Example #1
0
        /// <summary>
        /// <see cref="BobNodeClient"/> constructor
        /// </summary>
        /// <param name="innerClient">Low-level BobNodeClient</param>
        /// <param name="keySerializer">Serializer for <typeparamref name="TKey"/>  (null for default serializer)</param>
        /// <param name="keySerializationPoolSize">Size of the Key serialization pool (null - shared pool, 0 or less - pool is disabled, 1 or greater - custom pool with specified size)</param>
        protected internal BobNodeClient(BobNodeClient innerClient, BobKeySerializer <TKey> keySerializer, int?keySerializationPoolSize)
        {
            if (innerClient == null)
            {
                throw new ArgumentNullException(nameof(innerClient));
            }

            _innerClient = innerClient;

            if (keySerializer != null || BobDefaultKeySerializers.TryGetKeySerializer <TKey>(out keySerializer))
            {
                _keySerializer = keySerializer;
            }
            else
            {
                throw new ArgumentException($"KeySerializer is null and no default key serializer found for key type '{typeof(TKey).Name}'", nameof(keySerializer));
            }

            keySerializationPoolSize = keySerializationPoolSize ?? innerClient.ConnectionParameters.KeySerializationPoolSize;
            if (keySerializationPoolSize == null)
            {
                _keySerializationPool = SharedKeySerializationArrayPools.GetOrCreateSharedPool(_keySerializer);
            }
            else if (keySerializationPoolSize.Value > 0)
            {
                _keySerializationPool = new ByteArrayPool(_keySerializer.SerializedSize, keySerializationPoolSize.Value);
            }
            else
            {
                _keySerializationPool = null;
            }
        }
Example #2
0
        public void RentReleaseTest(int poolSize, bool skipLocal)
        {
            using (var pool = new ByteArrayPool(sizeof(ulong), poolSize))
            {
                Assert.Equal(sizeof(ulong), pool.ByteArrayLength);
                Assert.Equal(poolSize, pool.MaxElementCount);

                HashSet <byte[]> uniqArrays = new HashSet <byte[]>();

                for (int i = 0; i < Math.Max(poolSize * 2 + 101, 100000); i++)
                {
                    byte[] array = pool.Rent(skipLocal: skipLocal);
                    Assert.NotNull(array);
                    uniqArrays.Add(array);
                    pool.Release(array, skipLocal: skipLocal);
                }

                if (poolSize > 0)
                {
                    Assert.True(uniqArrays.Count <= pool.FullCapacity);
                    Assert.True(uniqArrays.Count <= ByteArrayPool.GapSize + 1);
                }

                if (poolSize > 0 && !skipLocal)
                {
                    Assert.Single(uniqArrays);
                }
            }
        }
        public GrpcContentServer(
            ILogger logger,
            Capabilities serviceCapabilities,
            ISessionHandler <IContentSession> sessionHandler,
            IReadOnlyDictionary <string, IContentStore> storesByName,
            LocalServerConfiguration?localServerConfiguration = null)
        {
            Contract.RequiresNotNull(storesByName);

            _serviceCapabilities     = serviceCapabilities;
            _contentStoreByCacheName = storesByName;
            _bufferSize            = localServerConfiguration?.BufferSizeForGrpcCopies ?? ContentStore.Grpc.GrpcConstants.DefaultBufferSizeBytes;
            _gzipSizeBarrier       = localServerConfiguration?.GzipBarrierSizeForGrpcCopies ?? (_bufferSize * 8);
            _ongoingPushCountLimit = localServerConfiguration?.ProactivePushCountLimit ?? LocalServerConfiguration.DefaultProactivePushCountLimit;
            _traceGrpcOperations   = localServerConfiguration?.TraceGrpcOperations ?? false;
            _pool = new ByteArrayPool(_bufferSize);
            ContentSessionHandler = sessionHandler;

            _fileSystem       = localServerConfiguration?.FileSystem ?? new PassThroughFileSystem();
            _workingDirectory = (localServerConfiguration?.DataRootPath ?? _fileSystem.GetTempPath()) / "GrpcContentServer";

            GrpcAdapter = new ContentServerAdapter(this);

            Logger = logger;
        }
Example #4
0
        internal static ServerClientEventEntry <TServerClient> Create <T>(DeserializePacketHandler <T> deserialize)
        {
            ServerClientEventEntry <TServerClient, T> entry = new ServerClientEventEntry <TServerClient, T>();

            entry._deserializeAndRaise = (in Packet packet,
                                          IServer <TServerClient> server,
                                          TServerClient client,
                                          ushort responseID,
                                          out object?result) =>
            {
                if (deserialize(in packet, out T value))
                {
                    ByteArrayPool.Return(packet.Buffer);
                    entry.Raise(server, client, value, responseID);

                    // ReSharper disable once HeapView.PossibleBoxingAllocation
                    result = value;
                    return(true);
                }

                ByteArrayPool.Return(packet.Buffer);
                result = null;
                return(false);
            };

            return(entry);
        }
Example #5
0
        public void GetOrCreateTest(Type keyType)
        {
            void CoreLogic <TKey>()
            {
                BobKeySerializer <TKey> keySerializer = null;

                Assert.True(BobDefaultKeySerializers.TryGetKeySerializer <TKey>(out keySerializer));

                ByteArrayPool pool = SharedKeySerializationArrayPools.GetOrCreateSharedPool(keySerializer);

                Assert.NotNull(pool);
                Assert.True(pool.MaxElementCount > 0);
                Assert.Equal(keySerializer.SerializedSize, pool.ByteArrayLength);

                var pool2 = SharedKeySerializationArrayPools.GetOrCreateSharedPool(keySerializer);

                Assert.True(object.ReferenceEquals(pool, pool2));

                Assert.True(SharedKeySerializationArrayPools.TryGetSharedPool(keySerializer, out pool2));
                Assert.True(object.ReferenceEquals(pool, pool2));
            }

            var referenceDelegate = new Action(CoreLogic <int>);
            var typedDelegate     = (Action)Delegate.CreateDelegate(typeof(Action), referenceDelegate.Method.GetGenericMethodDefinition().MakeGenericMethod(keyType));

            typedDelegate();
        }
Example #6
0
        /// <summary>
        /// Cache for <see cref="GrpcCopyClient"/>.
        /// </summary>
        public GrpcCopyClientCache(Context context, GrpcCopyClientCacheConfiguration?configuration = null, IClock?clock = null)
        {
            configuration ??= new GrpcCopyClientCacheConfiguration();
            _configuration = configuration;

            _grpcCopyClientBufferPool = new ByteArrayPool(configuration.GrpcCopyClientConfiguration.ClientBufferSizeBytes);

            switch (_configuration.ResourcePoolVersion)
            {
            case GrpcCopyClientCacheConfiguration.PoolVersion.Disabled:
                break;

            case GrpcCopyClientCacheConfiguration.PoolVersion.V1:
                _resourcePool = new ResourcePool <GrpcCopyClientKey, GrpcCopyClient>(
                    context,
                    _configuration.ResourcePoolConfiguration,
                    (key) => new GrpcCopyClient(key, _configuration.GrpcCopyClientConfiguration, sharedBufferPool: _grpcCopyClientBufferPool),
                    clock);
                break;

            case GrpcCopyClientCacheConfiguration.PoolVersion.V2:
                _resourcePoolV2 = new ResourcePoolV2 <GrpcCopyClientKey, GrpcCopyClient>(
                    context,
                    _configuration.ResourcePoolConfiguration,
                    (key) => new GrpcCopyClient(key, _configuration.GrpcCopyClientConfiguration, sharedBufferPool: _grpcCopyClientBufferPool),
                    clock);
                break;
            }
        }
Example #7
0
 public ThreadAnonymousInnerClassHelper(TestPayloads outerInstance, int numDocs, ByteArrayPool pool, IndexWriter writer, string field)
 {
     this.outerInstance = outerInstance;
     this.numDocs       = numDocs;
     this.pool          = pool;
     this.writer        = writer;
     this.field         = field;
 }
Example #8
0
        public void Tests()
        {
            var pool = new ByteArrayPool(arraySize: 16, poolCapacity: 2);

            var idx1 = pool.New();

            Assert.Equal(1, pool.Count);

            var buffer1 = pool.GetBuffer(idx1);

            Assert.Equal(16, buffer1.Length);

            var idx2 = pool.New();

            Assert.Equal(2, pool.Count);

            var buffer2 = pool.GetBuffer(idx2);

            Assert.Equal(16, buffer2.Length);

            var idx3 = pool.New(); // out of capacity

            Assert.Equal(2, pool.Count);

            buffer1[0] = 1;
            buffer1[1] = 2;

            buffer2[0] = 3;
            buffer2[1] = 4;

            Assert.Equal(1, buffer1[0]);
            Assert.Equal(2, buffer1[1]);
            Assert.Equal(3, buffer2[0]);
            Assert.Equal(4, buffer2[1]);

            pool.Free(idx1);

            Assert.Equal(1, pool.Count);

            var idx4 = pool.New();

            Assert.Equal(2, pool.Count);

            var buffer4 = pool.GetBuffer(idx4);

            buffer4[0] = 5;
            buffer4[1] = 6;

            Assert.Equal(3, buffer2[0]);
            Assert.Equal(4, buffer2[1]);
            Assert.Equal(5, buffer4[0]);
            Assert.Equal(6, buffer4[1]);

            pool.Free(idx2);
            pool.Free(idx4);

            Assert.Equal(0, pool.Count);
        }
Example #9
0
 /// <inheritdoc />
 private protected override Buffer Create(TKey key, int length)
 {
     return(new Buffer.Time(
                ByteArrayPool.Rent(length), length, state =>
     {
         if (Remove(key))
         {
             ByteArrayPool.Return(((Buffer.Time)state !)._data);
         }
Example #10
0
 internal PoolingPayloadTokenStream(TestPayloads outerInstance, ByteArrayPool pool)
 {
     this.OuterInstance = outerInstance;
     this.Pool          = pool;
     Payload            = pool.Get();
     OuterInstance.GenerateRandomData(Payload);
     Term       = Encoding.UTF8.GetString((byte[])(Array)Payload);
     First      = true;
     PayloadAtt = AddAttribute <IPayloadAttribute>();
     TermAtt    = AddAttribute <ICharTermAttribute>();
 }
Example #11
0
 internal PoolingPayloadTokenStream(TestPayloads outerInstance, ByteArrayPool pool)
 {
     this.outerInstance = outerInstance;
     this.pool          = pool;
     payload            = pool.Get();
     this.outerInstance.GenerateRandomData(payload);
     term       = Encoding.UTF8.GetString(payload);
     first      = true;
     payloadAtt = AddAttribute <IPayloadAttribute>();
     termAtt    = AddAttribute <ICharTermAttribute>();
 }
Example #12
0
 internal PoolingPayloadTokenStream(TestPayloads enclosingInstance, ByteArrayPool pool)
 {
     InitBlock(enclosingInstance);
     this.pool = pool;
     payload   = pool.Get();
     Enclosing_Instance.GenerateRandomData(payload);
     term       = pool.BytesToString(payload);
     first      = true;
     payloadAtt = AddAttribute <IPayloadAttribute>();
     termAtt    = AddAttribute <ITermAttribute>();
 }
Example #13
0
        public void RentReleaseConcurrentAsyncTest(int poolSize, bool skipLocal, int threadCount)
        {
            using (var pool = new ByteArrayPool(sizeof(ulong), poolSize))
            {
                Assert.Equal(sizeof(ulong), pool.ByteArrayLength);
                Assert.Equal(poolSize, pool.MaxElementCount);

                HashSet <byte[]> uniqArrays = new HashSet <byte[]>();
                Barrier          bar        = new Barrier(threadCount + 1);

                async Task act()
                {
                    HashSet <byte[]> uniqArraysLocal = new HashSet <byte[]>();

                    bar.SignalAndWait(10000);

                    for (int i = 0; i < Math.Max(poolSize * 2 + 101, 100000); i++)
                    {
                        byte[] array = pool.Rent(skipLocal: skipLocal);
                        Assert.NotNull(array);
                        Assert.Equal(0, array[0]);
                        array[0] = 1;
                        await Task.Yield();

                        uniqArraysLocal.Add(array);
                        array[0] = 0;
                        pool.Release(array, skipLocal: skipLocal);
                    }

                    lock (uniqArrays)
                    {
                        foreach (var item in uniqArraysLocal)
                        {
                            uniqArrays.Add(item);
                        }
                    }
                }

                Task[] tasks = new Task[threadCount];
                for (int i = 0; i < tasks.Length; i++)
                {
                    tasks[i] = Task.Run(() => act().GetAwaiter().GetResult());
                }

                bar.SignalAndWait(10000);

                Task.WaitAll(tasks);

                if (poolSize > threadCount)
                {
                    Assert.True(uniqArrays.Count <= pool.FullCapacity + threadCount);
                }
            }
        }
Example #14
0
        private protected void DeserializeData(T arg0, uint commandid, byte[] data, int offset, int length,
                                               uint responseid)
        {
            switch (commandid)
            {
            case CommandID.PING:
            {
                SendTo(arg0, CommandID.PING, data, offset, length, responseid);
                break;
            }

            case CommandID.CONNECT:
            {
                InvokeClientConnected(arg0);
                SendTo(arg0, CommandID.CONNECT, data, offset, length, responseid);
                break;
            }

            case CommandID.DISCONNECT:
            {
                InvokeClientDisconnect(arg0, DisconnectReason.Graceful);
                break;
            }

            default:
            {
                if (_clients.TryGetValue(arg0, out TServerClient sClient))
                {
                    if (commandid <= Constants.USER_COMMAND_LIMIT && _dataReceivedCallbacks.TryGetValue(
                            commandid, out ServerClientEventEntry <T, TServerClient> scee))
                    {
                        sClient.SetLastReceivedPacketTimeStamp();

                        Packet packet = new Packet(data, offset, length);
                        ThreadPool.QueueUserWorkItem(
                            x =>
                            {
                                object res = scee._deserialize(in packet);
                                ByteArrayPool.Return(data);

                                if (res != null)
                                {
                                    scee.Raise(this, arg0, res, responseid, sClient);
                                }
                            });
                        return;
                    }
                }
                break;
            }
            }
            ByteArrayPool.Return(data);
        }
Example #15
0
 private void SendDataToCallback(IAsyncResult iar)
 {
     try
     {
         _listener !.EndSendTo(iar);
     }
     finally
     {
         byte[] send = (byte[])iar.AsyncState !;
         ByteArrayPool.Return(send);
     }
 }
Example #16
0
        /// <summary>
        ///     Receives.
        /// </summary>
        /// <param name="key">         The key. </param>
        /// <param name="src">         [in,out] If non-null, source for the. </param>
        /// <param name="chunkLength"> Length of the chunk. </param>
        /// <param name="chunkOffset"> The chunk offset. </param>
        /// <param name="length">      The length. </param>
        /// <returns>
        ///     A byte[] or null.
        /// </returns>
        internal unsafe byte[] Receive(int key,
                                       byte *src,
                                       int chunkLength,
                                       int chunkOffset,
                                       int length)
        {
            if (!_bigDataBuffers.TryGetValue(key, out Buffer bdb))
            {
                bool lockTaken = false;
                try
                {
                    _bigDataBufferLock.Enter(ref lockTaken);
                    if (!_bigDataBuffers.TryGetValue(key, out bdb))
                    {
                        _bigDataBuffers.Add(
                            key,
                            bdb = new Buffer(ByteArrayPool.Rent(length), length));
                    }
                }
                finally
                {
                    if (lockTaken)
                    {
                        _bigDataBufferLock.Exit(false);
                    }
                }
            }

            fixed(byte *dst2 = bdb.Data)
            {
                Mem.Cpy(dst2 + chunkOffset, src, chunkLength);
            }

            if (bdb.AddBytes(chunkLength) == 0)
            {
                bool lockTaken = false;
                try
                {
                    _bigDataBufferLock.Enter(ref lockTaken);
                    _bigDataBuffers.Remove(key);
                }
                finally
                {
                    if (lockTaken)
                    {
                        _bigDataBufferLock.Exit(false);
                    }
                }
                return(bdb.Data);
            }

            return(null);
        }
        /// <inheritdoc />
        protected override Task <bool> SendInternalAsync(IByteStreamHandler byteStreamHandler, ReadOnlySpan <char> rawMessage)
        {
            byteStreamHandler.MustNotBeNull(nameof(byteStreamHandler));

            // Check for valid message
            if (rawMessage.Length > _length)
            {
                throw new ArgumentException(
                          "Given message too long. " +
                          $"Maximum length: {(_length)}, " +
                          $"given message length: {rawMessage.Length}",
                          nameof(rawMessage));
            }

            // Perform message formatting
            var sendBuffer = StringBuffer.Acquire(_length);

            byte[]? bytes = null;
            try
            {
                if (rawMessage.Length > 0)
                {
                    sendBuffer.Append(rawMessage);
                }
                while (sendBuffer.Count < _length)
                {
                    sendBuffer.Append(_fillSymbol);
                }
                sendBuffer.GetInternalData(out var buffer, out var currentCount);

                var sendMessageByteLength = _encoding.GetByteCount(buffer, 0, currentCount);
                bytes = ByteArrayPool.Take(sendMessageByteLength);

                _encoding.GetBytes(buffer, 0, currentCount, bytes, 0);
                StringBuffer.Release(sendBuffer);
                sendBuffer = null;

                return(byteStreamHandler.SendAsync(
                           new ArraySegment <byte>(bytes, 0, sendMessageByteLength)));
            }
            finally
            {
                if (bytes != null)
                {
                    ByteArrayPool.Return(bytes);
                }
                if (sendBuffer != null)
                {
                    StringBuffer.Release(sendBuffer);
                }
            }
        }
Example #18
0
        public void InnerLogicTest(int poolSize)
        {
            using (var pool = new ByteArrayPool(sizeof(ulong), poolSize))
            {
                Assert.Equal(sizeof(ulong), pool.ByteArrayLength);
                Assert.Equal(poolSize, pool.MaxElementCount);
                Assert.Equal(poolSize + ByteArrayPool.GapSize, pool.FullCapacity);

                Assert.Null(pool.TryRentGlobal());

                for (ulong i = 0; i < (ulong)pool.FullCapacity; i++)
                {
                    Assert.True(pool.TryReleaseGlobal(BitConverter.GetBytes(i)));
                }

                Assert.False(pool.TryReleaseGlobal(BitConverter.GetBytes((ulong)0)));

                for (ulong i = 0; i < (ulong)poolSize; i++)
                {
                    Assert.Equal(BitConverter.GetBytes(i), pool.TryRentGlobal());
                }

                Assert.Null(pool.TryRentGlobal());


                ulong releaseStart = (ulong)pool.FullCapacity;
                ulong rentStart    = (ulong)poolSize;
                for (int repeat = 0; repeat < 4; repeat++)
                {
                    Assert.Null(pool.TryRentGlobal());

                    for (ulong i = releaseStart; i < releaseStart + (ulong)poolSize; i++)
                    {
                        Assert.True(pool.TryReleaseGlobal(BitConverter.GetBytes(i)));
                    }

                    Assert.False(pool.TryReleaseGlobal(BitConverter.GetBytes((ulong)0)));

                    for (ulong i = rentStart; i < rentStart + (ulong)poolSize; i++)
                    {
                        Assert.Equal(BitConverter.GetBytes(i), pool.TryRentGlobal());
                    }

                    Assert.Null(pool.TryRentGlobal());

                    releaseStart += (ulong)poolSize;
                    rentStart    += (ulong)poolSize;
                }
            }
        }
Example #19
0
        public ClientUdpPacketTransport(
            ILogger logger,
            IPacketEncryptor packetEncryption,
            NetworkTransportConfig transportConfig,
            IPEndPoint remoteEndPoint)
        {
            this._packetEncryption = packetEncryption ?? throw new ArgumentNullException(nameof(packetEncryption));
            this._remoteEndPoint   = remoteEndPoint;

            this._receiveBuffer = new ReceiveBuffer(transportConfig.MaxPacketSize, transportConfig.ReceivePacketQueueCapacity);
            this._socket        = new ClientUdpSocket(logger, this._receiveBuffer);

            this._packetSerializationBytePool = new ByteArrayPool(transportConfig.MaxPacketSize, transportConfig.SendPacketQueueCapacity);
        }
Example #20
0
        public ServerUdpPacketTransport(
            ILogger logger,
            IPacketEncryptor packetEncryption,
            NetworkTransportConfig transportConfig,
            UdpServerConfig udpServerConfig)
        {
            this._logger           = logger ?? throw new ArgumentNullException(nameof(logger));
            this._packetEncryption = packetEncryption ?? throw new ArgumentNullException(nameof(packetEncryption));
            this._endPoint         = udpServerConfig.HostIpEndPoint;

            this._receiveBuffer = new ReceiveBuffer(transportConfig.MaxPacketSize, transportConfig.ReceivePacketQueueCapacity);
            this._udpSocket     = new ServerUdpSocket(logger, this._receiveBuffer);

            this._packetSerializationBytePool = new ByteArrayPool(transportConfig.MaxPacketSize, transportConfig.SendPacketQueueCapacity);
        }
Example #21
0
        internal GrpcCopyClient(GrpcCopyClientKey key, GrpcCopyClientConfiguration configuration, IClock?clock = null, ByteArrayPool?sharedBufferPool = null)
        {
            Key            = key;
            _configuration = configuration;
            _clock         = clock ?? SystemClock.Instance;

            GrpcEnvironment.WaitUntilInitialized();
            _channel = new Channel(key.Host, key.GrpcPort,
                                   ChannelCredentials.Insecure,
                                   options: GrpcEnvironment.GetClientOptions(_configuration.GrpcCoreClientOptions));

            _client = new ContentServer.ContentServerClient(_channel);

            _bandwidthChecker = new BandwidthChecker(configuration.BandwidthCheckerConfiguration);
            _pool             = sharedBufferPool ?? new ByteArrayPool(_configuration.ClientBufferSizeBytes);
        }
Example #22
0
        private void SendDataCallback(IAsyncResult iar)
        {
            try
            {
                if (_clientSocket.EndSend(iar) <= 0)
                {
                    Disconnect(DisconnectReason.Error);
                }
            }
            catch (ObjectDisposedException) { Disconnect(DisconnectReason.Aborted); }
            catch (SocketException) { Disconnect(DisconnectReason.Error); }
            catch { Disconnect(DisconnectReason.Unspecified); }

            byte[] send = (byte[])iar.AsyncState;
            ByteArrayPool.Return(send);
        }
Example #23
0
 /// <nodoc />
 public GrpcContentServer(
     ILogger logger,
     Capabilities serviceCapabilities,
     ISessionHandler <IContentSession> sessionHandler,
     Dictionary <string, IContentStore> storesByName,
     LocalServerConfiguration localServerConfiguration = null)
 {
     _logger = logger;
     _serviceCapabilities     = serviceCapabilities;
     _sessionHandler          = sessionHandler;
     _adapter                 = new ContentServerAdapter(this);
     _contentStoreByCacheName = storesByName;
     _bufferSize              = localServerConfiguration?.BufferSizeForGrpcCopies ?? ContentStore.Grpc.CopyConstants.DefaultBufferSize;
     _gzipSizeBarrier         = localServerConfiguration?.GzipBarrierSizeForGrpcCopies ?? _bufferSize * 8;
     _pool = new ByteArrayPool(_bufferSize);
 }
Example #24
0
        public virtual void  TestThreadSafety()
        {
            rnd = NewRandom();
            int           numThreads = 5;
            int           numDocs    = 50;
            ByteArrayPool pool       = new ByteArrayPool(numThreads, 5);

            Directory   dir    = new RAMDirectory();
            IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED, null);

            System.String field = "test";

            ThreadClass[] ingesters = new ThreadClass[numThreads];
            for (int i = 0; i < numThreads; i++)
            {
                ingesters[i] = new AnonymousClassThread(numDocs, field, pool, writer, this);
                ingesters[i].Start();
            }

            for (int i = 0; i < numThreads; i++)
            {
                ingesters[i].Join();
            }
            writer.Close();
            IndexReader reader = IndexReader.Open(dir, true, null);
            TermEnum    terms  = reader.Terms(null);

            while (terms.Next(null))
            {
                TermPositions tp = reader.TermPositions(terms.Term, null);
                while (tp.Next(null))
                {
                    int freq = tp.Freq;
                    for (int i = 0; i < freq; i++)
                    {
                        tp.NextPosition(null);
                        Assert.AreEqual(pool.BytesToString(tp.GetPayload(new byte[5], 0, null)), terms.Term.Text);
                    }
                }
                tp.Close();
            }
            terms.Close();
            reader.Close();

            Assert.AreEqual(pool.Size(), numThreads);
        }
Example #25
0
        public virtual void TestThreadSafety()
        {
            const int     numThreads = 5;
            int           numDocs    = AtLeast(50);
            ByteArrayPool pool       = new ByteArrayPool(numThreads, 5);

            Directory    dir    = NewDirectory();
            IndexWriter  writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)));
            const string field  = "test";

            ThreadJob[] ingesters = new ThreadJob[numThreads];
            for (int i = 0; i < numThreads; i++)
            {
                ingesters[i] = new ThreadAnonymousInnerClassHelper(this, numDocs, pool, writer, field);
                ingesters[i].Start();
            }

            for (int i = 0; i < numThreads; i++)
            {
                ingesters[i].Join();
            }
            writer.Dispose();
            IndexReader          reader   = DirectoryReader.Open(dir);
            TermsEnum            terms    = MultiFields.GetFields(reader).GetTerms(field).GetEnumerator();
            IBits                liveDocs = MultiFields.GetLiveDocs(reader);
            DocsAndPositionsEnum tp       = null;

            while (terms.MoveNext())
            {
                string termText = terms.Term.Utf8ToString();
                tp = terms.DocsAndPositions(liveDocs, tp);
                while (tp.NextDoc() != DocIdSetIterator.NO_MORE_DOCS)
                {
                    int freq = tp.Freq;
                    for (int i = 0; i < freq; i++)
                    {
                        tp.NextPosition();
                        BytesRef payload = tp.GetPayload();
                        Assert.AreEqual(termText, payload.Utf8ToString());
                    }
                }
            }
            reader.Dispose();
            dir.Dispose();
            Assert.AreEqual(pool.Count, numThreads);
        }
        /// <inheritdoc />
        protected override Task <bool> SendInternalAsync(IByteStreamHandler byteStreamHandler, ReadOnlySpan <char> rawMessage)
        {
            byteStreamHandler.MustNotBeNull(nameof(byteStreamHandler));

            var rawMessageLength = rawMessage.Length;
            var lengthDigitCount = TcpCommunicatorUtil.GetCountOfDigits(rawMessageLength);
            var sendBuffer       = StringBuffer.Acquire(rawMessageLength + 3 + lengthDigitCount);

            byte[]? bytes = null;
            try
            {
                sendBuffer.Append(SYMBOL_START);
                sendBuffer.Append(rawMessageLength, StringView.Empty);
                sendBuffer.Append(SYMBOL_DELIMITER);
                if (rawMessage.Length > 0)
                {
                    sendBuffer.Append(rawMessage);
                }
                sendBuffer.Append(SYMBOL_END);
                sendBuffer.GetInternalData(out var buffer, out var currentCount);

                var sendMessageByteLength = _encoding.GetByteCount(buffer, 0, currentCount);
                bytes = ByteArrayPool.Take(sendMessageByteLength);

                _encoding.GetBytes(buffer, 0, currentCount, bytes, 0);
                StringBuffer.Release(sendBuffer);
                sendBuffer = null;

                return(byteStreamHandler.SendAsync(
                           new ArraySegment <byte>(bytes, 0, sendMessageByteLength)));
            }
            finally
            {
                if (bytes != null)
                {
                    ByteArrayPool.Return(bytes);
                }
                if (sendBuffer != null)
                {
                    StringBuffer.Release(sendBuffer);
                }
            }
        }
        /// <inheritdoc />
        protected override Task <bool> SendInternalAsync(IByteStreamHandler byteStreamHandler, ReadOnlySpan <char> rawMessage)
        {
            byteStreamHandler.MustNotBeNull(nameof(byteStreamHandler));

            // Check for start- and endsymbols inside the message
            TcpCommunicatorUtil.EnsureNoEndsymbolsInMessage(rawMessage, _endSymbols);

            // Perform message formatting
            var sendBuffer = StringBuffer.Acquire(rawMessage.Length + _endSymbols.Length);

            byte[]? bytes = null;
            try
            {
                sendBuffer.Append(_startSymbols, 0, _startSymbols.Length);
                if (rawMessage.Length > 0)
                {
                    sendBuffer.Append(rawMessage);
                }
                sendBuffer.Append(_endSymbols, 0, _endSymbols.Length);
                sendBuffer.GetInternalData(out var buffer, out var currentCount);

                var sendMessageByteLength = _encoding.GetByteCount(buffer, 0, currentCount);
                bytes = ByteArrayPool.Take(sendMessageByteLength);

                _encoding.GetBytes(buffer, 0, currentCount, bytes, 0);
                StringBuffer.Release(sendBuffer);
                sendBuffer = null;

                return(byteStreamHandler.SendAsync(
                           new ArraySegment <byte>(bytes, 0, sendMessageByteLength)));
            }
            finally
            {
                if (bytes != null)
                {
                    ByteArrayPool.Return(bytes);
                }
                if (sendBuffer != null)
                {
                    StringBuffer.Release(sendBuffer);
                }
            }
        }
Example #28
0
        /// <inheritdoc />
        public override SendError SendTo(Socket arg0, uint commandid, byte[] data, int offset, int length,
                                         uint responseid)
        {
            if (_listener == null)
            {
                return(SendError.Invalid);
            }
            if ((_state & SEND_FLAG) == SEND_FLAG)
            {
                Serialization.Serialization.SerializeTcp(
                    commandid, data, offset, length, responseid, EncryptionMode.None, out byte[] send, out int size);
                try
                {
                    SendStateObject state;
                    state.Socket = arg0;
                    state.Buffer = send;
                    arg0.BeginSend(
                        send, 0, size, SocketFlags.None, BeginSendCallback, state);

                    return(SendError.None);
                }
                catch (ObjectDisposedException)
                {
                    InvokeClientDisconnect(arg0, DisconnectReason.Aborted);
                    ByteArrayPool.Return(send);
                    return(SendError.Disposed);
                }
                catch (SocketException)
                {
                    InvokeClientDisconnect(arg0, DisconnectReason.Error);
                    ByteArrayPool.Return(send);
                    return(SendError.Socket);
                }
                catch
                {
                    InvokeClientDisconnect(arg0, DisconnectReason.Unspecified);
                    ByteArrayPool.Return(send);
                    return(SendError.Unknown);
                }
            }
            return(SendError.Invalid);
        }
Example #29
0
        private void BeginSendCallback(IAsyncResult iar)
        {
            SendStateObject state = (SendStateObject)iar.AsyncState !;

            try
            {
                if (state.Socket.EndSend(iar) <= 0)
                {
                    InvokeClientDisconnect(state.Socket, DisconnectReason.Unspecified);
                }
            }
            catch
            {
                /* IGNORE */
            }
            finally
            {
                ByteArrayPool.Return(state.Buffer);
            }
        }
Example #30
0
        public void RentReleasePerfTest(int poolSize, bool skipLocal)
        {
            using (var pool = new ByteArrayPool(sizeof(ulong), poolSize))
            {
                Assert.Equal(sizeof(ulong), pool.ByteArrayLength);
                Assert.Equal(poolSize, pool.MaxElementCount);

                Stopwatch sw = Stopwatch.StartNew();

                const int iterations = 1000000;
                for (int i = 0; i < iterations; i++)
                {
                    byte[] array = pool.Rent(skipLocal: skipLocal);
                    pool.Release(array, skipLocal: skipLocal);
                }

                sw.Stop();
                Output?.WriteLine($"Perf: {iterations * 1000 / sw.ElapsedMilliseconds} op/sec ({sw.ElapsedMilliseconds} ms for {iterations})");
            }
        }
Example #31
0
		public virtual void  TestThreadSafety()
		{
			rnd = NewRandom();
			int numThreads = 5;
			int numDocs = 50;
			ByteArrayPool pool = new ByteArrayPool(numThreads, 5);
			
			Directory dir = new RAMDirectory();
			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
			System.String field = "test";
			
			SupportClass.ThreadClass[] ingesters = new SupportClass.ThreadClass[numThreads];
			for (int i = 0; i < numThreads; i++)
			{
				ingesters[i] = new AnonymousClassThread(numDocs, field, pool, writer, this);
				ingesters[i].Start();
			}
			
			for (int i = 0; i < numThreads; i++)
			{
				ingesters[i].Join();
			}
			writer.Close();
			IndexReader reader = IndexReader.Open(dir);
			TermEnum terms = reader.Terms();
			while (terms.Next())
			{
				TermPositions tp = reader.TermPositions(terms.Term());
				while (tp.Next())
				{
					int freq = tp.Freq();
					for (int i = 0; i < freq; i++)
					{
						tp.NextPosition();
						Assert.AreEqual(pool.BytesToString(tp.GetPayload(new byte[5], 0)), terms.Term().text_ForNUnit);
					}
				}
				tp.Close();
			}
			terms.Close();
			reader.Close();
			
			Assert.AreEqual(pool.Size(), numThreads);
		}
Example #32
0
			internal PoolingPayloadTokenStream(ByteArrayPool pool)
			{
				this.pool = pool;
				payload = pool.Get();
				Lucene.Net.Index.TestPayloads.GenerateRandomData(payload);
				first = true;
			}
Example #33
0
        public virtual void TestThreadSafety()
        {
            const int numThreads = 5;
            int numDocs = AtLeast(50);
            ByteArrayPool pool = new ByteArrayPool(numThreads, 5);

            Directory dir = NewDirectory();
            IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())));
            const string field = "test";

            ThreadClass[] ingesters = new ThreadClass[numThreads];
            for (int i = 0; i < numThreads; i++)
            {
                ingesters[i] = new ThreadAnonymousInnerClassHelper(this, numDocs, pool, writer, field);
                ingesters[i].Start();
            }

            for (int i = 0; i < numThreads; i++)
            {
                ingesters[i].Join();
            }
            writer.Dispose();
            IndexReader reader = DirectoryReader.Open(dir);
            TermsEnum terms = MultiFields.GetFields(reader).Terms(field).Iterator(null);
            Bits liveDocs = MultiFields.GetLiveDocs(reader);
            DocsAndPositionsEnum tp = null;
            while (terms.Next() != null)
            {
                string termText = terms.Term().Utf8ToString();
                tp = terms.DocsAndPositions(liveDocs, tp);
                while (tp.NextDoc() != DocIdSetIterator.NO_MORE_DOCS)
                {
                    int freq = tp.Freq();
                    for (int i = 0; i < freq; i++)
                    {
                        tp.NextPosition();
                        BytesRef payload = tp.Payload;
                        Assert.AreEqual(termText, payload.Utf8ToString());
                    }
                }
            }
            reader.Dispose();
            dir.Dispose();
            Assert.AreEqual(pool.Size(), numThreads);
        }
Example #34
0
 internal PoolingPayloadTokenStream(TestPayloads outerInstance, ByteArrayPool pool)
 {
     this.OuterInstance = outerInstance;
     this.Pool = pool;
     Payload = pool.Get();
     OuterInstance.GenerateRandomData(Payload);
     Term = Encoding.UTF8.GetString((byte[])(Array)Payload);
     First = true;
     PayloadAtt = AddAttribute<IPayloadAttribute>();
     TermAtt = AddAttribute<ICharTermAttribute>();
 }
Example #35
0
			internal PoolingPayloadTokenStream(TestPayloads enclosingInstance, ByteArrayPool pool)
			{
				InitBlock(enclosingInstance);
				this.pool = pool;
				payload = pool.Get();
				Enclosing_Instance.GenerateRandomData(payload);
				term = pool.BytesToString(payload);
				first = true;
				payloadAtt = (PayloadAttribute) AddAttribute(typeof(PayloadAttribute));
				termAtt = (TermAttribute) AddAttribute(typeof(TermAttribute));
			}