public bool Dequeue(out T t)
{
t = default(T);
lock (_lock)
{
while (!_token.IsCancellationRequested && RealTimeQueue <T> .IsEmpty(_queue))
{
Monitor.Wait(_lock);
}
// We can exit, once the queue is empty.
if (RealTimeQueue <T> .IsEmpty(_queue))
{
return(false);
}
_count--;
t = RealTimeQueue <T> .Head(_queue);
_queue = RealTimeQueue <T> .Tail(_queue);
Monitor.PulseAll(_lock);
}
return(true);
}
public void PerfTest()
{
var heap = RealTimeQueue <int> .Empty;
for (var i = 0; i < Size; i++)
{
heap = RealTimeQueue <int> .Snoc(heap, i);
}
Console.WriteLine(DumpQueue(heap, true));
var count = 0;
while (!RealTimeQueue <int> .IsEmpty(heap))
{
var next = RealTimeQueue <int> .Head(heap);
Assert.AreEqual(count, next);
heap = RealTimeQueue <int> .Tail(heap);
count++;
}
Assert.AreEqual(Size, count);
}
public void Simple()
{
const int N = 100;
var queues = new RealTimeQueue <int> [N][];
for (int i = 0; i < queues.Length; i++)
{
queues[0] = new RealTimeQueue <int> [N];
}
queues[0][0] = RealTimeQueue <int> .Empty;
for (int i = 0; i + 1 < N; i++)
{
queues[0][i + 1] = queues[0][i].Enqueue(i);
}
for (int i = 0; i + 1 < N; i++)
{
queues[i + 1] = new RealTimeQueue <int> [N];
for (int j = i + 1; j < N; j++)
{
queues[i + 1][j] = queues[i][j].Dequeue(out var v);
v.Should().Be(i);
}
}
for (int i = 0; i + 1 < N; i++)
{
queues[i][i].Should().BeSameAs(RealTimeQueue <int> .Empty);
for (int j = i + 1; j < N; j++)
{
queues[i][j].Should().Equal(Enumerable.Range(i, j - i));
}
}
}
public void TailTest()
{
const string data = "One Two Three One Three";
var queue = data.Split().Aggregate(RealTimeQueue <string> .Empty, RealTimeQueue <string> .Snoc);
var tail = RealTimeQueue <string> .Tail(queue);
Assert.AreEqual("[{Two, Three}, [Three, One], {}]", DumpQueue(tail, true));
}
public void HeadTest()
{
const string data = "One Two Three One Three";
var queue = data.Split().Aggregate(RealTimeQueue <string> .Empty, RealTimeQueue <string> .Snoc);
var head = RealTimeQueue <string> .Head(queue);
Assert.AreEqual("One", head);
}
public void EmptyTest()
{
var queue = RealTimeQueue <string> .Empty;
Assert.IsTrue(RealTimeQueue <string> .IsEmpty(queue));
queue = RealTimeQueue <string> .Snoc(queue, "Item");
Assert.IsFalse(RealTimeQueue <string> .IsEmpty(queue));
queue = RealTimeQueue <string> .Tail(queue);
Assert.IsTrue(RealTimeQueue <string> .IsEmpty(queue));
}
public void PushPopTest()
{
const string data = "One Two Three One Three";
var queue = data.Split().Aggregate(RealTimeQueue <string> .Empty, RealTimeQueue <string> .Snoc);
foreach (var expected in data.Split())
{
var head = RealTimeQueue <string> .Head(queue);
Assert.AreEqual(expected, head);
queue = RealTimeQueue <string> .Tail(queue);
}
Assert.IsTrue(RealTimeQueue <string> .IsEmpty(queue));
}
public void SnocTest()
{
var queue = RealTimeQueue <string> .Empty;
queue = RealTimeQueue <string> .Snoc(queue, "One");
Assert.AreEqual("[{$}, null, {$}]", DumpQueue(queue, false));
queue = RealTimeQueue <string> .Snoc(queue, "Two");
Assert.AreEqual("[{One}, [Two], {}]", DumpQueue(queue, false));
queue = RealTimeQueue <string> .Snoc(queue, "Three");
Assert.AreEqual("[{$One, $Two, $Three}, null, {One, Two, Three}]", DumpQueue(queue, true));
}
public static string DumpQueue <T>(RealTimeQueue <T> .Queue queue, bool expandUnCreated)
{
if (RealTimeQueue <T> .IsEmpty(queue))
{
return(string.Empty);
}
var result = new StringBuilder();
result.Append("[{");
result.Append(StreamTests.DumpStream(queue.F, expandUnCreated));
result.Append("}, ");
result.Append(queue.R?.ToReadableString() ?? "null");
result.Append(", {");
result.Append(StreamTests.DumpStream(queue.S, expandUnCreated));
result.Append("}]");
return(result.ToString());
}
public override void Solve(ConsoleReader cr, ConsoleWriter cw)
{
int q = cr;
var queues = new RealTimeQueue <int> [q];
for (int i = 0; i < q; i++)
{
var type = cr.Int();
var t = cr.Int();
var prev = (uint)t < (uint)queues.Length ? queues[t] : RealTimeQueue <int> .Empty;
if (type == 0)
{
queues[i] = prev.Enqueue(cr.Int());
}
else
{
queues[i] = prev.Dequeue(out var v);
cw.WriteLine(v);
}
}
}
public bool Enqueue(T t)
{
lock (_lock)
{
while (!_token.IsCancellationRequested && _count >= _size)
{
Monitor.Wait(_lock);
}
if (_token.IsCancellationRequested)
{
return(false);
}
_count++;
_queue = RealTimeQueue <T> .Snoc(_queue, t);
Monitor.PulseAll(_lock);
}
return(true);
}
public Task Scan()
{
Stopped.Value = false;
return(Task.Factory.StartNew(state =>
{
if (!((InternalStop)state).Value)
{
BacklogQueue.Scan();
InProcessQueue.Scan(); // for directly insert data to db
if (_firstRun)
{
_firstRun = false;
RealTimeQueue.Scan();
EmailMessage message;
while (!((InternalStop)state).Value && RealTimeQueue.Dequeue(out message))
{
InProcessQueue.Enqueue(message);
}
}
}
}, Stopped, TaskCreationOptions.AttachedToParent));
}
/// <summary>
/// Creates the workers and work slots to match the number
/// of available processors.
/// </summary>
public WorkerThreads()
{
#if FORCE_SINGLETHREADED
var count = 1;
#warning KERNEL FORCED TO SINGLE THREADED MODE!
#else
var count = Environment.ProcessorCount * 2; // TESTING WITH 4 THREADS PER CORE... TODO: fix the deadlocks instead
#endif
// create the real time thread
_realTimeWork = new RealTimeQueue <IKernelTask>();
_realTimeThread = new Thread(RealTimeThreadMain);
// create empty standard work load
_work = new IKernelTask[count];
for (var i = 0; i < count; i++)
{
_work[i] = null;
}
//start up the threads
_threads = new Thread[count];
Start();
}
public void EmptySnocTest()
{
AssertThrows <NullReferenceException>(() => RealTimeQueue <string> .Snoc(null, "Item"));
}
public void EmptyTailTest()
{
var queue = RealTimeQueue <string> .Empty;
AssertThrows <ArgumentNullException>(() => RealTimeQueue <string> .Tail(queue));
}
/// <summary>
/// Initializes a new instance of the <see cref="Enumerator"/> struct.
/// </summary>
/// <param name="queue">The queue to enumerate.</param>
internal EnumeratorObject(RealTimeQueue <T> queue)
{
_originalQueue = queue;
}
