internal MemoryManager(SocketConfig config) { _configuration = config; _pooledHeapMemory = new ConcurrentCircularQueue <HeapMemory>(_configuration.HeapMemoryPoolSize); _pooledPointerArrays = new ConcurrentCircularQueue <HeapPointers>(_configuration.HeapPointersPoolSize); _pooledMemoryWrappers = new ConcurrentCircularQueue <MemoryWrapper>(_configuration.MemoryWrapperPoolSize); }
public void ArrayTest() { var queue = new ConcurrentCircularQueue <DataClass>(_testList.Count); queue.Enqueue(new DataClass()); queue.Dequeue(); queue.Enqueue(_testList); Assert.AreEqual(_testList.Count, queue.Count); foreach (var item in _testList) { var result = queue.Dequeue(); Assert.AreSame(item, result); } queue.Enqueue(new DataClass()); queue.Dequeue(); queue.Enqueue(_testList); DataClass[] copyList = new DataClass[_testList.Count]; queue.CopyTo(copyList, 0); for (int i = 0; i < _testList.Count; ++i) { Assert.AreSame(_testList[i], copyList[i]); } }
public void BasicTest() { var queue = new ConcurrentCircularQueue <DataClass>(_testList.Count); foreach (var item in _testList) { queue.Enqueue(item); } Assert.AreEqual(_testList.Count, queue.Count); List <DataClass> _dequeueList = new List <DataClass>(_testList.Count); foreach (var item in _testList) { _dequeueList.Add(queue.Dequeue()); } Assert.AreEqual(0, queue.Count); CheckList(_dequeueList, _dequeueList.Count); for (int i = 0; i < _testList.Count * 3; ++i) { var item = _testList[i % _testList.Count]; queue.Enqueue(item); var result = queue.Dequeue(); Assert.AreSame(item, result); } }
public void OverflowTest() { int allocCount = _testList.Count / 2; var queue = new ConcurrentCircularQueue <DataClass>(allocCount); for (int i = 0; i < _testList.Count; ++i) { bool result = queue.Enqueue(_testList[i]); if (i < allocCount) { Assert.AreEqual(true, result); } else { Assert.AreEqual(false, result); } } Assert.AreEqual(allocCount, queue.Count); List <DataClass> _dequeueList = new List <DataClass>(_testList.Count); for (int i = 0; i < allocCount; ++i) { _dequeueList.Add(queue.Dequeue()); } Assert.AreEqual(0, queue.Count); CheckList(_dequeueList, _dequeueList.Count); }
private Task EnqueueTest(ConcurrentCircularQueue <DataClass> queue) { foreach (var item in _testList) { queue.Enqueue(item); } return(Task.CompletedTask); }
internal Connection(ulong id, ConnectionState state, IPEndPoint endpoint, RuffleSocket socket) { #if ALLOW_CONNECTION_STUB if (IsStub) { // NOOP return; } #endif this.Id = id; this.Socket = socket; this.EndPoint = endpoint; this.MTU = Config.MinimumMTU; this.SmoothRoundtrip = 0; this.HighestRoundtripVarience = 0; this.Roundtrip = 500; this.LowestRoundtrip = 500; this.LastMessageIn = NetTime.Now; this.LastMessageOut = NetTime.Now; this.ConnectionStarted = NetTime.Now; this.ConnectionCompleted = NetTime.Now; this.HandshakeStarted = NetTime.Now; this.HandshakeLastSendTime = NetTime.Now; this.HandshakeResendAttempts = 0; this.ChallengeAnswer = 0; this.ConnectionChallenge = RandomProvider.GetRandomULong(); this.ChallengeDifficulty = (byte)Config.ChallengeDifficulty; this.PreConnectionChallengeTimestamp = 0; this.PreConnectionChallengeCounter = 0; this.PreConnectionChallengeIV = 0; this.PreConnectionChallengeSolved = false; this.State = state; if (Config.EnableBandwidthTracking && Config.CreateBandwidthTracker != null) { this.BandwidthTracker = Config.CreateBandwidthTracker(); } if (Config.EnableHeartbeats) { this.HeartbeatChannel = new UnreliableOrderedChannel(0, this, Config, MemoryManager); } if (Config.EnablePacketMerging) { this.Merger = new MessageMerger(Config.MaxMergeMessageSize, Config.MinimumMTU); } if (Logging.CurrentLogLevel <= LogLevel.Debug) { Logging.LogInfo("Allocating " + Config.EventQueueSize + " event slots"); } this._userEventQueue = new ConcurrentCircularQueue <NetworkEvent>(Config.EventQueueSize, true); this.IsUserEventQueueActive = true; }
internal ChannelPool(SocketConfig config) { if (config.ReuseChannels) { if ((config.PooledChannels & PooledChannelType.Reliable) == PooledChannelType.Reliable) { _reliableChannels = new ConcurrentCircularQueue <ReliableChannel>(config.ChannelPoolSize); } if ((config.PooledChannels & PooledChannelType.ReliableFragmented) == PooledChannelType.ReliableFragmented) { _reliableFragmentedChannels = new ConcurrentCircularQueue <ReliableFragmentedChannel>(config.ChannelPoolSize); } if ((config.PooledChannels & PooledChannelType.ReliableOrdered) == PooledChannelType.ReliableOrdered) { _reliableOrderedChannels = new ConcurrentCircularQueue <ReliableOrderedChannel>(config.ChannelPoolSize); } if ((config.PooledChannels & PooledChannelType.ReliableSequenced) == PooledChannelType.ReliableSequenced) { _reliableSequencedChannels = new ConcurrentCircularQueue <ReliableSequencedChannel>(config.ChannelPoolSize); } if ((config.PooledChannels & PooledChannelType.ReliableSequencedFragmented) == PooledChannelType.ReliableSequencedFragmented) { _reliableSequencedFragmentedChannels = new ConcurrentCircularQueue <ReliableSequencedFragmentedChannel>(config.ChannelPoolSize); } if ((config.PooledChannels & PooledChannelType.Unreliable) == PooledChannelType.Unreliable) { _unreliableChannels = new ConcurrentCircularQueue <UnreliableChannel>(config.ChannelPoolSize); } if ((config.PooledChannels & PooledChannelType.UnreliableOrdered) == PooledChannelType.UnreliableOrdered) { _unreliableOrderedChannels = new ConcurrentCircularQueue <UnreliableOrderedChannel>(config.ChannelPoolSize); } if ((config.PooledChannels & PooledChannelType.UnreliableSequenced) == PooledChannelType.UnreliableSequenced) { _unreliableSequencedChannels = new ConcurrentCircularQueue <UnreliableSequencedChannel>(config.ChannelPoolSize); } if ((config.PooledChannels & PooledChannelType.UnreliableRaw) == PooledChannelType.UnreliableRaw) { _unreliableRawChannels = new ConcurrentCircularQueue <UnreliableRawChannel>(config.ChannelPoolSize); } } }
public QueueBenchmark() { _list = new List <DataClass>(TestCount); for (int i = 0; i < TestCount; ++i) { _list.Add(new DataClass() { Value = i }); } _concurrentQueue = new ConcurrentQueue <DataClass>(); _concurrentCircluarQueue = new ConcurrentCircularQueue <DataClass>(TestCount); }
public async Task MultithreadTest() { int taskCount = 20; var queue = new ConcurrentCircularQueue <DataClass>(_testList.Count * taskCount); List <Task> taskList = new List <Task>(); for (int i = 0; i < taskCount; ++i) { taskList.Add(EnqueueTest(queue)); } await Task.WhenAll(taskList); Assert.AreEqual(_testList.Count * taskCount, queue.Count); var sortedQueue = new List <DataClass>(queue.ToArray()); sortedQueue.Sort((x, y) => x.Value.CompareTo(y.Value)); for (int x = 0; x < _testList.Count; ++x) { for (int y = 0; y < taskCount; ++y) { Assert.AreSame(_testList[x], sortedQueue[x * taskCount + y]); } } var queue2 = new ConcurrentCircularQueue <DataClass>(_testList.Count); taskList.Clear(); for (int i = 0; i < taskCount; ++i) { taskList.Add(EnqueueDequeueTest(queue2)); } await Task.WhenAll(taskList); Assert.AreEqual(0, queue2.Count); }
internal void DisconnectInternal(bool sendMessage, bool timeout) { #if ALLOW_CONNECTION_STUB if (IsStub) { // NOOP return; } #endif // TODO: Could be just a normal write lock. The chance of it not being a write in the end is small. _stateLock.EnterUpgradeableReadLock(); try { if (State == ConnectionState.Connected && sendMessage && !timeout) { // Send disconnect message // Allocate memory HeapMemory memory = MemoryManager.AllocHeapMemory(1); // Write disconnect header memory.Buffer[0] = HeaderPacker.Pack(MessageType.Disconnect); // Send disconnect message SendInternal(new ArraySegment <byte>(memory.Buffer, 0, (int)memory.VirtualCount), true); // Release memory MemoryManager.DeAlloc(memory); } if (State != ConnectionState.Disconnected) { _stateLock.EnterWriteLock(); try { // Set the state to disconnected State = ConnectionState.Disconnected; // Release all memory Release(); } finally { _stateLock.ExitWriteLock(); } // IsUserEventQueueActive = false; while (_userEventQueue != null && _userEventQueue.TryDequeue(out NetworkEvent networkEvent)) { // Recycle all packets to prevent leak detection networkEvent.Recycle(); } // Release user queue _userEventQueue = null; // // Remove from global lookup Socket.RemoveConnection(this); // Send disconnect to userspace Socket.PublishEvent(new NetworkEvent() { Connection = this, Socket = Socket, Type = timeout ? NetworkEventType.Timeout : NetworkEventType.Disconnect, AllowUserRecycle = false, ChannelId = 0, Data = new ArraySegment <byte>(), InternalMemory = null, SocketReceiveTime = NetTime.Now, MemoryManager = MemoryManager, EndPoint = EndPoint }); } } finally { _stateLock.ExitUpgradeableReadLock(); } }