public void WorkItemWaitCanceling()
{
Assert.Throws<WorkItemTimeoutException>(() =>
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
ManualResetEvent cancelWaitHandle = new ManualResetEvent(false);
// Queue a work item that will occupy the thread in the pool
IWorkItemResult wir1 =
smartThreadPool.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
// Queue another work item that will wait for the first to complete
IWorkItemResult wir2 =
smartThreadPool.QueueWorkItem(new WorkItemCallback(this.SignalCancel), cancelWaitHandle);
try
{
wir1.GetResult(System.Threading.Timeout.Infinite, true, cancelWaitHandle);
}
finally
{
smartThreadPool.Shutdown();
}
});
}
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 WaitAllT()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
bool success = true;
IWorkItemResult<int>[] wirs = new IWorkItemResult<int>[5];
for (int i = 0; i < wirs.Length; ++i)
{
wirs[i] = smartThreadPool.QueueWorkItem(new Func<int, int, int>(System.Math.Min), i, i + 1);
}
SmartThreadPool.WaitAll(wirs);
for (int i = 0; i < wirs.Length; ++i)
{
if (!wirs[i].IsCompleted)
{
success = false;
break;
}
int result = wirs[i].GetResult();
if (i != result)
{
success = false;
break;
}
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public static void getImagesAsync(List<FilmData> tempFilmList)
{
if (isNetworkAvailable())
{
SmartThreadPool smartThreadPool = new SmartThreadPool(
15 * 1000, // Idle timeout in milliseconds
25, // Threads upper limit
1); // Threads lower limit
var bw = new System.ComponentModel.BackgroundWorker();
bw.DoWork += (s, args) =>
{
foreach (FilmData item in tempFilmList)
{
if (IsolatedStorageHelper.isFileAlreadySaved(item.imageUrl))
ImageHelper.addDownloadedItemsToFilmCollection(item.imageUrl);
else
smartThreadPool.QueueWorkItem(() => getImageFromUrl(item.imageUrl));
}
smartThreadPool.WaitForIdle(); // Wait for the completion of all work items
};
bw.RunWorkerAsync();
}
}
public void CancelCanceledWorkItem()
{
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.StartSuspended = true;
SmartThreadPool stp = new SmartThreadPool(stpStartInfo);
IWorkItemResult wir = stp.QueueWorkItem(state => null);
int counter = 0;
wir.Cancel();
try
{
wir.GetResult();
}
catch (WorkItemCancelException ce)
{
ce.GetHashCode();
++counter;
}
Assert.AreEqual(counter, 1);
wir.Cancel();
try
{
wir.GetResult();
}
finally
{
stp.Shutdown();
}
}
public void test()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
Curl.GlobalInit((int)CURLinitFlag.CURL_GLOBAL_ALL);
GlobalVar.isCrawling = true;
//string conn = string.Format(@"Data Source="+System.Environment.CurrentDirectory+"\\data\\{0}", GlobalVar.filename);
sqlitehelper con = new sqlitehelper(System.Environment.CurrentDirectory + @"\data\" + GlobalVar.filename);
string sql = "select keyword from Content where flag==0";
DataTable dt = new DataTable();
dt = con.GetDataTable(sql);
IWorkItemResult[] wir = new IWorkItemResult[dt.Rows.Count];
MessageBox.Show(dt.Rows.Count.ToString());
for (int i = 0; i < dt.Rows.Count; i++)
{
//MessageBox.Show(dt.Rows[i]["keyword"].ToString());
OneWorker one = new OneWorker(dt.Rows[i]["keyword"].ToString());
ThreadPool.QueueUserWorkItem(one.work, i);
}
bool success = SmartThreadPool.WaitAll(
wir);
if (success)
{
GlobalVar.isCrawling = false;
}
smartThreadPool.Shutdown();
}
public void TestConcurrencyChange()
{
SmartThreadPool smartThreadPool = new SmartThreadPool(10 * 1000, 1, 0);
bool success = false;
for (int i = 0; i < 100; ++i)
{
smartThreadPool.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
null);
}
smartThreadPool.Concurrency = 1;
success = WaitForMaxThreadsValue(smartThreadPool, 1, 1 * 1000);
Assert.IsTrue(success);
smartThreadPool.Concurrency = 5;
success = WaitForMaxThreadsValue(smartThreadPool, 5, 2 * 1000);
Assert.IsTrue(success);
smartThreadPool.Concurrency = 25;
success = WaitForMaxThreadsValue(smartThreadPool, 25, 4 * 1000);
Assert.IsTrue(success);
smartThreadPool.Concurrency = 10;
success = WaitForMaxThreadsValue(smartThreadPool, 10, 10 * 1000);
Assert.IsTrue(success);
smartThreadPool.Shutdown();
}
public void Test()
{
_requestReceived = new ManualResetEvent(false);
/*setup + start listening*/
var stub = new SipReceivedMessageProcessorStub(OnRequestReceived, (s,e) => { });
var listeningPoint = new IPEndPoint(TestConstants.MyIpAddress, 33333);
var f = new SipFactory();
var stp = new SmartThreadPool();
stp.Start();
var provider = new SipContextSource(listeningPoint, stp);
provider.AddListener(null);
provider.Start();
/*send a message to the listener*/
var send = new SipRequestBuilder().Build();
var requestBytes = SipFormatter.FormatMessage(send);
var udpClient = new UdpClient();
udpClient.Send(requestBytes, requestBytes.Length, listeningPoint);
_requestReceived.WaitOne();
var oc = ObjectComparer.Create();
var received = stub.Requests.First();
oc.Compare(received, send);
Assert.True(oc.Differences.Count == 0, oc.DifferencesString);
}
public void DoWork()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
DivArgs divArgs = new DivArgs();
divArgs.x = 10;
divArgs.y = 0;
IWorkItemResult wir =
smartThreadPool.QueueWorkItem(new
WorkItemCallback(this.DoDiv), divArgs);
Exception e;
object obj = wir.GetResult(out e);
// e contains the expetion that DoDiv threw
if(null == e)
{
int result = (int)obj;
}
else
{
// Do something with the exception
}
smartThreadPool.Shutdown();
}
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 TestJoin()
{
SmartThreadPool stp = new SmartThreadPool();
SafeCounter sc = new SafeCounter();
stp.Join(
sc.Increment,
sc.Increment,
sc.Increment);
Assert.AreEqual(3, sc.Counter);
for (int j = 0; j < 10; j++)
{
sc.Reset();
Action[] actions = new Action[1000];
for (int i = 0; i < actions.Length; i++)
{
actions[i] = sc.Increment;
}
stp.Join(actions);
Assert.AreEqual(actions.Length, sc.Counter);
}
stp.Shutdown();
}
private static int calculateLabel(Individual[] weights)
{
Individual[] reversedWeights = { weights[1], weights[0] };
weights[1].ResetScores();
weights[0].ResetScores();
SmartThreadPool smtp = new SmartThreadPool();
for (int index = 0; index < numberOfGames; index++)
{
if (index % 2 == 1)
{
smtp.QueueWorkItem(new WorkItemCallback(threadProc), weights);
}
else
{
smtp.QueueWorkItem(new WorkItemCallback(threadProc), reversedWeights);
}
}
smtp.WaitForIdle();
smtp.Shutdown();
//double strengthRatio = ((double)weights[0].Wins + (double)weights[0].Draws / 2) / numberOfGames;
//return strengthRatio > 0.5 ? 1 : -1;
return weights[0].Wins + 1/2 * weights[0].Draws;
}
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 ExceptionThrowing()
{
SmartThreadPool _smartThreadPool = new SmartThreadPool();
DivArgs divArgs = new DivArgs();
divArgs.x = 10;
divArgs.y = 0;
IWorkItemResult wir =
_smartThreadPool.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();
DivArgs divArgs = new DivArgs();
divArgs.x = 10;
divArgs.y = 0;
IWorkItemResult wir =
_smartThreadPool.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 TimeoutInProgressWorkItemWithSample()
{
bool timedout = false;
ManualResetEvent waitToStart = new ManualResetEvent(false);
ManualResetEvent waitToComplete = new ManualResetEvent(false);
SmartThreadPool stp = new SmartThreadPool();
IWorkItemResult wir = stp.QueueWorkItem(
new WorkItemInfo() { Timeout = 500 },
state =>
{
waitToStart.Set();
Thread.Sleep(1000);
timedout = SmartThreadPool.IsWorkItemCanceled;
waitToComplete.Set();
return null;
});
waitToStart.WaitOne();
waitToComplete.WaitOne();
Assert.IsTrue(timedout);
stp.Shutdown();
}
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);
}
private void btnStart_Click(object sender, RoutedEventArgs e)
{
if (_running)
{
_wakeupEvent.Set();
_stp.Cancel();
_stp.Shutdown(false, 5000);
_stp = null;
btnStart.Content = "Start";
//txtIdleTimeout.Enabled = true;
_running = false;
}
else
{
usageHistoryControl1.Reset();
usageControl1.Value1 = 0;
usageControl1.Value2 = 0;
_wakeupEvent.Set();
_running = true;
btnStart.Content = "Stop";
//txtIdleTimeout.Enabled = false;
STPStartInfo stpStartInfo = new STPStartInfo()
{
MinWorkerThreads = Convert.ToInt32(txtMinThreads.Text),
MaxWorkerThreads = Convert.ToInt32(txtMaxThreads.Text),
IdleTimeout = Convert.ToInt32(txtIdleTimeout.Text) * 1000,
EnableLocalPerformanceCounters = true,
};
_stp = new SmartThreadPool(stpStartInfo);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Sid.WebServices.WebService"/> class.
/// </summary>
/// <param name="sidModuleAssemblies">Names of assemblies to scan for SidModules.</param>
/// <param name="successHandler">SuccessHandler; this is a delegate that, if set,
/// executes as the last thing before the response hits the wire. It allows users to
/// set response headers.</param>
/// <param name="prefixes">The set of prefixes for the HttpListener class that Sid
/// wraps.</param>
public WebService(IEnumerable<Assembly> sidModuleAssemblies,
System.Func<IRequest, Uri, bool> IsValidOriginHandler, params string[] prefixes)
{
SetupJsonDefaults();
if (!HttpListener.IsSupported) {
throw new NotSupportedException("Not supported on this");
}
threadPool = new SmartThreadPool();
if (prefixes == null || prefixes.Length == 0) {
throw new ArgumentException("prefixes");
}
foreach (var s in prefixes) {
listener.Prefixes.Add(s);
}
methodDispatcher = new RestfulMethodDispatcher(sidModuleAssemblies) {
IsValidOrigin = IsValidOriginHandler,
};
listener.Start();
}
public void DisposeCallerState()
{
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.DisposeOfStateObjects = true;
SmartThreadPool smartThreadPool = new SmartThreadPool(stpStartInfo);
CallerState nonDisposableCallerState = new NonDisposableCallerState();
CallerState disposableCallerState = new DisposableCallerState();
IWorkItemResult wir1 =
smartThreadPool.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
nonDisposableCallerState);
IWorkItemResult wir2 =
smartThreadPool.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.
smartThreadPool.WaitForIdle();
Assert.AreEqual(2, disposableCallerState.Value);
smartThreadPool.Shutdown();
}
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 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 Init()
{
_stp = new SmartThreadPool();
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.FillStateWithArgs = true;
_wig = _stp.CreateWorkItemsGroup(10, wigStartInfo);
}
public static void Main()
{
SmartThreadPool stp = new SmartThreadPool();
stp.OnThreadInitialization += OnInitialization;
stp.OnThreadTermination += OnTermination;
stp.QueueWorkItem(DoSomeWork);
}
public void Setup()
{
_threadPool = new SmartThreadPool(10 * 1000, MaxWorkerThreads, 0);
//startInfo.
//_threadPool = new SmartThreadPool();
//_threadPool
}
public static void Shutdown()
{
if (Pool != null)
{
Pool.Shutdown();
Pool = null;
}
}
public DownloadManager()
{
_webHelper = new WebHelper();
DownLoadThreadPool = new SmartThreadPool();
_downloadJobDict = HPPClient.DownloadJobDict;
}
public BaseApproach(int autoCompleteAfterNChars, StandardEvalOutput evalOutput, PrefixProfile queryPrefixProfile)
{
_autoCompleteAfterNChars = autoCompleteAfterNChars;
_evalOutput = evalOutput;
_queryPrefixProfile = queryPrefixProfile;
_evalThreadPool = new SmartThreadPool(1000, 6);
_evalThreadPool.Start(); // Setup and start the threadpool
}
public KmlListener(SerialCommunication serial)
{
_smartThreadPool = new SmartThreadPool();
serial_comm = serial;
serial.AttitudeCommunicationReceived += new SerialCommunication.ReceiveAttitudeCommunicationFrame(serial_AttitudeCommunicationReceived);
serial.GpsBasicCommunicationReceived += new SerialCommunication.ReceiveGpsBasicCommunicationFrame(serial_GpsBasicCommunicationReceived);
serial.PressureTempCommunicationReceived += new SerialCommunication.ReceivePressureTempCommunicationFrame(serial_PressureTempCommunicationReceived);
serial.ControlInfoCommunicationReceived += new SerialCommunication.ReceiveControlInfoCommunicationFrame(serial_ControlInfoCommunicationReceived);
}
static PICSProductInfo()
{
ProcessedApps = new Dictionary<uint, IWorkItemResult>();
ProcessedSubs = new Dictionary<uint, IWorkItemResult>();
ProcessorThreadPool = new SmartThreadPool();
ProcessorThreadPool.Concurrency = 50;
ProcessorThreadPool.Name = "App/Sub Thread Pool";
}
public ICancellable Run(Action action)
{
if (_pool == null)
{
_pool = new Amib.Threading.SmartThreadPool(new Amib.Threading.STPStartInfo {
MaxWorkerThreads = OptionNumberOfThreads,
AreThreadsBackground = true,
EnableLocalPerformanceCounters = false,
WorkItemPriority = Amib.Threading.WorkItemPriority.BelowNormal
});
}
return(new CancellableWrapper(_pool.QueueWorkItem(new Amib.Threading.Action(action))));
}
protected AppSelfHostBase(string serviceName, string handlerPath, params Assembly[] assembliesWithServices)
: base(serviceName, handlerPath, assembliesWithServices)
{
threadPoolManager = new Amib.Threading.SmartThreadPool(IdleTimeout,
maxWorkerThreads: Math.Max(16, Environment.ProcessorCount * 2));
}
protected AppHostHttpListenerSmartPoolBase(string serviceName, string handlerPath, int poolSize, params Assembly[] assembliesWithServices)
: base(serviceName, handlerPath, assembliesWithServices)
{
threadPoolManager = new Amib.Threading.SmartThreadPool(IdleTimeout, poolSize);
}
public void Clean()
{
WorkThread = null;
_associatedSmartThreadPool = null;
}
public ThreadEntry(SmartThreadPool stp)
{
_associatedSmartThreadPool = stp;
_creationTime = DateTime.UtcNow;
_lastAliveTime = DateTime.MinValue;
}