public void DelayQueuePeekNothingTest()
{
DelayQueue target = new DelayQueue();
Assert.IsNull(target.poll());
Assert.IsNull(target.peek());
}
public void CreateQueue()
{
_queue = new DelayQueue <DummyMessage>(new ParallelOperations());
_queue.Dequeued += OnQueueDequeued;
_queue.Start(Delay);
_stopwatch.Start();
}
public void DelayQueuePutSome()
{
DelayQueue target = new DelayQueue();
TestNow = new DateTime(2000, 1, 1);
TimeSpan delta = new TimeSpan(1, 0, 0, 0);
target.put(new DelayItem(TestNow + delta));
Assert.AreEqual(1, target.Count);
target.put(new DelayItem(TestNow + delta + delta));
Assert.AreEqual(2, target.Count);
}
public void DelayQueuePollNotReady()
{
DelayQueue target = new DelayQueue();
TestNow = new DateTime(2000, 1, 1);
TimeSpan delta = new TimeSpan(1, 0, 0, 0);
DelayItem item1 = new DelayItem(TestNow + delta);
DelayItem item2 = new DelayItem(TestNow + delta + delta);
target.put(item1);
target.put(item2);
Assert.IsNull(target.poll());
Assert.AreEqual(2, target.Count);
}
public void DelayQueueTakeInOrder()
{
List <DelayItem> takenItems = new List <DelayItem>();
SortedList <DateTime, DelayItem> items = new SortedList <DateTime, DelayItem>();
DelayQueue target = new DelayQueue();
TestNow = new DateTime(2000, 1, 1);
List <int> offsets = new List <int>();
offsets.Add(8);
offsets.Add(6);
offsets.Add(7);
offsets.Add(5);
foreach (int i in offsets)
{
DateTime dt = TestNow + new TimeSpan(0, 0, i);
DelayItem item = new DelayItem(dt);
items.Add(dt, item);
target.put(item);
}
Thread thr = new Thread(() =>
{
while (target.Count > 0)
{
takenItems.Add((DelayItem)target.take());
}
});
thr.Start();
for (int i = 0; i < 12; i++)
{
Thread.Sleep(1000);
TestNow += new TimeSpan(0, 0, 1);
}
thr.Join();
Assert.AreEqual(items.Count, takenItems.Count);
Assert.AreEqual(0, target.Count);
for (int i = 0; i < items.Count; i++)
{
Assert.AreSame(items[items.Keys[i]], takenItems[i]);
}
}
public void TestAddsKeptInSequence()
{
DelayQueue<uint> dq = new DelayQueue<uint>();
dq.Enqueue(0, 1);
dq.Enqueue(1, 1);
dq.Enqueue(2, 1);
dq.Enqueue(3, 1);
Assert.AreEqual(1, dq.MaximumDelay);
Assert.IsFalse(dq.Dequeue(0, null));
uint lastSeen = 0;
dq.Enqueue(4, 1);
Assert.AreEqual(1, dq.MaximumDelay);
Assert.IsTrue(dq.Dequeue(1, v => Assert.AreEqual(lastSeen++, v)));
Assert.AreEqual(0, dq.Count);
Assert.AreEqual(0, dq.MaximumDelay);
}
/// <summary>
///
/// </summary>
/// <param name="tickSpan">时间槽大小，毫秒</param>
/// <param name="slotCount">时间槽数量</param>
/// <param name="startMs">起始时间戳，标识时间轮创建时间</param>
/// <param name="taskCount">任务总数</param>
/// <param name="delayQueue">时间槽延时队列</param>
public TimingWheel(long tickSpan, int slotCount, long startMs, AtomicInt taskCount, DelayQueue <TimeSlot> delayQueue)
{
_tickSpan = tickSpan;
_slotCount = slotCount;
_taskCount = taskCount;
_delayQueue = delayQueue;
_wheelSpan = _tickSpan * _slotCount;
_timeSlots = new TimeSlot[_slotCount];
for (int i = 0; i < _timeSlots.Length; i++)
{
_timeSlots[i] = new TimeSlot(_taskCount);
}
// 计算起始时间槽的起始时间戳，注意起始时间槽并不一定是第0个
SetNeedle(startMs);
}
public void DelayQueuePollInOrder()
{
List <DelayItem> takenItems = new List <DelayItem>();
SortedList <DateTime, DelayItem> items = new SortedList <DateTime, DelayItem>();
DelayQueue target = new DelayQueue();
TestNow = new DateTime(2000, 1, 1);
List <int> offsets = new List <int>();
offsets.Add(8);
offsets.Add(6);
offsets.Add(7);
offsets.Add(5);
foreach (int i in offsets)
{
DateTime dt = TestNow + new TimeSpan(0, 0, i);
DelayItem item = new DelayItem(dt);
items.Add(dt, item);
target.put(item);
}
TestNow += new TimeSpan(0, 0, 50);
while (target.Count > 0)
{
takenItems.Add((DelayItem)target.poll());
}
Assert.AreEqual(items.Count, takenItems.Count);
Assert.AreEqual(0, target.Count);
for (int i = 0; i < items.Count; i++)
{
Assert.AreSame(items[items.Keys[i]], takenItems[i]);
}
}
public void DelayQueuePollMultipleReady()
{
DelayQueue target = new DelayQueue();
TestNow = new DateTime(2000, 1, 1);
TimeSpan delta = new TimeSpan(1, 0, 0, 0);
const int numItems = 10;
SortedList <TimeSpan, DelayItem> items = new SortedList <TimeSpan, DelayItem>(10);
// Put in five ready items, five not ready items
{
TimeSpan d2 = delta;
for (int i = 0; i < numItems / 2; i++, d2 += delta)
{
DelayItem iplus = new DelayItem(TestNow + d2);
DelayItem iminus = new DelayItem(TestNow - d2);
target.put(iplus);
target.put(iminus);
items.Add(d2, iplus);
items.Add(-d2, iminus);
}
}
Assert.AreEqual(numItems, target.Count);
for (int i = 0; i < numItems / 2; i++)
{
object qItem = target.poll();
object item = items[items.Keys[0]];
items.RemoveAt(0);
Assert.AreSame(item, qItem);
Assert.AreEqual(items.Count, target.Count);
}
Assert.IsNull(target.peek());
Assert.IsNull(target.poll());
}
public void TestReversedAdds()
{
DelayQueue<uint> dq = new DelayQueue<uint>();
Assert.AreEqual(0, dq.Count);
for (uint i = 0; i < 10; i++)
{
dq.Enqueue(10 - i - 1, 10 - i);
Assert.AreEqual(i + 1, dq.Count);
Assert.AreEqual(10, dq.MaximumDelay); // MaxDelay shouldn't change
}
Assert.IsFalse(dq.Dequeue(0, null)); // nothing at time 0
for (uint i = 0; i < 10; i++)
{
Assert.AreEqual(10 - i, dq.Count);
Assert.AreEqual(10 - i , dq.MaximumDelay);
bool dequeued = dq.Dequeue(1, e => Assert.AreEqual(i, e));
Assert.IsTrue(dequeued);
Assert.AreEqual(10 - (i + 1), dq.Count);
Assert.AreEqual(10 - i - 1, dq.MaximumDelay);
Assert.IsFalse(dq.Dequeue(0, null));
}
Assert.AreEqual(0, dq.Count);
Assert.AreEqual(0, dq.MaximumDelay);
}
public void TestSequentialAdds()
{
DelayQueue<uint> dq = new DelayQueue<uint>();
Assert.AreEqual(0, dq.Count);
for (uint i = 0; i < 10; i++)
{
dq.Enqueue(i, i + 1);
Assert.AreEqual(i + 1, dq.Count);
Assert.AreEqual(i + 1, dq.MaximumDelay);
}
Assert.IsFalse(dq.Dequeue(0, null)); // nothing at time 0
for (uint i = 0; i < 10; i++)
{
uint expected = i;
Assert.AreEqual(10 - i, dq.Count);
Assert.AreEqual(10 - i, dq.MaximumDelay);
bool dequeued = dq.Dequeue(1, e => Assert.AreEqual(expected, e));
Assert.IsTrue(dequeued);
Assert.AreEqual(10 - (i + 1), dq.Count);
Assert.AreEqual(10 - (i + 1), dq.MaximumDelay);
Assert.IsFalse(dq.Dequeue(0, null));
}
Assert.AreEqual(0, dq.Count);
Assert.AreEqual(0, dq.MaximumDelay);
}
public void TestSequentialAddsButUnequalRemoved()
{
DelayQueue<uint> dq = new DelayQueue<uint>();
Assert.AreEqual(0, dq.Count);
Assert.AreEqual(0, dq.MaximumDelay);
for (uint i = 0; i < 5; i++)
{
dq.Enqueue(2 * i, i + 1);
dq.Enqueue(2 * i + 1, i + 1);
Assert.AreEqual(2 * (i + 1), dq.Count);
Assert.AreEqual(i + 1, dq.MaximumDelay);
}
Assert.IsFalse(dq.Dequeue(0, null)); // nothing at time 0
uint lastCount = 0;
for (uint i = 0; i < 5; i++)
{
Assert.AreEqual(10 - (2 * i), dq.Count);
Assert.AreEqual(5 - i, dq.MaximumDelay);
bool dequeued = dq.Dequeue(1, e => Assert.AreEqual(lastCount++, e));
Assert.IsTrue(dequeued);
Assert.AreEqual(10 - 2 * (i + 1), dq.Count);
Assert.AreEqual(5 - i - 1, dq.MaximumDelay);
Assert.IsFalse(dq.Dequeue(0, null));
}
Assert.AreEqual(0, dq.Count);
}
private void ProcessPacket(PacketMode mode, TransportPacket packet, DelayQueue<TransportPacket> queue)
{
uint delay = (uint)Math.Max(0, CalculateDelay());
if (Ordering != Ordering.Unordered)
{
// if this transport is ordered or sequenced, then the packets
// must be sent in order, and thus must be delayed in order.
// Thus when figuring out the possible delay of a packet,
// we must ensure it's at least as delayed as the previous
// packet, which must be the most-delayed packet.
delay = (uint)Math.Max(delay, lastPacketTime[mode] - timer.TimeInMilliseconds);
}
if (Reliability != Reliability.Reliable || Ordering != Ordering.Ordered)
{
double pDropped = PacketLossCorrelation * pLastDropped +
(1d - PacketLossCorrelation) * urng.NextDouble();
pLastDropped = pDropped;
if(pDropped < PacketLoss)
{
NotifyPacketDisposition(mode, PacketEffect.Dropped, packet);
return;
}
}
// don't include reordering time when recording the scheduled
// time for this current packet -- if we reorder by delaying,
// then we *don't* want subsequent packets
lastPacketTime[mode] = timer.TimeInMilliseconds + delay;
// Sequenced and ordered transports cannot have out-of-order packets
if (Ordering == Ordering.Unordered && urng.NextDouble() < PacketReordering)
{
// reorder packets by delaying this current packet
delay += queue.MaximumDelay == 0 ? 10u : queue.MaximumDelay / 2;
NotifyPacketDisposition(mode, PacketEffect.Reordered, packet);
}
else if(delay > 0)
{
NotifyPacketDisposition(mode, PacketEffect.Delayed, packet);
}
else
{
NotifyPacketDisposition(mode, PacketEffect.None, packet);
}
packet.Retain(); // countered in Really{Send,Receive}Packet
queue.Enqueue(packet, delay);
}
public void DelayQueueConstructorTest()
{
DelayQueue target = new DelayQueue();
Assert.AreEqual(0, target.Count);
}
