public void TestConcurrencyInThreadsAndMicrothreads()
{
var scheduler = new Scheduler();
var microThreadLock = new MicroThreadLock();
var counter = 0;
for (var j = 0; j < ThreadCount; ++j)
{
var microThread = scheduler.Create();
microThread.Start(async() =>
{
using (await microThreadLock.LockAsync())
{
var initialValue = counter;
for (var i = 0; i < IncrementCount; ++i)
{
Assert.AreEqual(initialValue + i, counter);
await Task.Yield();
++counter;
}
}
});
}
var threads = new List <Thread>();
for (var j = 0; j < ThreadCount; ++j)
{
var thread = new Thread(() =>
{
var sc = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(sc);
sc.Post(async x =>
{
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
var initialValue = counter;
for (var i = 0; i < IncrementCount; ++i)
{
Assert.AreEqual(initialValue + i, counter);
Thread.Sleep(1);
++counter;
}
}
sc.SignalEnd();
}, null);
sc.RunUntilEnd();
})
{
Name = $"Thread {j}"
};
thread.Start();
threads.Add(thread);
}
while (scheduler.MicroThreads.Count > 0)
{
scheduler.Run();
}
threads.ForEach(x => x.Join());
Assert.AreEqual(2 * ThreadCount * IncrementCount, counter);
}
public void TestConcurrencyInTasks()
{
var microThreadLock = new MicroThreadLock();
var counter = 0;
var tasks = new List <Task>();
for (var j = 0; j < ThreadCount; ++j)
{
var task = Task.Run(async() =>
{
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
var initialValue = counter;
for (var i = 0; i < IncrementCount; ++i)
{
Assert.AreEqual(initialValue + i, counter);
//Thread.Sleep(1);
++counter;
}
}
});
tasks.Add(task);
}
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(ThreadCount * IncrementCount, counter);
}
public void TestConcurrencyInMicrothreads()
{
var scheduler = new Scheduler();
var microThreadLock = new MicroThreadLock();
var counter = 0;
for (var j = 0; j < ThreadCount; ++j)
{
var microThread = scheduler.Create();
microThread.Start(async() =>
{
using (await microThreadLock.LockAsync())
{
var initialValue = counter;
for (var i = 0; i < IncrementCount; ++i)
{
Assert.AreEqual(initialValue + i, counter);
await Task.Yield();
++counter;
}
}
});
}
while (scheduler.MicroThreads.Count > 0)
{
scheduler.Run();
}
Assert.AreEqual(ThreadCount * IncrementCount, counter);
}
public void TestConcurrencyInTasksAndMicrothreads()
{
var scheduler = new Scheduler();
var microThreadLock = new MicroThreadLock();
var counter = 0;
for (var j = 0; j < ThreadCount; ++j)
{
var microThread = scheduler.Create();
microThread.Start(async() =>
{
using (await microThreadLock.LockAsync())
{
var initialValue = counter;
for (var i = 0; i < IncrementCount; ++i)
{
Assert.AreEqual(initialValue + i, counter);
await Task.Yield();
++counter;
}
}
});
}
var tasks = new List <Task>();
for (var j = 0; j < ThreadCount; ++j)
{
var task = Task.Run(async() =>
{
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
var initialValue = counter;
for (var i = 0; i < IncrementCount; ++i)
{
Assert.AreEqual(initialValue + i, counter);
Thread.Sleep(1);
++counter;
}
}
});
tasks.Add(task);
}
while (scheduler.MicroThreads.Count > 0)
{
scheduler.Run();
}
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(2 * ThreadCount * IncrementCount, counter);
}
public void TestReentrancyInThreads()
{
var microThreadLock = new MicroThreadLock();
var counter = 0;
var threads = new List <Thread>();
for (var j = 0; j < ThreadCount; ++j)
{
var thread = new Thread(() =>
{
var sc = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(sc);
sc.Post(async x =>
{
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
var initialValue = counter;
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
for (var i = 0; i < IncrementCount; ++i)
{
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
Assert.AreEqual(initialValue + i, counter);
}
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
Thread.Sleep(1);
}
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
++counter;
}
}
}
}
sc.SignalEnd();
}, null);
sc.RunUntilEnd();
})
{
Name = $"Thread {j}"
};
thread.Start();
threads.Add(thread);
}
threads.ForEach(x => x.Join());
Assert.AreEqual(ThreadCount * IncrementCount, counter);
}
