public void should_throw_an_unabletocreatememoryexception_if_acquiring_memory_is_disabled_and_out_of_memory() { BufferManager manager = new BufferManager(1, 1000, 1, false); manager.CheckOut(); //should be none left, boom Assert.Throws<UnableToCreateMemoryException>(() => manager.CheckOut()); }
public void CheckOut_should_return_a_buffer_of_same_size_as_manager() { var buffer = _Manager.CheckOut(); Assert.That(buffer, Is.Not.Null); Assert.That(buffer.Memory.Length, Is.EqualTo(_BufferSize)); }
public void should_throw_an_unabletocreatememoryexception_if_acquiring_memory_is_disabled_and_out_of_memory() { BufferManager manager = new BufferManager(1, 1000, 1, false); manager.CheckOut(); //should be none left, boom Assert.Throws <UnableToCreateMemoryException>(() => manager.CheckOut()); }
public void should_throw_an_unabletocreatememoryexception_if_acquiring_memory_is_disabled_and_out_of_memory() { BufferManager manager = new BufferManager(1, 1000, 1, false); ArraySegment <byte> buffer = manager.CheckOut(); //should be none left, boom manager.CheckOut(); }
public void TestUpdatePacket() { var mgr = new BufferManager(2, 128); var segment1 = mgr.CheckOut(); // 1st buffer Assert.AreEqual(1, mgr.AvailableSegmentsCount); var segment2 = mgr.CheckOut(); // 1st buffer Assert.AreEqual(1, mgr.TotalBufferCount); Assert.AreEqual(0, mgr.AvailableSegmentsCount); //Assert.AreEqual(2, segment2.Buffer.UsedSegmentCount); var segment3 = mgr.CheckOut(); // 2nd buffer Assert.AreEqual(2, mgr.TotalBufferCount); Assert.AreEqual(1, mgr.AvailableSegmentsCount); //Assert.AreEqual(1, segment3.Buffer.UsedSegmentCount); segment3.DecrementUsage(); Assert.AreEqual(2, mgr.AvailableSegmentsCount); //Assert.AreEqual(0, segment3.Buffer.UsedSegmentCount); //using (var outPacket = new UpdatePacket(segment2)) using (var outPacket = new UpdatePacket(128)) { Assert.AreEqual(outPacket.PacketId, (PacketId)RealmServerOpCode.SMSG_UPDATE_OBJECT); outPacket.Write(15); outPacket.WriteCString("abc"); using (var inPacket = DisposableRealmPacketIn.CreateFromOutPacket(segment1, outPacket)) { Assert.AreEqual(0, inPacket.ReadInt32()); //update count Assert.AreEqual(15, inPacket.ReadInt32()); Assert.AreEqual("abc", inPacket.ReadCString()); } outPacket.Reset(); Assert.AreEqual(outPacket.PacketId, (PacketId)RealmServerOpCode.SMSG_UPDATE_OBJECT); outPacket.WriteCString("def"); outPacket.WriteUShortBE(300); using (var inPacket = DisposableRealmPacketIn.CreateFromOutPacket(segment1, outPacket)) { Assert.AreEqual(0, inPacket.ReadInt32()); //update count Assert.AreEqual((byte)0, inPacket.ReadByte()); //block count Assert.AreEqual("def", inPacket.ReadCString()); Assert.AreEqual((ushort)300, inPacket.ReadUInt16BE()); } } }
public void should_increment_available_buffers() { BufferManager manager = new BufferManager(10, 1000, 0); manager.CheckIn(manager.CheckOut()); Assert.AreEqual(10, manager.AvailableBuffers); }
public void should_return_a_valid_buffer_when_available() { BufferManager manager = new BufferManager(1, 1000, 1); ArraySegment <byte> buffer = manager.CheckOut(); Assert.AreEqual(1000, buffer.Count); }
public void should_decrement_available_buffers() { BufferManager manager = new BufferManager(1, 1000, 1); manager.CheckOut(); Assert.AreEqual(0, manager.AvailableBuffers); }
public void should_create_a_segment_if_none_are_availabke() { BufferManager manager = new BufferManager(10, 1000, 0); manager.CheckOut(); Assert.AreEqual(9, manager.AvailableBuffers); }
public void should_release_acquired_buffers_if_size_requirement_cant_be_satisfied() { BufferManager manager = new BufferManager(1, 1000, 1, false); Assert.Throws(Is.InstanceOf(typeof(Exception)), () => manager.CheckOut(2)); Assert.AreEqual(1, manager.AvailableBuffers); }
public void TestBufferManagerEtc() { var mgr = new BufferManager(2, 128); var segment1 = mgr.CheckOut(); // 1st buffer Assert.AreEqual(1, mgr.AvailableSegmentsCount); var segment2 = mgr.CheckOut(); // 1st buffer Assert.AreEqual(1, mgr.TotalBufferCount); Assert.AreEqual(0, mgr.AvailableSegmentsCount); //Assert.AreEqual(2, segment2.Buffer.UsedSegmentCount); var segment3 = mgr.CheckOut(); // 2nd buffer Assert.AreEqual(2, mgr.TotalBufferCount); Assert.AreEqual(1, mgr.AvailableSegmentsCount); //Assert.AreEqual(1, segment3.Buffer.UsedSegmentCount); segment3.DecrementUsage(); Assert.AreEqual(2, mgr.AvailableSegmentsCount); //Assert.AreEqual(0, segment3.Buffer.UsedSegmentCount); using (var outPacket = new RealmPacketOut(RealmServerOpCode.CMSG_ACCEPT_TRADE)) { outPacket.Position = outPacket.HeaderSize; outPacket.Write(1); outPacket.WriteCString("abc"); var inPacket = DisposableRealmPacketIn.CreateFromOutPacket(segment1, outPacket); Assert.AreEqual(1, inPacket.ReadInt32()); Assert.AreEqual("abc", inPacket.ReadCString()); } using (var outPacket = new RealmPacketOut(RealmServerOpCode.CMSG_ACCEPT_TRADE)) { outPacket.Position = outPacket.HeaderSize; outPacket.WriteCString("def"); outPacket.Write(2); var inPacket = DisposableRealmPacketIn.CreateFromOutPacket(segment2, outPacket); Assert.AreEqual("def", inPacket.ReadCString()); Assert.AreEqual(2, inPacket.ReadInt32()); } }
public static byte[] CompressResponse(byte[] response, string compressionAlgorithm) { if (string.IsNullOrEmpty(compressionAlgorithm) || !SupportedCompressionAlgorithms.Contains(compressionAlgorithm)) { return(response); } MemoryStream outputStream; var useBufferManager = 10L * response.Length <= 9L * _compressionBufferManager .ChunkSize; //in some rare cases, compression can result in larger outputs. Added a 10% overhead just to be sure. var bufferManagerArraySegment = new ArraySegment <byte>(); if (useBufferManager) { //use buffer manager to handle responses less than ~50kb long to prevent excessive memory allocations bufferManagerArraySegment = _compressionBufferManager.CheckOut(); outputStream = new MemoryStream(bufferManagerArraySegment.Array, bufferManagerArraySegment.Offset, bufferManagerArraySegment.Count); outputStream.SetLength(0); } else { //since Gzip/Deflate compression ratio doesn't go below 20% in most cases, we can initialize the array to a quarter of the original response length //this also limits memory stream growth operations to at most 2. outputStream = new MemoryStream((response.Length + 4 - 1) / 4); } using (outputStream) { Stream compressedStream = null; if (compressionAlgorithm.Equals(CompressionAlgorithms.Gzip)) { compressedStream = new GZipStream(outputStream, CompressionLevel.Fastest); } else if (compressionAlgorithm.Equals(CompressionAlgorithms.Deflate)) { compressedStream = new DeflateStream(outputStream, CompressionLevel.Fastest); } using (compressedStream) using (var dataStream = new MemoryStream(response)) { dataStream.CopyTo(compressedStream); } var result = outputStream.ToArray(); if (useBufferManager) { _compressionBufferManager.CheckIn(bufferManagerArraySegment); } return(result); } }
/// <summary> /// Initializes a new instance of the <see cref="BufferPool"/> class. /// </summary> /// <param name="initialBufferCount">The number of initial buffers.</param> /// <param name="bufferManager">The buffer manager.</param> public BufferPool(int initialBufferCount, BufferManager bufferManager) { if (initialBufferCount <= 0) throw new ArgumentException("initialBufferCount"); if (bufferManager == null) throw new ArgumentNullException("bufferManager"); _length = 0; _buffers = new List<ArraySegment<byte>>(bufferManager.CheckOut(initialBufferCount)); // must have 1 buffer _chunkSize = _buffers[0].Count; _bufferManager = bufferManager; _disposed = false; }
private void StartReceive() { var buffer = BufferManager.CheckOut(); if (buffer.Array == null || buffer.Count == 0 || buffer.Array.Length < buffer.Offset + buffer.Count) { throw new Exception("Invalid buffer allocated"); } lock (_receiveSocketArgs) { _receiveSocketArgs.SetBuffer(buffer.Array, buffer.Offset, buffer.Count); if (_receiveSocketArgs.Buffer == null) { throw new Exception("Buffer was not set"); } } try { Interlocked.Increment(ref _recvAsyncs); NotifyReceiveStarting(); bool firedAsync; lock (_receiveSocketArgs) { if (_receiveSocketArgs.Buffer == null) { throw new Exception("Buffer was lost"); } firedAsync = _receiveSocketArgs.AcceptSocket.ReceiveAsync(_receiveSocketArgs); } if (!firedAsync) { Log.Info("SYNC receive"); ProcessReceive(_receiveSocketArgs); } } catch (ObjectDisposedException) { ReturnReceivingSocketArgs(); } }
private void StartReceive() { var buffer = BufferManager.CheckOut(); if (buffer.Array == null || buffer.Count == 0 || buffer.Array.Length < buffer.Offset + buffer.Count) { throw new Exception("Invalid buffer allocated"); } // TODO AN: do we need to lock on _receiveSocketArgs?.. lock (_receiveSocketArgs) { _receiveSocketArgs.SetBuffer(buffer.Array, buffer.Offset, buffer.Count); if (_receiveSocketArgs.Buffer == null) { throw new Exception("Buffer was not set"); } } try { NotifyReceiveStarting(); bool firedAsync; lock (_receiveSocketArgs) { if (_receiveSocketArgs.Buffer == null) { throw new Exception("Buffer was lost"); } firedAsync = _receiveSocketArgs.AcceptSocket.ReceiveAsync(_receiveSocketArgs); } if (!firedAsync) { ProcessReceive(_receiveSocketArgs); } } catch (ObjectDisposedException) { ReturnReceivingSocketArgs(); } }
private void StartReceive() { try { Interlocked.Increment(ref _recvAsyncs); _currentBuffer = BufferManager.CheckOut(); _socket.BeginReceive(_currentBuffer.Array, _currentBuffer.Offset, _currentBuffer.Count, SocketFlags.None, OnReceiveAsyncCompleted, null); } catch (SocketException exc) { CloseInternal(exc.SocketErrorCode); } catch (Exception) { CloseInternal(SocketError.Shutdown); } }
private void StartReceive() { var buffer = BufferManager.CheckOut(); if (buffer.Array == null || buffer.Count == 0 || buffer.Array.Length < buffer.Offset + buffer.Count) { throw new Exception("Invalid buffer allocated"); } try { NotifyReceiveStarting(); _receiveSocketArgs.SetBuffer(buffer.Array, buffer.Offset, buffer.Count); var firedAsync = _receiveSocketArgs.AcceptSocket.ReceiveAsync(_receiveSocketArgs); if (!firedAsync) { ProcessReceive(_receiveSocketArgs); } } catch (ObjectDisposedException) { ReturnReceivingSocketArgs(); } }
public void should_accept_a_checked_out_buffer() { BufferManager manager = new BufferManager(10, 1000, 0); manager.CheckIn(manager.CheckOut()); }
public void should_accept_a_checked_out_buffer() { BufferManager manager = new BufferManager(10, 1000, 0); manager.CheckIn(manager.CheckOut()); }
public void should_throw_an_unabletocreatememoryexception_if_acquiring_memory_is_disabled_and_out_of_memory() { BufferManager manager = new BufferManager(1, 1000, 1, false); ArraySegment<byte> buffer = manager.CheckOut(); //should be none left, boom manager.CheckOut(); }
public void should_increment_available_buffers() { BufferManager manager = new BufferManager(10, 1000, 0); manager.CheckIn(manager.CheckOut()); Assert.AreEqual(10, manager.AvailableBuffers); }
public void should_return_a_valid_buffer_when_available() { BufferManager manager = new BufferManager(1, 1000, 1); ArraySegment<byte> buffer = manager.CheckOut(); Assert.AreEqual(1000, buffer.Count); }
public void should_decrement_available_buffers() { BufferManager manager = new BufferManager(1, 1000, 1); manager.CheckOut(); Assert.AreEqual(0, manager.AvailableBuffers); }
public void should_create_a_segment_if_none_are_availabke() { BufferManager manager = new BufferManager(10, 1000, 0); manager.CheckOut(); Assert.AreEqual(9, manager.AvailableBuffers); }
/// <summary> /// </summary> public ISComV2ClientBase() { this._bufferSegment = Buffers.CheckOut(); }
public void should_release_acquired_buffers_if_size_requirement_cant_be_satisfied() { BufferManager manager = new BufferManager(1, 1000, 1, false); Assert.Throws(Is.InstanceOf(typeof(Exception)), () => manager.CheckOut(2)); Assert.AreEqual(1, manager.AvailableBuffers); }