public void TestLongProcessWork()
{
using (StaticThreadPool testInst = new StaticThreadPool(Environment.ProcessorCount, 100, "name"))
{
Assert.AreEqual(Environment.ProcessorCount, testInst.ThreadCount);
Assert.AreEqual(100, testInst.QueueCapacity);
int expectedWork = 100;
int executedWork = 0;
for (int i = 0; i < expectedWork; i++)
{
testInst.Run(() =>
{
Thread.Sleep(300);
Interlocked.Increment(ref executedWork);
});
}
testInst.Dispose(true, true, true);
Assert.AreEqual(0, testInst.ThreadCount);
Assert.IsFalse(testInst.IsWork);
Assert.AreEqual(expectedWork, executedWork);
}
}
public void WaitUntilStopWorkCorrect()
{
using (StaticThreadPool testInst = new StaticThreadPool(Environment.ProcessorCount, -1, "name"))
{
Assert.AreEqual(-1, testInst.QueueCapacity);
int expectedWork = 100;
int executedWork = 0;
for (int i = 0; i < expectedWork; i++)
{
testInst.Run(() =>
{
Thread.Sleep(200);
Interlocked.Increment(ref executedWork);
});
}
testInst.Dispose(false, true, false);
Assert.IsTrue(executedWork < expectedWork);
Assert.IsTrue(testInst.State == ThreadPoolState.StopRequested);
testInst.WaitUntilStop();
Assert.IsTrue(testInst.State == ThreadPoolState.Stopped);
Assert.AreEqual(expectedWork, executedWork);
}
}
public void TestQueueCapacityBoundExtends()
{
using (StaticThreadPool testInst = new StaticThreadPool(Environment.ProcessorCount, 10, "name"))
{
int expectedWork = 25;
int executedWork = 0;
ManualResetEventSlim tracker = new ManualResetEventSlim();
for (int i = 0; i < expectedWork; i++)
{
testInst.Run(() =>
{
tracker.Wait();
Interlocked.Increment(ref executedWork);
});
}
tracker.Set();
testInst.Dispose(true, true, true);
Assert.AreEqual(expectedWork, executedWork);
}
}
public void TestCantAddAfterCompleteAdding()
{
using (StaticThreadPool testInst = new StaticThreadPool(Environment.ProcessorCount, -1, "name"))
{
Assert.IsTrue(testInst.TryRun(() => { }));
testInst.CompleteAdding();
Assert.IsFalse(testInst.TryRun(() => { }));
testInst.Run(() => { });
}
}
public void StaticThreadPoolChangeThreadCount()
{
using (StaticThreadPool testInst = new StaticThreadPool(0, -1, "name"))
{
int expectedWork = 100;
int executedWork = 0;
for (int i = 0; i < expectedWork; i++)
{
if (i == 30)
{
testInst.AddThreads(10);
}
else if (i == 50)
{
testInst.RemoveThreads(5);
}
else if (i == 80)
{
testInst.SetThreadCount(2);
}
testInst.Run(() =>
{
Thread.Sleep(200);
Interlocked.Increment(ref executedWork);
});
Thread.Sleep(10);
}
SpinWait.SpinUntil(() => executedWork == expectedWork);
Assert.AreEqual(2, testInst.ThreadCount);
testInst.Dispose(true, true, true);
Assert.AreEqual(0, testInst.ThreadCount);
Assert.IsFalse(testInst.IsWork);
Assert.AreEqual(expectedWork, executedWork);
}
}
private void RunTestOnPool(StaticThreadPool pool, int totalTaskCount, int taskSpinCount, int spawnThreadCount, int spawnSpinTime, bool spawnFromPool)
{
Random rndGenerator = new Random();
int executedTaskCounter = 0;
int completedTaskCount = 0;
Action taskAction = null;
taskAction = () =>
{
int curTaskSpinCount = taskSpinCount;
lock (rndGenerator)
curTaskSpinCount = rndGenerator.Next(taskSpinCount);
SpinWaitHelper.SpinWait(curTaskSpinCount);
if (spawnFromPool)
{
if (Interlocked.Increment(ref executedTaskCounter) <= totalTaskCount)
{
pool.Run(taskAction);
}
}
Interlocked.Increment(ref completedTaskCount);
};
Barrier bar = new Barrier(spawnThreadCount + 1);
Random spawnRndGenerator = new Random();
Thread[] spawnThreads = new Thread[spawnThreadCount];
ThreadStart spawnAction = () =>
{
bar.SignalAndWait();
while (Interlocked.Increment(ref executedTaskCounter) <= totalTaskCount)
{
pool.Run(taskAction);
int curSpawnSpinCount = spawnSpinTime;
lock (spawnRndGenerator)
curSpawnSpinCount = spawnRndGenerator.Next(spawnSpinTime);
SpinWaitHelper.SpinWait(curSpawnSpinCount);
}
};
for (int i = 0; i < spawnThreads.Length; i++)
{
spawnThreads[i] = new Thread(spawnAction);
}
for (int i = 0; i < spawnThreads.Length; i++)
{
spawnThreads[i].Start();
}
bar.SignalAndWait();
TimingAssert.AreEqual(60 * 1000, totalTaskCount, () => Volatile.Read(ref completedTaskCount));
}