Пример #1
0
 public CheckByteArray(PilePointer pp, int il, byte fb, byte lb)
 {
     Ptr       = pp;
     IdxLast   = il;
     FirstByte = fb;
     LastByte  = lb;
 }
Пример #2
0
        private PilePointer findPP(string Key)
        {
            char[]         keys      = Key.ToCharArray();
            string         strKey    = "";
            PilePointer    currentPP = m_Root;
            PrefixTreeNode current   = (PrefixTreeNode)m_Pile.Get(currentPP);
            bool           contains  = false;

            foreach (char charKey in keys)
            {
                strKey += charKey;
                int i = 0;
                contains = false;
                for (i = 0; i < current.Children.Length; i++)
                {
                    if (current.Children[i].Key > charKey)
                    {
                        break;
                    }
                    if (current.Children[i].Key == charKey)
                    {
                        contains = true;
                        break;
                    }
                }
                if (i >= current.Children.Length)
                {
                    break;
                }
                currentPP = current.Children[i].ValuePP;
                current   = (PrefixTreeNode)m_Pile.Get(currentPP);
            }
            return(contains ? currentPP : default(PilePointer));
        }
Пример #3
0
        private IEnumerable <KeyValuePair <string, T> > getNextValuePairs(PilePointer pp, string strKey)
        {
            if (pp == default(PilePointer))
            {
                yield break;
            }
            var current = (PrefixTreeNode)m_Pile.Get(pp);

            if (current.ValuePP != default(PilePointer))
            {
                yield return(new KeyValuePair <string, T>(strKey, (T)m_Pile.Get(current.ValuePP)));
            }
            foreach (Entry entry in current.Children)
            {
                if (entry.ValuePP != default(PilePointer))
                {
                    foreach (var nextValuePair in getNextValuePairs(entry.ValuePP, strKey + entry.Key))
                    {
                        yield return(nextValuePair);
                    }
                }
                else
                {
                    yield break;
                }
            }
        }
Пример #4
0
 internal LinkedListNode(IPile pile, PilePointer self, LinkedList <T> list)
 {
     m_Pile = pile;
     Node   = m_Pile.Get(self) as NodeData;
     if (Node == null)
     {
         throw new AccessViolationException();
     }
     List = list;
 }
Пример #5
0
        private void putValue(PilePointer currentPP, string key, T value, string strKey, int i)
        {
            if (i > key.Length)
            {
                throw new IndexOutOfRangeException();
            }
            if (currentPP == default(PilePointer))
            {
                throw new IndexOutOfRangeException();
            }
            var current = (PrefixTreeNode)m_Pile.Get(currentPP);

            if (key == strKey)
            {
                if (current.ValuePP != default(PilePointer))
                {
                    m_Pile.Put(current.ValuePP, value);
                }
                else
                {
                    current.ValuePP = m_Pile.Put(value);
                    m_Pile.Put(currentPP, current);
                    m_Count++;
                }
                return;
            }
            for (int j = 0; j < current.Children.Length; j++)
            {
                if (current.Children[j].ValuePP == default(PilePointer))
                {
                    var   tmp   = newPrefixTreeNode();
                    Entry entry = new Entry()
                    {
                        Key = key[i], ValuePP = m_Pile.Put(tmp)
                    };
                    insertEntry(j, ref current.Children, entry);
                    m_Pile.Put(currentPP, current);
                }
                else if (current.Children[j].Key > key[i])
                {
                    var   tmp   = newPrefixTreeNode();
                    Entry entry = new Entry()
                    {
                        Key = key[i], ValuePP = m_Pile.Put(tmp)
                    };
                    insertEntry(j, ref current.Children, entry);
                    m_Pile.Put(currentPP, current);
                }
                if (current.Children[j].Key == key[i])
                {
                    putValue(current.Children[j].ValuePP, key, value, strKey + current.Children[j].Key, i + 1);
                    break;
                }
            }
        }
Пример #6
0
        private T find(string key)
        {
            T           result    = default(T);
            PilePointer currentPP = findPP(key);

            if (currentPP != default(PilePointer))
            {
                PrefixTreeNode current = (PrefixTreeNode)m_Pile.Get(currentPP);
                result = current.ValuePP != default(PilePointer) ? (T)m_Pile.Get(current.ValuePP) : default(T);
            }
            return(result);
        }
Пример #7
0
        private void setValue(string key, T value)
        {
            char[]         keys      = key.ToCharArray();
            string         strKey    = "";
            PilePointer    currentPP = m_Root;
            PrefixTreeNode current   = (PrefixTreeNode)m_Pile.Get(currentPP);

            foreach (char charKey in keys)
            {
                strKey += charKey;
                int i = 0;
                for (i = 0; i < current.Children.Length; i++)
                {
                    if (current.Children[i].ValuePP == default(PilePointer))
                    {
                        var   tmp   = newPrefixTreeNode();
                        Entry entry = new Entry()
                        {
                            Key = charKey, ValuePP = m_Pile.Put(tmp)
                        };
                        insertEntry(i, ref current.Children, entry);
                        m_Pile.Put(currentPP, current);
                    }
                    else if (current.Children[i].Key > charKey)
                    {
                        var   tmp   = newPrefixTreeNode();
                        Entry entry = new Entry()
                        {
                            Key = charKey, ValuePP = m_Pile.Put(tmp)
                        };
                        insertEntry(i, ref current.Children, entry);
                        m_Pile.Put(currentPP, current);
                    }
                    if (current.Children[i].Key == charKey)
                    {
                        break;
                    }
                }
                currentPP = current.Children[i].ValuePP;
                current   = (PrefixTreeNode)m_Pile.Get(currentPP);
            }
            if (current.ValuePP != default(PilePointer))
            {
                m_Pile.Put(current.ValuePP, value);
            }
            else
            {
                current.ValuePP = m_Pile.Put(value);
                m_Pile.Put(currentPP, current);
                m_Count++;
            }
        }
Пример #8
0
        public bool Remove(string key)
        {
            bool        result    = false;
            PilePointer currentPP = findPP(key);

            if (currentPP != default(PilePointer))
            {
                PrefixTreeNode current = (PrefixTreeNode)m_Pile.Get(currentPP);
                m_Pile.Delete(current.ValuePP);
                current.ValuePP = default(PilePointer);
                m_Pile.Put(currentPP, current);
                m_Count--;
            }

            return(result);
        }
Пример #9
0
        public void StringCorrectess(int len, int deleteEvery, int parallel)
        {
            using (var pile = new DefaultPile())
            {
                pile.Start();

                var bag     = new ConcurrentBag <PilePointer>();
                var deleted = 0;
                Parallel.For(0, len, new ParallelOptions {
                    MaxDegreeOfParallelism = parallel
                },
                             (i) =>
                {
                    var str = new string('a', i);

                    PilePointer pp = PilePointer.Invalid;
                    if (i % 2 == 0)
                    {
                        if (bag.TryTake(out pp))
                        {
                            pile.Put(pp, str);
                        }
                    }

                    pp = pile.Put(str, preallocateBlockSize: i + 100);

                    var got = pile.Get(pp) as string;

                    Aver.AreEqual(str, got);

                    if (i % deleteEvery == 0)
                    {
                        PilePointer dp;
                        if (bag.TryTake(out dp))
                        {
                            if (pile.Delete(dp, false))
                            {
                                Interlocked.Increment(ref deleted);
                            }
                        }
                        bag.Add(pp);
                    }
                });

                Console.WriteLine("Deleted {0:n0}", deleted);
            }
        }
Пример #10
0
        private void clearItem(PilePointer pp)
        {
            if (pp == default(PilePointer))
            {
                return;
            }
            PrefixTreeNode current = (PrefixTreeNode)m_Pile.Get(pp);

            foreach (Entry entry in current.Children)
            {
                if (entry.ValuePP != default(PilePointer))
                {
                    clearItem(entry.ValuePP);
                }
            }
            if (current.ValuePP != default(PilePointer))
            {
                m_Pile.Delete(current.ValuePP);
            }
            m_Pile.Delete(pp);
        }
Пример #11
0
        private void getNextKey(ref string[] result, PilePointer pp, ref int i, string strKey)
        {
            if (pp == default(PilePointer))
            {
                return;
            }
            var current = (PrefixTreeNode)m_Pile.Get(pp);

            if (current.ValuePP != default(PilePointer))
            {
                result[i++] = strKey;
            }
            foreach (Entry entry in current.Children)
            {
                if (entry.ValuePP != default(PilePointer))
                {
                    getNextKey(ref result, entry.ValuePP, ref i, strKey + entry.Key);
                }
                else
                {
                    break;
                }
            }
        }
Пример #12
0
      /// <summary>
      /// Deletes object from pile by its pointer returning true if there is no access violation
      /// and pointer is pointing to the valid object, throws otherwise unless
      /// throwInvalid is set to false
      /// </summary>
      public bool Delete(PilePointer ptr, bool throwInvalid = true)
      {
        if (!Running) return false;

        var segs = m_Segments;
        if (ptr.Segment<0 || ptr.Segment>=segs.Count)
        {
           if (throwInvalid) throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());
           return false;
        }


        var seg = segs[ptr.Segment];
        if (seg==null || seg.DELETED!=0)
        {
          if (throwInvalid) throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());
          return false;
        }

        Interlocked.Increment(ref m_stat_DeleteCount);

        var removeEmptySegment = false;

        if (!getWriteLock(seg)) return false;//Service shutting down
        try
        {
          //2nd check under lock
          if (seg.DELETED!=0) throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());

          var data = seg.Data;
          var addr = ptr.Address;
          if (addr<0 || addr>=data.LongLength-CHUNK_HDER_SZ)
          {
            if (throwInvalid) throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_ADDR_EOF_ERROR + ptr.ToString());
            return false;
          }

          var cflag = readChunkFlag(data, addr); addr+=3;
          if (cflag!=chunkFlag.Used)
          {
            if (throwInvalid) throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_ADDR_CHUNK_FLAG_ERROR + ptr.ToString());
            return false;
          }
       
          seg.Deallocate(ptr.Address);

     
          //release segment
          //if nothing left allocated and either reuseSpace or 50/50 chance
          if (seg.ObjectCount==0 && (m_AllocMode==AllocationMode.ReuseSpace || (ptr.Address & 1) == 1))
          {
            Thread.VolatileWrite(ref seg.DELETED, 1);//Mark as deleted
            removeEmptySegment = true;
          }
        }
        finally
        {
          releaseWriteLock(seg);
        }

        if (removeEmptySegment) //it is ok that THIS is not under segment write lock BECAUSE
          lock(m_SegmentsLock)  // the segment was marked as DELETED, and it can not be re-allocated as it was marked under the lock
          {
               
              var newSegs = new List<_segment>(m_Segments);
              if (newSegs.Count>0)//safeguard, always true
              {
                  if (newSegs.Count==1)
                  {
                    if (newSegs[0]==seg) newSegs.Clear();
                  }
                  else
                  if (seg==newSegs[newSegs.Count-1])
                  newSegs.Remove( seg );
                  else
                  {
                    for(var k=0; k<newSegs.Count; k++)
                    if (newSegs[k] == seg)
                    {
                      newSegs[k] = null;
                      break;
                    }
                  }
              }
              m_Segments = newSegs;//atomic
          }//lock barrier


        return true;
      }
Пример #13
0
      /// <summary>
      /// Returns a CLR object by its pointer or throws access violation if pointer is invalid 
      /// </summary>
      public object Get(PilePointer ptr)
      {
        if (!Running) return null;

        var segs = m_Segments;
        if (ptr.Segment<0 || ptr.Segment>=segs.Count)
         throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());


        var seg = segs[ptr.Segment];
        if (seg==null || seg.DELETED!=0)
          throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());
        
        Interlocked.Increment(ref m_stat_GetCount);

        if (!getReadLock(seg)) return null;//Service shutting down
        try
        {
          //2nd check under lock
          if (seg.DELETED!=0) throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());

          var data = seg.Data;
          var addr = ptr.Address;
          if (addr<0 || addr>=data.LongLength-CHUNK_HDER_SZ)
           throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_ADDR_EOF_ERROR + ptr.ToString());

          var cflag = readChunkFlag(data, addr); addr+=3;
          if (cflag!=chunkFlag.Used)
           throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_ADDR_CHUNK_FLAG_ERROR + ptr.ToString());

          var payloadSize = data.ReadBEInt32(ref addr);
          if (payloadSize>data.Length)
           throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_ADDR_PAYLOAD_SIZE_ERROR.Args(ptr, payloadSize)); 

          //not used now
          //var serVer = data[addr];
          addr++;

          return deserialize(data, addr, payloadSize);
        }
        finally
        {
          releaseReadLock(seg);
        }
      }
Пример #14
0
      /// <summary>
      /// Puts a CLR object into the pile and returns a newly-allocated pointer.
      /// Throws out-of-space if there is not enough space in the pile and limits are set.
      /// Optional lifeSpanSec is ignored by this implementation
      /// </summary>
      public PilePointer Put(object obj, uint lifeSpanSec = 0)
      {  
        if (!Running) return PilePointer.Invalid;
        
        if (obj==null) throw new PileException(StringConsts.ARGUMENT_ERROR+GetType().Name+".Put(obj==null)");

        Interlocked.Increment(ref m_stat_PutCount);

        //1 serialize to determine the size
        int serializedSize;
        byte serializerVersion;
        var buffer = serialize(obj, out serializedSize, out serializerVersion);

        var payloadSize = IntMath.Align8(serializedSize);
        var chunkSize = CHUNK_HDER_SZ + payloadSize;


        if (chunkSize>m_SegmentSize)
         throw new PileOutOfSpaceException(StringConsts.PILE_OBJECT_LARGER_SEGMENT_ERROR.Args(payloadSize));

        while(true)
        {
            if (!Running) return PilePointer.Invalid;

            var segs = m_Segments;

            for(var idxSegment=0; idxSegment<segs.Count; idxSegment++)
            {
              var seg = segs[idxSegment];
              if (seg==null) continue;
              if (seg.DELETED!=0) continue;

              var sused = seg.UsedBytes;
              if (seg.FreeCapacity > chunkSize) 
              {
                 if (!getWriteLock(seg)) return PilePointer.Invalid;
                 try
                 {
                   if (Thread.VolatileRead(ref seg.DELETED)==0 && seg.FreeCapacity > chunkSize)
                   {
                     var adr = seg.Allocate(buffer, payloadSize, serializerVersion); 
                     if (adr>=0) return new PilePointer(idxSegment, adr);//allocated before crawl
                    
                     var utcNow = DateTime.UtcNow;
                     if ((utcNow - seg.LastCrawl).TotalSeconds > (m_AllocMode==AllocationMode.FavorSpeed ? 30 : 5))
                     {
                         //could not fit, try to reclaim
                         seg.Crawl();
                         seg.LastCrawl = utcNow;
                     
                         //try again
                         adr = seg.Allocate(buffer, payloadSize, serializerVersion); 
                         if (adr>=0) return new PilePointer(idxSegment, adr);//allocated after crawl
                     }
                     //if we are here - still could not allocate, will try next segment in iteration
                   }
                 }
                 finally
                 {
                   releaseWriteLock(seg);
                 }
              }
            }//for
        
            //if we are here, we still could not allocate space of existing segments
            if (m_AllocMode==AllocationMode.FavorSpeed) break;

            var nsegs = m_Segments;
            if (segs.Count >= nsegs.Count) break;//if segment list grew already, repeat the whole thing again as more space may have become available 
        }//while 
        
        //allocate segment
        lock(m_SegmentsLock)
        {
           if (
               (m_MaxMemoryLimit>0  && AllocatedMemoryBytes+m_SegmentSize     > m_MaxMemoryLimit  )||
               (m_MaxSegmentLimit>0 && (m_Segments.Count( s => s!=null ) + 1) > m_MaxSegmentLimit )
              )
           throw new PileOutOfSpaceException(StringConsts.PILE_OUT_OF_SPACE_ERROR.Args(m_MaxMemoryLimit, m_MaxSegmentLimit, m_SegmentSize));
        
           var newSeg = new _segment(this);
           var newSegs = new List<_segment>(m_Segments);
           newSegs.Add( newSeg );
           var adr = newSeg.Allocate(buffer, payloadSize, serializerVersion); 
           var pp = new PilePointer(newSegs.Count-1, adr);
           m_Segments = newSegs;   
           return pp;
        }
      }
Пример #15
0
      public int SizeOf(PilePointer ptr)
      {
        if (!Running) return 0;
       
        var segs = m_Segments;
        if (ptr.Segment<0 || ptr.Segment>=segs.Count)
         throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());


        var seg = segs[ptr.Segment];
        if (seg==null || seg.DELETED!=0)
          throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());

        if (!getReadLock(seg)) return 0;//Service shutting down
        try
        {
          //2nd check under lock
          if (seg.DELETED!=0) throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_SEGMENT_ERROR + ptr.ToString());

          var data = seg.Data;
          var addr = ptr.Address;
          if (addr<0 || addr>=data.LongLength-CHUNK_HDER_SZ)
           throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_ADDR_EOF_ERROR + ptr.ToString());

          var cflag = readChunkFlag(data, addr); addr+=3;
          if (cflag!=chunkFlag.Used)
           throw new PileAccessViolationException(StringConsts.PILE_AV_BAD_ADDR_CHUNK_FLAG_ERROR + ptr.ToString());

          var payloadSize = data.ReadBEInt32(ref addr);
          return payloadSize;
        }
        finally
        {
          releaseReadLock(seg);
        }
      }
Пример #16
0
 public bool Rejuvenate(PilePointer ptr)
 {
   return false;
 } 
Пример #17
0
 public CheckTRow(PilePointer ptr, GDID id, string address)
 {
     Ptr     = ptr;
     Id      = id;
     Address = address;
 }
Пример #18
0
 public PileEntry(PilePointer ptr, DataType tp, int size)
 {
     Pointer = ptr;
     Type    = tp;
     Size    = size;
 }
Пример #19
0
        public AllTypesDoc Populate(bool withDoc = true)
        {
            Enum      = CustomEnumType.DElement;
            EnumN     = CustomEnumType.C;
            EnumArray = new CustomEnumType[] { CustomEnumType.A, CustomEnumType.B };
            EnumList  = new List <CustomEnumType> {
                CustomEnumType.C, CustomEnumType.DElement
            };
            EnumNArray = new CustomEnumType?[] { null, null, CustomEnumType.B };
            EnumNList  = new List <CustomEnumType?> {
                CustomEnumType.C, null, null, CustomEnumType.DElement
            };

            if (withDoc)
            {
                Doc      = new AllTypesDoc().Populate(false);
                DocArray = new AllTypesDoc[] { null, null, new AllTypesDoc().Populate(false) };
                DocList  = new List <AllTypesDoc> {
                    new AllTypesDoc().Populate(false)
                };
            }

            Gdid      = new GDID(12, 23423);
            GdidN     = new GDID(24, 243534);
            GdidArray = new GDID[] { new GDID(122, 2342543), new GDID(122, 233423), new GDID(12, 232423) };
            GdidList  = new List <GDID> {
                new GDID(122, 2342543), new GDID(122, 233423), new GDID(12, 232423)
            };
            GdidNArray = new GDID?[] { new GDID(122, 2342543), null, new GDID(12, 232423) };
            GdidNList  = new List <GDID?> {
                null, new GDID(122, 233423), new GDID(12, 232423)
            };


            GdidSymbol      = new GDIDSymbol(new GDID(12, 23423), "fsdfsd");
            GdidSymbolN     = new GDIDSymbol(new GDID(312, 323423), "jezl kulaz");
            GdidSymbolArray = new GDIDSymbol[] { new GDIDSymbol(new GDID(1, 53), "fs44dfsd"), new GDIDSymbol(new GDID(2, 923), "liopa") };
            GdidSymbolList  = new List <GDIDSymbol> {
                new GDIDSymbol(new GDID(1, 53), "fs44dfsd"), new GDIDSymbol(new GDID(2, 923), "liopa")
            };
            GdidSymbolNArray = new GDIDSymbol?[] { null, new GDIDSymbol(new GDID(2, 923), "liopa") };
            GdidSymbolNList  = new List <GDIDSymbol?> {
                new GDIDSymbol(new GDID(1, 53), "fs44dfsd"), null
            };

            Guid      = System.Guid.NewGuid();
            GuidN     = System.Guid.NewGuid();
            GuidArray = new Guid[] { System.Guid.NewGuid(), System.Guid.NewGuid() };
            GuidList  = new List <Guid> {
                System.Guid.NewGuid(), System.Guid.NewGuid(), System.Guid.NewGuid()
            };
            GuidNArray = new Guid?[] { null, System.Guid.NewGuid() };
            GuidNList  = new List <Guid?> {
                System.Guid.NewGuid(), null
            };


            Atom      = Atom.Encode("a");
            AtomN     = Atom.Encode("ae3");
            AtomArray = new Atom[] { Atom.Encode("a2e3"), Atom.Encode("a1e3") };
            AtomList  = new List <Atom> {
                Atom.Encode("a3"), Atom.Encode("23"), Atom.Encode("r4")
            };
            AtomNArray = new Atom?[] { null, Atom.Encode("a3") };
            AtomNList  = new List <Atom?> {
                Atom.Encode("2a3"), null
            };


            Fid      = new FID(23);
            FidN     = new FID(323);
            FidArray = new FID[] { new FID(23), new FID(123) };
            FidList  = new List <FID> {
                new FID(233), new FID(23), new FID(23)
            };
            FidNArray = new FID?[] { null, new FID(223) };
            FidNList  = new List <FID?> {
                new FID(423), null
            };

            Pileptr      = new PilePointer(1, 23);
            PileptrN     = new PilePointer(1, 23);
            PileptrArray = new PilePointer[] { new PilePointer(1, 243), new PilePointer(1, 223) };
            PileptrList  = new List <PilePointer> {
                new PilePointer(21, 23), new PilePointer(1, 23), new PilePointer(1, 263)
            };
            PileptrNArray = new PilePointer?[] { null, new PilePointer(1, 293) };
            PileptrNList  = new List <PilePointer?> {
                new PilePointer(1, 223), null
            };


            NLSMap      = new NLSMap("{eng: {n: 'Cucumber',d: 'It is green'}, deu: {n: 'Gurke',d: 'Es ist grün'}}");
            NLSMapN     = new NLSMap("{eng: {n: 'Cur',d: 'Is'}}");
            NLSMapArray = new NLSMap[] { new NLSMap("{eng: {n: 'Cewqeur',d: 'Is'}}"), new NLSMap("{eng: {n: 'Cur23',d: 'Isee'}}") };
            NLSMapList  = new List <NLSMap> {
                new NLSMap("{eng: {n: 'Cr',d: 'Is'}}"), new NLSMap("{eng: {n: 'Currr',d: 'Iws'}}"), new NLSMap("{eng: {n: 'ertCur',d: 'rtIs'}}")
            };
            NLSMapNArray = new NLSMap?[] { null, new NLSMap("{eng: {n: 'Cweur',d: 'Is'}}") };
            NLSMapNList  = new List <NLSMap?> {
                new NLSMap("{eng: {n: 'Cuer',d: 'Is'}}"), null
            };

            Amount      = new Amount("usd", 123.11m);
            AmountN     = new Amount("usd", 223.11m);
            AmountArray = new Amount[] { new Amount("usd", 123.11m), new Amount("usd", 223.11m) };
            AmountList  = new List <Amount> {
                new Amount("usd", 123.11m), new Amount("usd", 253.11m), new Amount("usd", 243.11m)
            };
            AmountNArray = new Amount?[] { null, new Amount("usd", 323.11m) };
            AmountNList  = new List <Amount?> {
                new Amount("usd", 523.11m), null
            };

            StringMap = new StringMap {
                { "a", "aaa" }, { "b", "bbb" }
            };
            StringMapArray = new StringMap[] { new StringMap {
                                                   { "a", "aaa" }, { "b", "bbb" }
                                               }, null, new StringMap {
                                                   { "23a", "23423weaaa" }
                                               } };
            StringMapList = new List <StringMap> {
                new StringMap {
                    { "a", "aaa" }, { "b", "bbb" }
                }, null, new StringMap {
                    { "23a", "23423weaaa" }
                }
            };

            this.String      = "kazapzon";
            this.StringArray = new string[] { "mox", null, null, "zaporojets", "kefal" };
            this.StringList  = new List <string> {
                "mox", null, null, "zaporojets", "kefal"
            };


            Int      = -7;
            IntN     = -789;
            IntArray = new int[] { 3, 8, 9, -23, 234, 0 };
            IntList  = new List <int>()
            {
                0, 1, 4, 8
            };
            IntNArray = new int?[] { 3, null, 9, -23, 234, 0 };
            IntNList  = new List <int?>()
            {
                0, 1, null, 8
            };

            UInt      = 7;
            UIntN     = 789;
            UIntArray = new uint[] { 3, 8, 9, 23, 234, 0 };
            UIntList  = new List <uint>()
            {
                0, 1, 4, 8
            };
            UIntNArray = new uint?[] { 3, null, 9, 23, 234, 0 };
            UIntNList  = new List <uint?>()
            {
                0, 1, null, 8
            };


            //-------------------------------------------------------

            Long      = -74;
            LongN     = -7893;
            LongArray = new long[] { 43, 8, 59, -243, 234, 0 };
            LongList  = new List <long>()
            {
                03, 1, 43, 8
            };
            LongNArray = new long?[] { 3, null, 9, -23, 2344, 0 };
            LongNList  = new List <long?>()
            {
                0, 1, null, 58
            };

            ULong      = 78;
            ULongN     = 159;
            ULongArray = new ulong[] { 3, 5, 19, 23, 24, 0 };
            ULongList  = new List <ulong>()
            {
                0, 1, 7, 9
            };
            ULongNArray = new ulong?[] { 3, null, 9, 5, 24, 0 };
            ULongNList  = new List <ulong?>()
            {
                0, 7, null, 8
            };

            Short      = -4;
            ShortN     = -73;
            ShortArray = new short[] { 16, 8, 59, -23, 34, 0 };
            ShortList  = new List <short>()
            {
                0, 3, 1, 4, 8
            };
            ShortNArray = new short?[] { 3, null, 9, -23, 24, 0 };
            ShortNList  = new List <short?>()
            {
                0, 4, null, 5
            };

            UShort      = 5;
            UShortN     = 59;
            UShortArray = new ushort[] { 3, 5, 67, 23, 38, 0 };
            UShortList  = new List <ushort>()
            {
                0, 1, 5, 9
            };
            UShortNArray = new ushort?[] { 3, null, 9, 0, 4, 0 };
            UShortNList  = new List <ushort?>()
            {
                0, 7, null, 8, 9
            };


            //----
            Byte      = 15;
            ByteN     = 22;
            ByteArray = new byte[] { 16, 22, 59, 28, 34, 0 };
            ByteList  = new List <byte>()
            {
                0, 8, 1, 6, 3
            };
            ByteNArray = new byte?[] { 3, null, 9, 15, 33, 0 };
            ByteNList  = new List <byte?>()
            {
                0, 4, null, 5
            };

            Sbyte      = 6;
            SbyteN     = 97;
            SbyteArray = new sbyte[] { 3, 38, 45, 2, 38, 0 };
            SbyteList  = new List <sbyte>()
            {
                0, 1, 7, 4
            };
            SbyteNArray = new sbyte?[] { 3, null, 2, 6, 4, 0 };
            SbyteNList  = new List <sbyte?>()
            {
                0, 7, null, 8, 9
            };

            Char      = 'a';
            CharN     = 'c';
            CharArray = new char[] { 'b', 'c', 'f' };
            CharList  = new List <char>()
            {
                'a', 'd', 'e', 'h'
            };
            CharNArray = new char?[] { 'v', 'r', 'u', };
            CharNList  = new List <char?>()
            {
                'w', 'e', 'r', 't'
            };

            Bool      = true;
            BoolN     = false;
            BoolArray = new bool[] { true, false, false, true };
            BoolList  = new List <bool>()
            {
                true, true, false
            };
            BoolNArray = new bool?[] { false, false, true };
            BoolNList  = new List <bool?>()
            {
                true, false, false
            };

            Float      = -8;
            FloatN     = -79;
            FloatArray = new float[] { 3.89f, 8, 9, -2332.5f, 34, 0 };
            FloatList  = new List <float>()
            {
                0, 1.3f, 4, 8
            };
            FloatNArray = new float?[] { 3, null, 9, -23, 234, 0 };
            FloatNList  = new List <float?>()
            {
                0, 1, null, 8
            };

            this.Double = -7;
            DoubleN     = -89;
            DoubleArray = new double[] { 3.2, 8, 9, -3.93, 23, 0 };
            DoubleList  = new List <double>()
            {
                0.1, 1.7, 4, 8
            };
            DoubleNArray = new double?[] { 3, null, 9, -23, 234, 0 };
            DoubleNList  = new List <double?>()
            {
                0, 1, null, 8
            };

            this.Decimal = 2;
            DecimalN     = 89;
            DecimalArray = new decimal[] { 7, 8, 9, 3, 234, 0 };
            DecimalList  = new List <decimal>()
            {
                0, 1, 4, 8
            };
            DecimalNArray = new decimal?[] { 3, null, 9, -23, 234, 0 };
            DecimalNList  = new List <decimal?>()
            {
                0, 1, null, 8
            };

            Timespan      = TimeSpan.FromHours(2.45);
            TimespanN     = TimeSpan.FromHours(8.19);
            TimespanArray = new TimeSpan[] { TimeSpan.FromHours(2.001), TimeSpan.FromHours(4.72) };
            TimespanList  = new List <TimeSpan>()
            {
                TimeSpan.FromHours(12.45), TimeSpan.FromHours(11.09)
            };
            TimespanNArray = new TimeSpan?[] { TimeSpan.FromHours(2.435), null, TimeSpan.FromHours(32.45) };
            TimespanNList  = new List <TimeSpan?>()
            {
                TimeSpan.FromHours(2.45), null, TimeSpan.FromHours(7.401)
            };

            Datetime      = new DateTime(1980, 2, 3);
            DatetimeN     = new DateTime(1980, 2, 3);
            DatetimeArray = new DateTime[] { new DateTime(1980, 2, 3), new DateTime(1980, 2, 3) };
            DatetimeList  = new List <DateTime>()
            {
                new DateTime(1980, 2, 3), new DateTime(1980, 2, 3)
            };
            DatetimeNArray = new DateTime?[] { new DateTime(1980, 2, 3), null, new DateTime(1980, 2, 3) };
            DatetimeNList  = new List <DateTime?>()
            {
                new DateTime(1980, 2, 3), null, new DateTime(1980, 2, 3)
            };

            return(this);
        }
Пример #20
0
        private void trax()
        {
            __threadCount     = tbTraxThreads.Text.AsInt(1);
            __writesSec       = tbTraxWrites.Text.AsInt(0);
            __delSec          = tbTraxDeletes.Text.AsInt(0);
            __payloadVariance = tbTraxVariance.Text.AsInt(0);
            __payloadType     = rbtPerson.Checked ? ptype.Person : rbtPerson2.Checked ? ptype.Person2 : rbtString.Checked ? ptype.String : ptype.ByteArray;

            var added = 0;

            while (chkTraxer.Checked && m_Traxers.Count < __threadCount)
            {
                var context = new tcontext();
                var thread  = new Thread(
                    (ctx) =>
                {
                    try
                    {
                        var pps = new PilePointer[4000000];
                        for (var i = 0; i < pps.Length; i++)
                        {
                            pps[i] = PilePointer.Invalid;
                        }
                        var ppi = 0;
                        var di  = 0;

                        while (m_Pile.Running && !((tcontext)ctx).STOP)
                        {
                            var tc = __threadCount;
                            if (tc == 0)
                            {
                                return;
                            }

                            var wc = __writesSec / tc;
                            var dc = __delSec / tc;

                            var w = 0;
                            var d = 0;
                            while (w < wc || d < dc)
                            {
                                if (w < wc)
                                {
                                    object payload;

                                    if (__payloadType == ptype.Person)
                                    {
                                        var p = Person.MakeFake();
                                        if (__payloadVariance > 0)
                                        {
                                            p.BinData = new byte[IntMath.ChangeByRndPct(__payloadVariance, -0.25f)];
                                        }
                                        payload = p;
                                    }
                                    else if (__payloadType == ptype.Person2)
                                    {
                                        var p = Person2.MakeFake2();
                                        if (__payloadVariance > 0)
                                        {
                                            p.BinData = new byte[IntMath.ChangeByRndPct(__payloadVariance, -0.25f)];
                                        }
                                        payload = p;
                                    }
                                    else if (__payloadType == ptype.String)
                                    {
                                        payload = new string(' ', __payloadVariance);
                                    }
                                    else
                                    {
                                        payload = new byte[__payloadVariance];
                                    }



                                    var pp   = m_Pile.Put(payload);
                                    pps[ppi] = pp;
                                    ppi++;
                                    if (ppi == pps.Length)
                                    {
                                        ppi = 0;
                                    }
                                    w++;
                                }

                                if (d < dc)
                                {
                                    if (di == pps.Length)
                                    {
                                        di = 0;
                                    }
                                    var pp = pps[di];
                                    if (pp.Address >= 0)
                                    {
                                        m_Pile.Delete(pp);
                                        pps[di] = PilePointer.Invalid;
                                    }
                                    d++;
                                    di++;
                                }
                            }
                        }
                    }
                    catch (Exception error)//abort etc..
                    {
                        m_Errors.Enqueue(error.ToMessageWithType());
                    }
                });
                m_Traxers.Add(context);
                thread.Start(context);
                added++;
            }

            if (added > 0)
            {
                log("{0} added {1} threads".Args(DateTime.Now, added));
            }

            var removed = 0;

            while ((!chkTraxer.Checked && m_Traxers.Count > 0) || m_Traxers.Count > __threadCount)
            {
                m_Traxers[0].STOP = true;
                m_Traxers.RemoveAt(0);
                removed++;
            }

            if (removed > 0)
            {
                log("{0} removed {1} threads".Args(DateTime.Now, removed));
            }
        }
Пример #21
0
 public CheckTRow(PilePointer ptr, GDID id, string address)
 {
     Ptr = ptr;
     Id = id;
     Address = address;
 }
Пример #22
0
        public void TestThreadSafety(int cnt, int tcount, int seconds)
        {
            using (var pile = new DefaultPile())
            {
                // pile.SegmentSize = 64 * 1024 * 1024;
                pile.Start();

                var data = new PilePointer[cnt];
                for (var i = 0; i < cnt; i++)
                {
                    data[i] = pile.Put(new byte[0], preallocateBlockSize: Memory.PTR_RAW_BYTE_SIZE + (137 * (i % 17)));
                }

                var lst = new List <Task>();

                long statRead   = 0;
                long statPut    = 0;
                long statDelete = 0;

                var sw         = Stopwatch.StartNew();
                var sd         = DateTime.UtcNow;
                var deleteLock = new object();
                for (var i = 0; i < tcount; i++)
                {
                    lst.Add(Task.Factory.StartNew(() =>
                    {
                        while (true)
                        {
                            var now = DateTime.UtcNow;
                            if ((now - sd).TotalSeconds > seconds)
                            {
                                break;
                            }

                            var it = ExternalRandomGenerator.Instance.NextScaledRandomInteger(10, 100);
                            for (var j = 0; j < it; j++)
                            {
                                var pp = data[ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, cnt - 1)];
                                Aver.IsTrue(pile.Get(pp) is byte[]);
                                Interlocked.Increment(ref statRead);
                            }

                            it = ExternalRandomGenerator.Instance.NextScaledRandomInteger(10, 100);
                            for (var j = 0; j < it; j++)
                            {
                                var pp = data[ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, cnt - 1)];
                                Aver.IsTrue(pile.Put(pp, new byte[ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, 3791)], link: true));
                                Interlocked.Increment(ref statPut);
                            }

                            if (ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, 100) > 50 && Monitor.TryEnter(deleteLock))
                            {
                                try
                                {
                                    var newData  = (PilePointer[])data.Clone();
                                    it           = ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, 10 + (cnt / 2));
                                    var toDelete = new List <PilePointer>();
                                    for (var j = 0; j < it; j++)
                                    {
                                        var idx = ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, cnt - 1);
                                        toDelete.Add(newData[idx]);
                                        newData[idx] = pile.Put(new byte[12], preallocateBlockSize: ExternalRandomGenerator.Instance.NextScaledRandomInteger(24, 1024));
                                    }
                                    data = newData;//atomic;
                                    Thread.Sleep(1000);
                                    foreach (var pp in toDelete)
                                    {
                                        Aver.IsTrue(pile.Delete(pp));
                                        Interlocked.Increment(ref statDelete);
                                    }
                                }
                                finally
                                {
                                    Monitor.Exit(deleteLock);
                                }
                            }
                        }
                    }, TaskCreationOptions.LongRunning));
                }

                Task.WaitAll(lst.ToArray());

                var el = sw.ElapsedMilliseconds;

                Console.WriteLine("Read {0:n0} at {1:n0} ops/sec".Args(statRead, statRead / (el / 1000d)));
                Console.WriteLine("Put {0:n0} at {1:n0} ops/sec".Args(statPut, statPut / (el / 1000d)));
                Console.WriteLine("Deleted {0:n0} at {1:n0} ops/sec".Args(statDelete, statDelete / (el / 1000d)));

                for (var i = 0; i < data.Length; i++)
                {
                    Aver.IsTrue(pile.Delete(data[i]));
                }


                Aver.AreEqual(0, pile.ObjectCount);
                Aver.AreEqual(0, pile.ObjectLinkCount);
                Aver.AreEqual(0, pile.AllocatedMemoryBytes);
            }
        }
Пример #23
0
 private void clearAll()
 {
     clearItem(m_Root);
     m_Root = default(PilePointer);
 }
Пример #24
0
        private void trax()
        {
            __threadCount     = tbTraxThreads.Text.AsInt(1);
            __writesSec       = tbTraxWrites.Text.AsInt(0);
            __delSec          = tbTraxDeletes.Text.AsInt(0);
            __payloadVariance = tbTraxVariance.Text.AsInt(0);

            var added = 0;

            while (chkTraxer.Checked && m_Traxers.Count < __threadCount)
            {
                var context = new tcontext();
                var thread  = new Thread(
                    (ctx) =>
                {
                    try
                    {
                        var pps = new PilePointer[2000000];
                        for (var i = 0; i < pps.Length; i++)
                        {
                            pps[i] = PilePointer.Invalid;
                        }
                        var ppi = 0;
                        var di  = 0;

                        while (m_Pile.Running && !((tcontext)ctx).STOP)
                        {
                            var tc = __threadCount;
                            if (tc == 0)
                            {
                                return;
                            }

                            var wc = __writesSec / tc;
                            var dc = __delSec / tc;

                            var w = 0;
                            var d = 0;
                            while (w < wc || d < dc)
                            {
                                if (w < wc)
                                {
                                    var obj = Person.MakeFake();

                                    if (__payloadVariance > 0)
                                    {
                                        obj.BinData = new byte[__payloadVariance];
                                    }

                                    var pp   = m_Pile.Put(obj);
                                    pps[ppi] = pp;
                                    ppi++;
                                    if (ppi == pps.Length)
                                    {
                                        ppi = 0;
                                    }
                                    w++;
                                }

                                if (d < dc)
                                {
                                    if (di == pps.Length)
                                    {
                                        di = 0;
                                    }
                                    var pp = pps[di];
                                    if (pp.Address >= 0)
                                    {
                                        m_Pile.Delete(pp);
                                        pps[di] = PilePointer.Invalid;
                                    }
                                    d++;
                                    di++;
                                }
                            }

                            Thread.Sleep(90 + ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, 20));
                        }
                    }
                    catch (Exception error)//abort etc..
                    {
                        m_Errors.Enqueue(error.ToMessageWithType());
                    }
                });
                m_Traxers.Add(context);
                thread.Start(context);
                added++;
            }

            if (added > 0)
            {
                log("{0} added {1} threads".Args(DateTime.Now, added));
            }

            var removed = 0;

            while ((!chkTraxer.Checked && m_Traxers.Count > 0) || m_Traxers.Count > __threadCount)
            {
                m_Traxers[0].STOP = true;
                m_Traxers.RemoveAt(0);
                removed++;
            }

            if (removed > 0)
            {
                log("{0} removed {1} threads".Args(DateTime.Now, removed));
            }
        }
Пример #25
0
        private void trax()
        {
            __threadCount = tbTraxThreads.Text.AsInt(1);
            __writesSec = tbTraxWrites.Text.AsInt(0);
            __delSec = tbTraxDeletes.Text.AsInt(0);
            __payloadVariance = tbTraxVariance.Text.AsInt(0);

            var added = 0;
            while (chkTraxer.Checked &&  m_Traxers.Count < __threadCount)
            {
              var context = new tcontext();
              var thread = new Thread(
              (ctx) =>
              {
            try
            {
              var pps = new PilePointer[2000000];
              for(var i=0; i<pps.Length; i++) pps[i] = PilePointer.Invalid;
              var ppi = 0;
              var di=0;

              while(m_Pile.Running && !((tcontext)ctx).STOP)
              {
                var tc = __threadCount;
                if (tc==0) return;

                var wc = __writesSec / tc;
                var dc = __delSec / tc;

                var w=0;
                var d=0;
                while(w<wc || d<dc)
                {
                  if (w<wc)
                  {
                    var obj = Person.MakeFake();

                    if (__payloadVariance>0)
                     obj.BinData = new byte[__payloadVariance];

                    var pp = m_Pile.Put( obj );
                    pps[ppi] = pp;
                    ppi++;
                    if (ppi==pps.Length) ppi = 0;
                    w++;
                  }

                  if (d<dc)
                  {
                      if (di==pps.Length) di = 0;
                      var pp = pps[di];
                      if (pp.Address>=0)
                      {
                        m_Pile.Delete( pp );
                        pps[di] = PilePointer.Invalid;
                      }
                      d++;
                      di++;
                  }
                }

                Thread.Sleep(90+ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, 20));

              }
            }
            catch(Exception error)//abort etc..
            {
              m_Errors.Enqueue(error.ToMessageWithType());
            }
              });
              m_Traxers.Add(context);
              thread.Start(context);
              added++;
            }

            if (added>0)
             log("{0} added {1} threads".Args(DateTime.Now, added));

            var removed = 0;
            while ((!chkTraxer.Checked&&m_Traxers.Count>0) || m_Traxers.Count > __threadCount)
            {
              m_Traxers[0].STOP = true;
              m_Traxers.RemoveAt(0);
              removed++;
            }

            if (removed>0)
             log("{0} removed {1} threads".Args(DateTime.Now, removed));
        }
Пример #26
0
 public CheckByteArray(PilePointer pp, int il, byte fb, byte lb)
 {
     Ptr = pp;
     IdxLast = il;
     FirstByte = fb;
     LastByte = lb;
 }