public void TwoWIGsStartSuspended()
{
SmartThreadPool stp = new SmartThreadPool();
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.StartSuspended = true;
IWorkItemsGroup wig1 = stp.CreateWorkItemsGroup(10, wigStartInfo);
IWorkItemsGroup wig2 = stp.CreateWorkItemsGroup(10, wigStartInfo);
wig1.QueueWorkItem(new WorkItemCallback(this.DoWork));
wig2.QueueWorkItem(new WorkItemCallback(this.DoWork));
Assert.IsFalse(wig1.WaitForIdle(200));
Assert.IsFalse(wig2.WaitForIdle(200));
wig1.Start();
Assert.IsTrue(wig1.WaitForIdle(200));
Assert.IsFalse(wig2.WaitForIdle(200));
wig2.Start();
Assert.IsTrue(wig1.WaitForIdle(0));
Assert.IsTrue(wig2.WaitForIdle(200));
}
public void WaitForIdleOnSTPThreadForAnotherWorkItemsGroup()
{
SmartThreadPool smartThreadPool = new SmartThreadPool(10*1000, 25, 0);
IWorkItemsGroup workItemsGroup1 = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
IWorkItemsGroup workItemsGroup2 = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
workItemsGroup1.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
1000);
workItemsGroup1.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
1000);
IWorkItemResult wir = workItemsGroup2.QueueWorkItem(
new WorkItemCallback(this.DoWaitForIdle),
workItemsGroup1);
Exception e;
wir.GetResult(out e);
smartThreadPool.Shutdown();
Assert.IsNull(e);
}
public void TestWIGConcurrencyChange2WIGs()
{
SmartThreadPool smartThreadPool = new SmartThreadPool(10 * 1000, 2, 0);
Assert.IsTrue(0 == smartThreadPool.WaitingCallbacks);
PauseSTP(smartThreadPool);
PauseSTP(smartThreadPool);
Thread.Sleep(100);
Assert.IsTrue(0 == smartThreadPool.WaitingCallbacks);
IWorkItemsGroup wig1 = smartThreadPool.CreateWorkItemsGroup(1);
IWorkItemsGroup wig2 = smartThreadPool.CreateWorkItemsGroup(1);
wig1.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
Assert.IsTrue(1 == smartThreadPool.WaitingCallbacks);
wig2.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
Assert.IsTrue(2 == smartThreadPool.WaitingCallbacks);
wig1.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
Assert.IsTrue(2 == smartThreadPool.WaitingCallbacks);
wig2.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
Assert.IsTrue(2 == smartThreadPool.WaitingCallbacks);
wig1.Concurrency = 2;
Thread.Sleep(100);
Assert.IsTrue(3 == smartThreadPool.WaitingCallbacks);
wig2.Concurrency = 2;
Thread.Sleep(100);
Assert.IsTrue(4 == smartThreadPool.WaitingCallbacks);
ResumeSTP(smartThreadPool);
Thread.Sleep(100);
Assert.IsTrue(0 == smartThreadPool.WaitingCallbacks);
PauseSTP(smartThreadPool);
PauseSTP(smartThreadPool);
Thread.Sleep(100);
wig1.Concurrency = 1;
wig1.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
Assert.IsTrue(1 == smartThreadPool.WaitingCallbacks);
wig2.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
Assert.IsTrue(2 == smartThreadPool.WaitingCallbacks);
ResumeSTP(smartThreadPool);
Thread.Sleep(100);
Assert.IsTrue(0 == smartThreadPool.WaitingCallbacks);
smartThreadPool.Shutdown();
}
public void ExceptionThrowing()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
DivArgs divArgs = new DivArgs();
divArgs.x = 10;
divArgs.y = 0;
IWorkItemResult wir =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoDiv), divArgs);
try
{
wir.GetResult();
}
catch(WorkItemResultException wire)
{
Assert.IsTrue(wire.InnerException is DivideByZeroException);
return;
}
catch(Exception e)
{
e.GetHashCode();
Assert.Fail();
}
Assert.Fail();
}
public void ExceptionReturning()
{
bool success = true;
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
DivArgs divArgs = new DivArgs();
divArgs.x = 10;
divArgs.y = 0;
IWorkItemResult wir =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoDiv), divArgs);
Exception e = null;
try
{
wir.GetResult(out e);
}
catch (Exception ex)
{
ex.GetHashCode();
success = false;
}
Assert.IsTrue(success);
Assert.IsTrue(e is DivideByZeroException);
}
public void DisposeCallerState()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.DisposeOfStateObjects = true;
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue, wigStartInfo);
CallerState nonDisposableCallerState = new NonDisposableCallerState();
CallerState disposableCallerState = new DisposableCallerState();
IWorkItemResult wir1 =
workItemsGroup.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
nonDisposableCallerState);
IWorkItemResult wir2 =
workItemsGroup.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
disposableCallerState);
wir1.GetResult();
Assert.AreEqual(1, nonDisposableCallerState.Value);
wir2.GetResult();
// Wait a little bit for the working thread to call dispose on the
// work item's state.
workItemsGroup.WaitForIdle();
Assert.AreEqual(2, disposableCallerState.Value);
smartThreadPool.Shutdown();
}
public void STPAndWIGStartSuspended()
{
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.StartSuspended = true;
SmartThreadPool stp = new SmartThreadPool(stpStartInfo);
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.StartSuspended = true;
IWorkItemsGroup wig = stp.CreateWorkItemsGroup(10, wigStartInfo);
wig.QueueWorkItem(new WorkItemCallback(this.DoWork));
Assert.IsFalse(wig.WaitForIdle(200));
wig.Start();
Assert.IsFalse(wig.WaitForIdle(200));
stp.Start();
Assert.IsTrue(wig.WaitForIdle(5000), "WIG is not idle");
Assert.IsTrue(stp.WaitForIdle(5000), "STP is not idle");
}
public void WaitAny()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
bool success = false;
IWorkItemResult [] wirs = new IWorkItemResult[5];
for(int i = 0; i < wirs.Length; ++i)
{
wirs[i] =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
}
int index = SmartThreadPool.WaitAny(wirs);
if (wirs[index].IsCompleted)
{
int result = (int)wirs[index].GetResult();
if (1 == result)
{
success = true;
}
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public void WorkItemWaitCanceling()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
ManualResetEvent cancelWaitHandle = new ManualResetEvent(false);
bool success = false;
// Queue a work item that will occupy the thread in the pool
IWorkItemResult wir1 =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
// Queue another work item that will wait for the first to complete
IWorkItemResult wir2 =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.SignalCancel), cancelWaitHandle);
try
{
wir1.GetResult(System.Threading.Timeout.Infinite, true, cancelWaitHandle);
}
catch (WorkItemTimeoutException)
{
success = true;
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public void TestWIGConcurrencyChange()
{
SmartThreadPool smartThreadPool = new SmartThreadPool(10 * 1000, 25, 0);
IWorkItemsGroup wig = smartThreadPool.CreateWorkItemsGroup(smartThreadPool.MaxThreads);
bool success = false;
for (int i = 0; i < 100; ++i)
{
wig.QueueWorkItem(new WorkItemCallback(this.DoSomeLongWork), null);
}
wig.Concurrency = 1;
success = WaitForWIGThreadsInUse(wig, 1, 1 * 1000);
Assert.IsTrue(success);
wig.Concurrency = 5;
success = WaitForWIGThreadsInUse(wig, 5, 2 * 1000);
Assert.IsTrue(success);
wig.Concurrency = 25;
success = WaitForWIGThreadsInUse(wig, 25, 4 * 1000);
Assert.IsTrue(success);
wig.Concurrency = 10;
success = WaitForWIGThreadsInUse(wig, 10, 10 * 1000);
Assert.IsTrue(success);
smartThreadPool.Shutdown();
}
public void Init()
{
_stp = new SmartThreadPool();
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.FillStateWithArgs = true;
_wig = _stp.CreateWorkItemsGroup(10, wigStartInfo);
}
public HashCalculator(IHashAlgorithm method, SmartThreadPool pool)
{
_method = method;
_pool = pool;
if(_hashGroup == null)
{
_hashGroup = _pool.CreateWorkItemsGroup(1);
}
}
public void GoodCallback()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
workItemsGroup.QueueWorkItem(new WorkItemCallback(DoWork));
workItemsGroup.WaitForIdle();
smartThreadPool.Shutdown();
}
public void ChainedDelegatesCallback()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
WorkItemCallback workItemCallback = new WorkItemCallback(DoWork);
workItemCallback += new WorkItemCallback(DoWork);
workItemsGroup.QueueWorkItem(workItemCallback);
workItemsGroup.WaitForIdle();
smartThreadPool.Shutdown();
}
public void Cancel1WIGof2WorkItems()
{
int counter1 = 0;
int counter2 = 0;
SmartThreadPool stp = new SmartThreadPool();
IWorkItemsGroup wig1 = stp.CreateWorkItemsGroup(3);
IWorkItemsGroup wig2 = stp.CreateWorkItemsGroup(3);
for (int i = 0; i < 3; i++)
{
wig1.QueueWorkItem(
state => { Interlocked.Increment(ref counter1); Thread.Sleep(500); Interlocked.Increment(ref counter1); return null; }
);
}
for (int i = 0; i < 3; i++)
{
wig2.QueueWorkItem(
state => { Thread.Sleep(500); Interlocked.Increment(ref counter2); return null; }
);
}
while (counter1 < 3)
{
Thread.Sleep(1);
}
wig1.Cancel(true);
stp.WaitForIdle();
Assert.AreEqual(3, counter1, "Cancelled WIG1");
Assert.AreEqual(3, counter2, "Normal WIG2");
stp.Shutdown();
}
public void WaitForIdleEvent()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(1);
ManualResetEvent wigIsIdle = new ManualResetEvent(false);
workItemsGroup.OnIdle += wig => wigIsIdle.Set();
workItemsGroup.QueueWorkItem(() => { });
bool eventFired = wigIsIdle.WaitOne(100, true);
smartThreadPool.Shutdown();
Assert.IsTrue(eventFired);
}
public void DoWork(object [] states)
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup wig = smartThreadPool.CreateWorkItemsGroup(1);
wig.OnIdle += wig_OnIdle;
foreach(object state in states)
{
wig.QueueWorkItem(new
WorkItemCallback(this.DoSomeWork), state);
}
smartThreadPool.WaitForIdle();
smartThreadPool.Shutdown();
}
public void ChainedDelegatesCallback()
{
Assert.Throws<NotSupportedException>(() =>
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
WorkItemCallback workItemCallback = new WorkItemCallback(DoWork);
workItemCallback += new WorkItemCallback(DoWork);
workItemsGroup.QueueWorkItem(workItemCallback);
workItemsGroup.WaitForIdle();
smartThreadPool.Shutdown();
});
}
public void DoWork(object [] states)
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
// Create a work items group that processes
// one work item at a time
IWorkItemsGroup wig = smartThreadPool.CreateWorkItemsGroup(1);
// Queue some work items
foreach(object state in states)
{
wig.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), state);
}
// Wait for the completion of all work items in the work items group
wig.WaitForIdle();
smartThreadPool.Shutdown();
}
private void Concurrency(
int concurrencyPerWig,
int wigsCount,
int workItemsCount)
{
Console.WriteLine(
"Testing : concurrencyPerWig = {0}, wigsCount = {1}, workItemsCount = {2}",
concurrencyPerWig,
wigsCount,
workItemsCount);
_success = true;
_concurrencyPerWig = concurrencyPerWig;
_randGen = new Random(0);
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.StartSuspended = true;
SmartThreadPool stp = new SmartThreadPool(stpStartInfo);
_concurrentOps = new int[wigsCount];
IWorkItemsGroup [] wigs = new IWorkItemsGroup[wigsCount];
for(int i = 0; i < wigs.Length; ++i)
{
wigs[i] = stp.CreateWorkItemsGroup(_concurrencyPerWig);
for(int j = 0; j < workItemsCount; ++j)
{
wigs[i].QueueWorkItem(new WorkItemCallback(this.DoWork), i);
}
wigs[i].Start();
}
stp.Start();
stp.WaitForIdle();
Assert.IsTrue(_success);
stp.Shutdown();
}
public void ChainedDelegatesPostExecute()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
PostExecuteWorkItemCallback postExecuteWorkItemCallback =
new PostExecuteWorkItemCallback(DoPostExecute);
postExecuteWorkItemCallback +=
new PostExecuteWorkItemCallback(DoPostExecute);
workItemsGroup.QueueWorkItem(
new WorkItemCallback(DoWork),
null,
postExecuteWorkItemCallback);
workItemsGroup.WaitForIdle();
smartThreadPool.Shutdown();
}
public void BlockingCall()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
bool success = false;
IWorkItemResult wir =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
if (!wir.IsCompleted)
{
int result = (int)wir.GetResult();
success = (1 == result);
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public void WaitAllWithTimeoutFailure()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
IWorkItemResult [] wirs = new IWorkItemResult[5];
for(int i = 0; i < wirs.Length; ++i)
{
wirs[i] =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
}
bool timeout = !SmartThreadPool.WaitAll(wirs, 10, true);
bool success = timeout;
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public void WaitForIdle()
{
SmartThreadPool smartThreadPool = new SmartThreadPool(10*1000, 25, 0);
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
ManualResetEvent isRunning = new ManualResetEvent(false);
for (int i = 0; i < 4; ++i)
{
workItemsGroup.QueueWorkItem(delegate { isRunning.WaitOne(); });
}
bool success = !workItemsGroup.WaitForIdle(1000);
isRunning.Set();
success = success && workItemsGroup.WaitForIdle(1000);
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public void DoWork(object [] states)
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.StartSuspended = true;
IWorkItemsGroup wig = smartThreadPool.CreateWorkItemsGroup(1, wigStartInfo);
foreach(object state in states)
{
wig.QueueWorkItem(new
WorkItemCallback(this.DoSomeWork), state);
}
// Start working on the work items in the work items group queue
wig.Start();
// Wait for the completion of all work items
wig.WaitForIdle();
smartThreadPool.Shutdown();
}
public void Timeout()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
bool success = false;
IWorkItemResult wir =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
try
{
wir.GetResult(500, true);
}
catch (WorkItemTimeoutException)
{
success = true;
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public void WaitForIdleWithCancel()
{
SmartThreadPool smartThreadPool = new SmartThreadPool(10 * 1000, 1, 1);
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(2);
_x = 0;
IWorkItemResult wir1 = workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), 1000);
IWorkItemResult wir2 = workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), 1000);
IWorkItemResult wir3 = workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), 1000);
while (0 == _x)
{
Thread.Sleep(10);
}
Console.WriteLine("{0}: Cancelling WIG", DateTime.Now.ToLongTimeString());
workItemsGroup.Cancel();
// At this point:
// The first work item is running
// The second work item is cancelled, but waits in the STP queue
// The third work item is cancelled.
Assert.AreEqual(1, _x);
Assert.IsTrue(wir2.IsCanceled);
Assert.IsTrue(wir3.IsCanceled);
// Make sure the workItemsGroup is still idle
Assert.IsFalse(workItemsGroup.IsIdle);
Console.WriteLine("{0}: Waiting for 1st result", DateTime.Now.ToLongTimeString());
wir1.GetResult();
Assert.AreEqual(2, _x);
bool isIdle = workItemsGroup.WaitForIdle(100);
Assert.IsTrue(isIdle);
smartThreadPool.Shutdown();
}
public void WaitAnyWithTimeoutSuccess()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
bool success;
IWorkItemResult [] wirs = new IWorkItemResult[5];
for(int i = 0; i < wirs.Length; ++i)
{
wirs[i] =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
}
int index = SmartThreadPool.WaitAny(wirs, 1500, true);
success = (index != WaitHandle.WaitTimeout);
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public void CancelWIGWorkItems()
{
// I don't use lock on the counter, since any number above 0 is a failure.
// In the worst case counter will be equal to 1 which is still not 0.
int counter = 0;
SmartThreadPool stp = new SmartThreadPool();
IWorkItemsGroup wig = stp.CreateWorkItemsGroup(10);
for (int i = 0; i < 10; i++)
{
wig.QueueWorkItem(
state => { Thread.Sleep(500); ++counter; return null; }
);
}
Thread.Sleep(100);
wig.Cancel(true);
Assert.AreEqual(counter, 0);
stp.Shutdown();
}
private void InitSTP()
{
STPStartInfo stpStartInfo =
new STPStartInfo
{
StartSuspended = true,
MaxWorkerThreads = ((int)spinCon6.Value),
IdleTimeout = int.Parse(spinIdleTimeout.Text) * 1000,
};
if (_useWindowsPerformanceCounters)
{
stpStartInfo.PerformanceCounterInstanceName = "WIG Test SmartThreadPool";
}
else
{
stpStartInfo.EnableLocalPerformanceCounters = true;
}
_smartThreadPool = new SmartThreadPool(stpStartInfo);
_wig1 = _smartThreadPool.CreateWorkItemsGroup((int)spinCon1.Value);
_wig2 = _smartThreadPool.CreateWorkItemsGroup((int)spinCon2.Value);
_wig3 = _smartThreadPool.CreateWorkItemsGroup((int)spinCon3.Value);
spinCon1.Tag = _wig1;
spinCon2.Tag = _wig2;
spinCon3.Tag = _wig3;
spinCon6.Tag = _smartThreadPool;
comboWIPriority1.SelectedIndex = 1;
comboWIPriority2.SelectedIndex = 1;
comboWIPriority3.SelectedIndex = 1;
comboWIPriority6.SelectedIndex = 1;
_wigEntries = new WigEntry[]
{
new WigEntry(_wig1, queueUsageControl1, lblStatus1),
new WigEntry(_wig2, queueUsageControl2, lblStatus2),
new WigEntry(_wig3, queueUsageControl3, lblStatus3),
};
for (int i = 0; i < _lastIndex.Length; i++)
{
_lastIndex[i] = 1;
}
}