private void QueueWorkItems(IWorkItemsGroup group, IEnumerable <Action> actionGroup) { foreach (Action action in actionGroup) { Action action_ = action; group.QueueWorkItem( o => { try { action_(); } catch (Exception e) { ExecutionException = e; bool abort = false; if (OnException != null) { OnException(e, out abort); } group.Cancel(abort); } return(null); }, this, wi => { //if (wi.Exception != null) { } }); } }
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(Crestron.SimplSharp.Timeout.Infinite, true, cancelWaitHandle); } catch (WorkItemTimeoutException) { success = true; } smartThreadPool.Shutdown(); Assert.IsTrue(success); }
/// <summary> /// Create a new work item /// </summary> /// <param name = "wigStartInfo">Work item group start information</param> /// <param name = "callback">A callback to execute</param> /// <returns>Returns a work item</returns> public static WorkItem CreateWorkItem( IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemCallback callback) { return CreateWorkItem(workItemsGroup, wigStartInfo, callback, null); }
/// <summary> /// 实例化QueueService /// </summary> /// <param name="smart"></param> /// <param name="logger"></param> /// <param name="service"></param> /// <param name="elapsedTime"></param> public AsyncService(IWorkItemsGroup group, ILog logger, IService service, TimeSpan elapsedTime) { this.smart = group; this.logger = logger; this.service = service; this.elapsedTime = elapsedTime; }
public int Choice(IEnumerable <Action> actions) { WIGStartInfo wigStartInfo = new WIGStartInfo { StartSuspended = true }; IWorkItemsGroup workItemsGroup = this.CreateWorkItemsGroup(2147483647, wigStartInfo); ManualResetEvent anActionCompleted = new ManualResetEvent(false); SmartThreadPool.ChoiceIndex choiceIndex = new SmartThreadPool.ChoiceIndex(); int num = 0; foreach (Action current in actions) { Action act = current; int value = num; workItemsGroup.QueueWorkItem(delegate { act(); Interlocked.CompareExchange(ref choiceIndex._index, value, -1); anActionCompleted.Set(); }); num++; } workItemsGroup.Start(); anActionCompleted.WaitOne(); return(choiceIndex._index); }
public void DontDisposeCallerState() { SmartThreadPool smartThreadPool = new SmartThreadPool(); WIGStartInfo wigStartInfo = new WIGStartInfo(); wigStartInfo.DisposeOfStateObjects = false; 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(); bool success = (1 == nonDisposableCallerState.Value); wir2.GetResult(); success = success && (1 == disposableCallerState.Value); smartThreadPool.Shutdown(); Assert.IsTrue(success); }
/// <summary> /// Create a new work item /// </summary> /// <param name = "wigStartInfo">Work item group start information</param> /// <param name = "callback">A callback to execute</param> /// <param name = "state"> /// The context object of the work item. Used for passing arguments to the work item. /// </param> /// <param name = "postExecuteWorkItemCallback"> /// A delegate to call after the callback completion /// </param> /// <param name = "callToPostExecute">Indicates on which cases to call to the post execute callback</param> /// <param name = "workItemPriority">The work item priority</param> /// <returns>Returns a work item</returns> public static WorkItem CreateWorkItem( IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback, CallToPostExecute callToPostExecute, WorkItemPriority workItemPriority) { ValidateCallback(callback); ValidateCallback(postExecuteWorkItemCallback); WorkItemInfo workItemInfo = new WorkItemInfo { UseCallerCallContext = wigStartInfo.UseCallerCallContext, UseCallerHttpContext = wigStartInfo.UseCallerHttpContext, PostExecuteWorkItemCallback = postExecuteWorkItemCallback, CallToPostExecute = callToPostExecute, WorkItemPriority = workItemPriority, DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects }; WorkItem workItem = new WorkItem( workItemsGroup, workItemInfo, callback, state); return(workItem); }
/// <summary> /// Initialize the callback holding object. /// </summary> /// <param name="workItemsGroup">The workItemGroup of the workitem</param> /// <param name="workItemInfo">The WorkItemInfo of te workitem</param> /// <param name="callback">Action delegate for the callback.</param> /// <param name="state">Items with which to call the callback delegate.</param> /// /// We assume that the WorkItem object is created within the thread /// that meant to run the callback public WorkItem( IWorkItemsGroup workItemsGroup, WorkItemInfo workItemInfo, WorkItemCallback callback, object state) { if (null == workItemInfo) { throw new ArgumentNullException("workItemInfo"); } _workItemsGroup = workItemsGroup; _workItemInfo = workItemInfo; #if !(_WINDOWS_CE) && !(_SILVERLIGHT) if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext) { _callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext); } #endif _callback = callback; _state = state; _workItemResult = new WorkItemResult(this); Initialize(); }
/// <summary> /// Create a new work item /// </summary> /// <param name="workItemsGroup"></param> /// <param name="wigStartInfo">Work item group start information</param> /// <param name="callback">A callback to execute</param> /// <param name="state"> /// The context object of the work item. Used for passing arguments to the work item. /// </param> /// <param name="workItemPriority">The work item priority</param> /// <returns>Returns a work item</returns> public static WorkItem CreateWorkItem(IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemCallback callback, object state, WorkItemPriority workItemPriority) { ValidateCallback(callback); return(new WorkItem(workItemsGroup, new WorkItemInfo { UseCallerCallContext = wigStartInfo.UseCallerCallContext, UseCallerHttpContext = wigStartInfo.UseCallerHttpContext, PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback, CallToPostExecute = wigStartInfo.CallToPostExecute, DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects, WorkItemPriority = workItemPriority }, callback, state)); }
public void ExceptionThrowing() { STP smartThreadPool = new STP(); IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue); DivArgs divArgs = new DivArgs { x = 10, 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(); }
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback, WorkItemPriority workItemPriority); public static void TestQueueWorkItemCallStatPostPrio(IWorkItemsGroup wig) { bool postExecuteCalled = false; object state = new object(); PostExecuteWorkItemCallback postExecuteWorkItemCallback = delegate(IWorkItemResult w) { postExecuteCalled = true; }; WorkItemInfo wii = new WorkItemInfo(); wii.WorkItemPriority = WorkItemPriority.BelowNormal; wii.PostExecuteWorkItemCallback = postExecuteWorkItemCallback; WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii, state); IWorkItemResult wir = wig.QueueWorkItem( wiic.CompareWorkItemInfo, state, postExecuteWorkItemCallback, WorkItemPriority.BelowNormal); // We must wait for idle to let the post execute run wig.WaitForIdle(); bool success = (bool)wir.Result; Assert.IsTrue(success); Assert.IsTrue(postExecuteCalled); }
private void btnStart_Click(object sender, System.EventArgs e) { UpdateControls(true); workItemsCompleted = 0; workItemsGenerated = 0; STPStartInfo stpStartInfo = new STPStartInfo(); stpStartInfo.IdleTimeout = Convert.ToInt32(spinIdleTimeout.Value) * 1000; stpStartInfo.MaxWorkerThreads = Convert.ToInt32(spinMaxThreads.Value); stpStartInfo.MinWorkerThreads = Convert.ToInt32(spinMinThreads.Value); if (_useWindowsPerformanceCounters) { stpStartInfo.PerformanceCounterInstanceName = "Test SmartThreadPool"; } else { stpStartInfo.EnableLocalPerformanceCounters = true; } _smartThreadPool = new SmartThreadPool(stpStartInfo); //_workItemsGroup = _smartThreadPool.CreateWorkItemsGroup(1); _workItemsGroup = _smartThreadPool; workItemsProducerThread = new Thread(new ThreadStart(this.WorkItemsProducer)); workItemsProducerThread.IsBackground = true; workItemsProducerThread.Start(); }
public void ExceptionReturning() { bool success = true; STP smartThreadPool = new STP(); IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue); DivArgs divArgs = new DivArgs { x = 10, 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); }
private void spinCon_ValueChanged(object sender, EventArgs e) { NumericUpDown spin = sender as NumericUpDown; IWorkItemsGroup wig = spin.Tag as IWorkItemsGroup; wig.Concurrency = (int)spin.Value; }
private void Dispose(bool disposing) { if (this.disposed) { return; } if (disposing) { if (this.schedulerThread != null) { this.schedulerThread.Abort(); this.schedulerThread = (Thread)null; } if (this.processingGroup != null) { this.processingGroup.Cancel(false); this.processingGroup = (IWorkItemsGroup)null; } if (this.processingThreadPool != null) { this.processingThreadPool.Dispose(); this.processingThreadPool = (SmartThreadPool)null; } } this.disposed = true; }
/// <summary> /// Example of how to use the post execute callback /// </summary> private bool DoTestPostExecute(CallToPostExecute callToPostExecute, bool answer) { SmartThreadPool smartThreadPool = new SmartThreadPool(); IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue); bool success = false; PostExecuteResult postExecuteResult = new PostExecuteResult(); IWorkItemResult wir = workItemsGroup.QueueWorkItem( new WorkItemCallback(this.DoSomeWork), postExecuteResult, new PostExecuteWorkItemCallback(this.DoSomePostExecuteWork), callToPostExecute); if (!wir.IsCompleted) { int result = (int)wir.GetResult(); success = (1 == result); success = success && (postExecuteResult.wh.WaitOne(1000, true) == answer); } smartThreadPool.Shutdown(); return(success); }
private void WorkItemsProducer() { WorkItemCallback workItemCallback = DoWork; while (running) { IWorkItemsGroup workItemsGroup = _stp; if (null == workItemsGroup) { return; } try { workItemsGroup.QueueWorkItem(workItemCallback); } catch (ObjectDisposedException e) { e.GetHashCode(); break; } workItemsGenerated++; Thread.Sleep(_interval); } }
private void WorkItemsProducer() { WorkItemCallback workItemCallback = new WorkItemCallback(this.DoWork); while (running) { IWorkItemsGroup workItemsGroup = _workItemsGroup; if (null == workItemsGroup) { return; } try { workItemCallback = new WorkItemCallback(this.DoWork); workItemsGroup.QueueWorkItem(workItemCallback); } catch (ObjectDisposedException e) { e.GetHashCode(); break; } workItemsGenerated++; Thread.Sleep(Convert.ToInt32(spinInterval.Value)); } }
private void ValidateWorkItemsGroupWaitForIdleImpl(IWorkItemsGroup workItemsGroup, WorkItem workItem) { if (((workItemsGroup != null) && (workItem != null)) && workItem.WasQueuedBy(workItemsGroup)) { throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock"); } }
public Boolean reparse() { lock (_lock) { Boolean result = true; if (!Constant.RunStatus.STOP.Equals(this.RunStatus)) { result = false; } else { this.workItemsGroup = ThreadPoolEx.getWorkItemsGroup(); this.WaitQueue = new Hashtable(); this.StartQueue = new Hashtable(); this.successQueue = new Hashtable(); this.errorQueue = new Hashtable(); this.RunStatus = Constant.RunStatus.RUNING; } return(result); } }
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"); }
/// <summary> /// Create a new work item /// </summary> /// <param name="workItemsGroup">The WorkItemsGroup of this workitem</param> /// <param name="wigStartInfo">Work item group start information</param> /// <param name="callback">A callback to execute</param> /// <returns>Returns a work item</returns> public static WorkItem CreateWorkItem( IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemCallback callback) { return(CreateWorkItem(workItemsGroup, wigStartInfo, callback, null)); }
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); }
private void materialRaisedButton11_Click(object sender, EventArgs e) { startTime = System.DateTime.Now; running = true; UpdateControls(true); workItemsCompleted = 0; workItemsGenerated = 0; STPStartInfo stpStartInfo = new STPStartInfo(); stpStartInfo.IdleTimeout = Convert.ToInt32(materialSingleLineTextField4.Text) * 1000; stpStartInfo.MaxWorkerThreads = Convert.ToInt32(materialSingleLineTextField5.Text); stpStartInfo.MinWorkerThreads = 0; if (_useWindowsPerformanceCounters) { stpStartInfo.PerformanceCounterInstanceName = "测试线程池工具"; } else { stpStartInfo.EnableLocalPerformanceCounters = true; } _smartThreadPool = new SmartThreadPool(stpStartInfo); _workItemsGroup = _smartThreadPool; workItemsProducerThread = new Thread(new ThreadStart(this.WorkItemsProducer)); workItemsProducerThread.IsBackground = true; workItemsProducerThread.Start(); }
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)); }
/// <summary> /// 后台消息业务处理对象启动 /// </summary> /// <returns></returns> public bool InitServer() { try { //获取线程空闲超时时间(单位:秒)、最大线程数 _idleTimeout = 10; _maxWorkerThreads = 10; } catch (Exception ex) { //写日志(预留),不退出 } ////////////////////////////////////////////////////////////////////////////////////////////////// try { STPStartInfo stpStartInfo = new STPStartInfo(); stpStartInfo.IdleTimeout = _idleTimeout * 2000; stpStartInfo.MaxWorkerThreads = _maxWorkerThreads; stpStartInfo.MinWorkerThreads = _minWorkerThreads; stpStartInfo.PerformanceCounterInstanceName = "Pool"; _smartThreadPool = new SmartThreadPool(stpStartInfo); _workItemsGroup = _smartThreadPool; //线程池启动成功,写日志(预留) return(true); } catch (Exception ex) { //Helper.Log.SaveException("Exception", ex); //写日志(预留) return(false); } }
/// <summary> /// Create a new work item /// </summary> /// <param name="workItemsGroup">The WorkItemsGroup of this workitem</param> /// <param name="wigStartInfo">Work item group start information</param> /// <param name="callback">A callback to execute</param> /// <param name="state"> /// The context object of the work item. Used for passing arguments to the work item. /// </param> /// <returns>Returns a work item</returns> public static WorkItem CreateWorkItem( IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemCallback callback, object state) { ValidateCallback(callback); WorkItemInfo workItemInfo = new WorkItemInfo(); workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext; workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext; workItemInfo.PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback; workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute; workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects; workItemInfo.WorkItemPriority = wigStartInfo.WorkItemPriority; WorkItem workItem = new WorkItem( workItemsGroup, workItemInfo, callback, state); return(workItem); }
internal void UnregisterWorkItemsGroup(IWorkItemsGroup workItemsGroup) { if (_workItemsGroups.Contains(workItemsGroup)) { _workItemsGroups.Remove(workItemsGroup); } }
public void TestWIGConcurrencyChange() { STP smartThreadPool = new STP(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 StopMonitorFolder() { if (_fSWatcher != null) { _fSWatcher.EnableRaisingEvents = false; _fSWatcher.Created -= new FileSystemEventHandler(FSWatcher_Created); _fSWatcher = null; this.FMSObjStatus = "Stop"; } if ((_processFileWIG != null)) { _processFileWIG.Cancel(true); _processFileWIG = null; } if (_sMTPool != null) { _sMTPool.Shutdown(); _sMTPool = null; } if ((_processingFileList != null)) { _processingFileList = null; } }
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 object DoWaitForIdle(object state) { IWorkItemsGroup workItemsGroup = state as IWorkItemsGroup; workItemsGroup.WaitForIdle(); return(null); }
public void Init() { _stp = new SmartThreadPool(); WIGStartInfo wigStartInfo = new WIGStartInfo(); wigStartInfo.FillStateWithArgs = true; _wig = _stp.CreateWorkItemsGroup(10, wigStartInfo); }
/// <summary> /// HttpServiceCaller初始化 /// </summary> /// <param name="group"></param> /// <param name="config"></param> /// <param name="container"></param> public HttpServiceCaller(IWorkItemsGroup group, CastleServiceConfiguration config, IServiceContainer container) { this.config = config; this.container = container; this.smart = group; this.callers = new HttpCallerInfoCollection(); this.callTimeouts = new Dictionary<string, int>(); }
/// <summary> /// QuickSort array using wig to parallel the sort /// </summary> /// <param name="wig">A IWorkItemsGroup to use to parallel the sort</param> /// <param name="array">The array of items to sort</param> public static void QuickSort(IWorkItemsGroup wig, int[] array) { // Initiate the QuickSort wig.QueueWorkItem(QuickSort, wig, array, 0, array.Length - 1); // Wait for the sort to complete. wig.WaitForIdle(); }
public WigEntry( IWorkItemsGroup wig, QueueUsageControl queueUsageControl, Label isIdle) { _wig = wig; _queueUsageControl = queueUsageControl; _isIdle = isIdle; }
public HashCalculator(IHashAlgorithm method, SmartThreadPool pool) { _method = method; _pool = pool; if(_hashGroup == null) { _hashGroup = _pool.CreateWorkItemsGroup(1); } }
/// <summary> /// Initializes a new instance of the <see cref="WorkGroupWithItem"/> class. /// </summary> /// <param name="sourceGroup">The source group.</param> /// <param name="threadGroup">The thread group.</param> /// <param name="metricCounter">A counter for tracking how many items are being processed</param> public WorkGroupWithItem(IWorkGroup sourceGroup, IWorkItemsGroup threadGroup, ICounter metricCounter) { Guard.NotNull(() => sourceGroup, sourceGroup); Guard.NotNull(() => threadGroup, threadGroup); Guard.NotNull(() => metricCounter, metricCounter); GroupInfo = sourceGroup; Group = threadGroup; MaxWorkItems = GroupInfo.ConcurrencyLevel + GroupInfo.MaxQueueSize; MetricCounter = metricCounter; }
/// <summary> /// Sort a subarray in array, starting with the left item and ending in the right item. /// The method uses the IWorkItemsGroup wig to parallel the sort. /// </summary> /// <param name="wig">A IWorkItemsGroup to use to parallel the sort</param> /// <param name="array">The array of items to sort</param> /// <param name="left">The left index in the subarray</param> /// <param name="right">The right index in the subarray</param> private static void QuickSort(IWorkItemsGroup wig, int[] array, int left, int right) { if (right > left) { int pivotIndex = left; int pivotNewIndex = Partition(array, left, right, pivotIndex); wig.QueueWorkItem(QuickSort, wig, array, left, pivotNewIndex - 1); wig.QueueWorkItem(QuickSort, wig, array, pivotNewIndex + 1, right); } }
//IWorkItemResult QueueWorkItem(WorkItemCallback callback); public static void TestQueueWorkItemCall(IWorkItemsGroup wig) { WorkItemInfo wii = new WorkItemInfo(); WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii); IWorkItemResult wir = wig.QueueWorkItem(wiic.CompareWorkItemInfo); bool success = (bool)wir.Result; Assert.IsTrue(success); }
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state); public static void TestQueueWorkItemCallStat(IWorkItemsGroup wig) { object state = new object(); WorkItemInfo wii = new WorkItemInfo(); WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii, state); IWorkItemResult wir = wig.QueueWorkItem((WorkItemCallback) wiic.CompareWorkItemInfo, state); bool success = (bool)wir.Result; Assert.IsTrue(success); }
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, WorkItemPriority workItemPriority); public static void TestQueueWorkItemCallPrio(IWorkItemsGroup wig) { WorkItemInfo wii = new WorkItemInfo(); wii.WorkItemPriority = WorkItemPriority.AboveNormal; WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii); IWorkItemResult wir = wig.QueueWorkItem((WorkItemCallback)wiic.CompareWorkItemInfo, WorkItemPriority.AboveNormal); bool success = (bool)wir.Result; Assert.IsTrue(success); }
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, WorkItemPriority workItemPriority); public static void TestQueueWorkItemCallStatPrio(IWorkItemsGroup wig) { object state = new object(); WorkItemInfo wii = new WorkItemInfo(); wii.WorkItemPriority = WorkItemPriority.AboveNormal; WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii, state); IWorkItemResult wir = wig.QueueWorkItem(wiic.CompareWorkItemInfo, state, WorkItemPriority.AboveNormal); bool success = (bool)wir.Result; Assert.IsTrue(success); }
// Token: 0x0600185F RID: 6239 // RVA: 0x00075274 File Offset: 0x00073474 public static WorkItem CreateWorkItem(IWorkItemsGroup iworkItemsGroup_0, WIGStartInfo wigstartInfo_0, WorkItemCallback workItemCallback_0, object object_0, WorkItemPriority workItemPriority_0) { WorkItemFactory.ValidateCallback(workItemCallback_0); return new WorkItem(iworkItemsGroup_0, new WorkItemInfo { UseCallerCallContext = wigstartInfo_0.UseCallerCallContext, UseCallerHttpContext = wigstartInfo_0.UseCallerHttpContext, PostExecuteWorkItemCallback = wigstartInfo_0.PostExecuteWorkItemCallback, CallToPostExecute = wigstartInfo_0.CallToPostExecute, DisposeOfStateObjects = wigstartInfo_0.DisposeOfStateObjects, WorkItemPriority = workItemPriority_0 }, workItemCallback_0, object_0); }
/// <summary> /// 初始化ServiceCaller /// </summary> /// <param name="group"></param> /// <param name="status"></param> public ServiceCaller(IWorkItemsGroup group, ServerStatusService status) { this.status = status; this.smart = group; this.callbackTypes = new Dictionary<string, Type>(); this.callTimeouts = new Dictionary<string, int>(); //初始化服务 InitServiceCaller(status.Container); //注册状态服务 var hashtable = new Dictionary<Type, object>(); hashtable[typeof(IStatusService)] = status; //注册组件 status.Container.RegisterComponents(hashtable); }
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(); }
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback); public static void TestQueueWorkItemCallStatPost(IWorkItemsGroup wig) { bool postExecuteCalled = false; object state = new object(); PostExecuteWorkItemCallback postExecuteWorkItemCallback = delegate(IWorkItemResult w) { postExecuteCalled = true; }; WorkItemInfo wii = new WorkItemInfo(); wii.PostExecuteWorkItemCallback = postExecuteWorkItemCallback; WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii, state); IWorkItemResult wir = wig.QueueWorkItem( wiic.CompareWorkItemInfo, state, postExecuteWorkItemCallback); // We must wait for idle to let the post execute run wig.WaitForIdle(); bool success = (bool)wir.Result; Assert.IsTrue(success); Assert.IsTrue(postExecuteCalled); }
/// <summary> /// Create a new work item /// </summary> /// <param name="workItemsGroup"></param> /// <param name="wigStartInfo">Work item group start information</param> /// <param name="callback">A callback to execute</param> /// <param name="state"> /// The context object of the work item. Used for passing arguments to the work item. /// </param> /// <returns>Returns a work item</returns> public static WorkItem CreateWorkItem( IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemCallback callback, object state) { ValidateCallback(callback); WorkItemInfo workItemInfo = new WorkItemInfo(); workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext; workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext; workItemInfo.PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback; workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute; workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects; WorkItem workItem = new WorkItem( workItemsGroup, workItemInfo, callback, state); return workItem; }
/// <summary> /// Initialize the callback holding object. /// </summary> /// <param name="workItemsGroup"></param> /// <param name="workItemInfo"></param> /// <param name="callback">Callback delegate for the callback.</param> /// <param name="state">State with which to call the callback delegate.</param> /// /// We assume that the WorkItem object is created within the thread /// that meant to run the callback public WorkItem( IWorkItemsGroup workItemsGroup, WorkItemInfo workItemInfo, WorkItemCallback callback, object state) { _workItemsGroup = workItemsGroup; _workItemInfo = workItemInfo; if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext) { _callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext); } _callback = callback; _state = state; _workItemResult = new WorkItemResult(this); Initialize(); }
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; } }
/// <summary> /// Initialize the callback holding object. /// </summary> /// <param name="workItemsGroup">The workItemGroup of the workitem</param> /// <param name="workItemInfo">The WorkItemInfo of te workitem</param> /// <param name="callback">Callback delegate for the callback.</param> /// <param name="state">State with which to call the callback delegate.</param> /// /// We assume that the WorkItem object is created within the thread /// that meant to run the callback public WorkItem( IWorkItemsGroup workItemsGroup, WorkItemInfo workItemInfo, WorkItemCallback callback, object state) { _workItemsGroup = workItemsGroup; _workItemInfo = workItemInfo; #if !(_WINDOWS_CE) && !(_SILVERLIGHT) && !(WINDOWS_PHONE) if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext) { _callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext); } #endif _callback = callback; _state = state; _workItemResult = new WorkItemResult(this); Initialize(); }
private void ValidateWorkItemsGroupWaitForIdleImpl(IWorkItemsGroup workItemsGroup, WorkItem workItem) { if ((null != workItemsGroup) && (null != workItem) && workItem.WasQueuedBy(workItemsGroup)) { throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock"); } }
// Token: 0x060017EE RID: 6126 // RVA: 0x00014AD5 File Offset: 0x00012CD5 internal void RegisterWorkItemsGroup(IWorkItemsGroup iworkItemsGroup_0) { this._workItemsGroups[iworkItemsGroup_0] = iworkItemsGroup_0; }
// Token: 0x060017EF RID: 6127 // RVA: 0x00014AE4 File Offset: 0x00012CE4 internal void UnregisterWorkItemsGroup(IWorkItemsGroup iworkItemsGroup_0) { if (this._workItemsGroups.Contains(iworkItemsGroup_0)) { this._workItemsGroups.Remove(iworkItemsGroup_0); } }
/// <summary> /// Create a new work item /// </summary> /// <param name = "wigStartInfo">Work item group start information</param> /// <param name = "workItemInfo">Work item information</param> /// <param name = "callback">A callback to execute</param> /// <param name = "state"> /// The context object of the work item. Used for passing arguments to the work item. /// </param> /// <returns>Returns a work item</returns> public static WorkItem CreateWorkItem( IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemInfo workItemInfo, WorkItemCallback callback, object state) { ValidateCallback(callback); ValidateCallback(workItemInfo.PostExecuteWorkItemCallback); WorkItem workItem = new WorkItem( workItemsGroup, new WorkItemInfo(workItemInfo), callback, state); return workItem; }
internal bool WasQueuedBy(IWorkItemsGroup workItemsGroup) { return (workItemsGroup == _workItemsGroup); }
/// <summary> /// Create a new work item /// </summary> /// <param name = "wigStartInfo">Work item group start information</param> /// <param name = "callback">A callback to execute</param> /// <param name = "state"> /// The context object of the work item. Used for passing arguments to the work item. /// </param> /// <param name = "postExecuteWorkItemCallback"> /// A delegate to call after the callback completion /// </param> /// <param name = "callToPostExecute">Indicates on which cases to call to the post execute callback</param> /// <param name = "workItemPriority">The work item priority</param> /// <returns>Returns a work item</returns> public static WorkItem CreateWorkItem( IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback, CallToPostExecute callToPostExecute, WorkItemPriority workItemPriority) { ValidateCallback(callback); ValidateCallback(postExecuteWorkItemCallback); WorkItemInfo workItemInfo = new WorkItemInfo { UseCallerCallContext = wigStartInfo.UseCallerCallContext, UseCallerHttpContext = wigStartInfo.UseCallerHttpContext, PostExecuteWorkItemCallback = postExecuteWorkItemCallback, CallToPostExecute = callToPostExecute, WorkItemPriority = workItemPriority, DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects }; WorkItem workItem = new WorkItem( workItemsGroup, workItemInfo, callback, state); return workItem; }
private void EnqueueWorkItems(ref int startIndex, int count, string text, Color color, WorkItemPriority priority, IWorkItemsGroup wig, int sleepDuration) { for (int i = 0; i < count; ++i, ++startIndex) { wig.QueueWorkItem( DoNothing, new WorkItemState(new QueueUsageControl.QueueUsageEntry(string.Format("{0}{1} ({2})", text, startIndex, priority.ToString().Substring(0,2 )), color), sleepDuration), priority); } _workItemsGenerated += count; }
private void wig_OnIdle(IWorkItemsGroup workItemsGroup) { Debug.WriteLine("WIG is idle"); }
private void UpdateQueueUsageControl( IWorkItemsGroup wig, QueueUsageControl queueUsageControl, Label label) { label.Text = wig.IsIdle ? "Idle" : "Working"; object[] states = wig.GetStates(); List<QueueUsageControl.QueueUsageEntry> list = new List<QueueUsageControl.QueueUsageEntry>(); foreach (WorkItemState state in states) { if (null != state) { list.Add(state.QueueUsageEntry); } } queueUsageControl.SetQueue(list); }