From 206fb306a7820cf593570e35ddfa8e7c5a10e449 Mon Sep 17 00:00:00 2001
From: Justin Clark-Casey (justincc)
Date: Wed, 1 May 2013 19:01:43 +0100
Subject: Update SmartThreadPool to latest version 2.2.3 with a major and minor
change.
SmartThreadPool code comes from http://www.codeproject.com/Articles/7933/Smart-Thread-Pool
This version implements thread abort (via WorkItem.Cancel(true)), threadpool naming, max thread stack, etc. so we no longer need to manually patch those.
However, two changes have been made to stock 2.2.3.
Major change: WorkItem.Cancel(bool abortExecution) in our version does not succeed if the work item was in progress and thread abort was not specified.
This is to match previous behaviour where we handle co-operative termination via another mechanism rather than checking WorkItem.IsCanceled.
Minor change: Did not add STP's StopWatch implementation as this is only used WinCE and Silverlight and causes a build clash with System.Diagnostics.StopWatch
The reason for updating is to see if this improves http://opensimulator.org/mantis/view.php?id=6557 and http://opensimulator.org/mantis/view.php?id=6586
---
ThirdParty/SmartThreadPool/WorkItemsGroup.cs | 873 +++++++++++----------------
1 file changed, 361 insertions(+), 512 deletions(-)
(limited to 'ThirdParty/SmartThreadPool/WorkItemsGroup.cs')
diff --git a/ThirdParty/SmartThreadPool/WorkItemsGroup.cs b/ThirdParty/SmartThreadPool/WorkItemsGroup.cs
index 01ac8dd..67dcbdd 100644
--- a/ThirdParty/SmartThreadPool/WorkItemsGroup.cs
+++ b/ThirdParty/SmartThreadPool/WorkItemsGroup.cs
@@ -1,512 +1,361 @@
-// Ami Bar
-// amibar@gmail.com
-
-using System;
-using System.Threading;
-using System.Runtime.CompilerServices;
-using System.Diagnostics;
-
-namespace Amib.Threading.Internal
-{
- #region WorkItemsGroup class
-
- ///
- /// Summary description for WorkItemsGroup.
- ///
- public class WorkItemsGroup : IWorkItemsGroup
- {
- #region Private members
-
- private object _lock = new object();
- ///
- /// Contains the name of this instance of SmartThreadPool.
- /// Can be changed by the user.
- ///
- private string _name = "WorkItemsGroup";
-
- ///
- /// A reference to the SmartThreadPool instance that created this
- /// WorkItemsGroup.
- ///
- private SmartThreadPool _stp;
-
- ///
- /// The OnIdle event
- ///
- private event WorkItemsGroupIdleHandler _onIdle;
-
- ///
- /// Defines how many work items of this WorkItemsGroup can run at once.
- ///
- private int _concurrency;
-
- ///
- /// Priority queue to hold work items before they are passed
- /// to the SmartThreadPool.
- ///
- private PriorityQueue _workItemsQueue;
-
- ///
- /// Indicate how many work items are waiting in the SmartThreadPool
- /// queue.
- /// This value is used to apply the concurrency.
- ///
- private int _workItemsInStpQueue;
-
- ///
- /// Indicate how many work items are currently running in the SmartThreadPool.
- /// This value is used with the Cancel, to calculate if we can send new
- /// work items to the STP.
- ///
- private int _workItemsExecutingInStp = 0;
-
- ///
- /// WorkItemsGroup start information
- ///
- private WIGStartInfo _workItemsGroupStartInfo;
-
- ///
- /// Signaled when all of the WorkItemsGroup's work item completed.
- ///
- private ManualResetEvent _isIdleWaitHandle = new ManualResetEvent(true);
-
- ///
- /// A common object for all the work items that this work items group
- /// generate so we can mark them to cancel in O(1)
- ///
- private CanceledWorkItemsGroup _canceledWorkItemsGroup = new CanceledWorkItemsGroup();
-
- #endregion
-
- #region Construction
-
- public WorkItemsGroup(
- SmartThreadPool stp,
- int concurrency,
- WIGStartInfo wigStartInfo)
- {
- if (concurrency <= 0)
- {
- throw new ArgumentOutOfRangeException("concurrency", concurrency, "concurrency must be greater than zero");
- }
- _stp = stp;
- _concurrency = concurrency;
- _workItemsGroupStartInfo = new WIGStartInfo(wigStartInfo);
- _workItemsQueue = new PriorityQueue();
-
- // The _workItemsInStpQueue gets the number of currently executing work items,
- // because once a work item is executing, it cannot be cancelled.
- _workItemsInStpQueue = _workItemsExecutingInStp;
- }
-
- #endregion
-
- #region IWorkItemsGroup implementation
-
- ///
- /// Get/Set the name of the SmartThreadPool instance
- ///
- public string Name
- {
- get
- {
- return _name;
- }
-
- set
- {
- _name = value;
- }
- }
-
- ///
- /// Queue a work item
- ///
- /// A callback to execute
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(WorkItemCallback callback)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// A callback to execute
- /// The priority of the work item
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(WorkItemCallback callback, WorkItemPriority workItemPriority)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, workItemPriority);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// Work item info
- /// A callback to execute
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(WorkItemInfo workItemInfo, WorkItemCallback callback)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, workItemInfo, callback);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// A callback to execute
- ///
- /// The context object of the work item. Used for passing arguments to the work item.
- ///
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// A callback to execute
- ///
- /// The context object of the work item. Used for passing arguments to the work item.
- ///
- /// The work item priority
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, WorkItemPriority workItemPriority)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, workItemPriority);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// Work item information
- /// A callback to execute
- ///
- /// The context object of the work item. Used for passing arguments to the work item.
- ///
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(WorkItemInfo workItemInfo, WorkItemCallback callback, object state)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, workItemInfo, callback, state);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// A callback to execute
- ///
- /// The context object of the work item. Used for passing arguments to the work item.
- ///
- ///
- /// A delegate to call after the callback completion
- ///
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(
- WorkItemCallback callback,
- object state,
- PostExecuteWorkItemCallback postExecuteWorkItemCallback)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, postExecuteWorkItemCallback);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// A callback to execute
- ///
- /// The context object of the work item. Used for passing arguments to the work item.
- ///
- ///
- /// A delegate to call after the callback completion
- ///
- /// The work item priority
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(
- WorkItemCallback callback,
- object state,
- PostExecuteWorkItemCallback postExecuteWorkItemCallback,
- WorkItemPriority workItemPriority)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, postExecuteWorkItemCallback, workItemPriority);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// A callback to execute
- ///
- /// The context object of the work item. Used for passing arguments to the work item.
- ///
- ///
- /// A delegate to call after the callback completion
- ///
- /// Indicates on which cases to call to the post execute callback
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(
- WorkItemCallback callback,
- object state,
- PostExecuteWorkItemCallback postExecuteWorkItemCallback,
- CallToPostExecute callToPostExecute)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Queue a work item
- ///
- /// A callback to execute
- ///
- /// The context object of the work item. Used for passing arguments to the work item.
- ///
- ///
- /// A delegate to call after the callback completion
- ///
- /// Indicates on which cases to call to the post execute callback
- /// The work item priority
- /// Returns a work item result
- public IWorkItemResult QueueWorkItem(
- WorkItemCallback callback,
- object state,
- PostExecuteWorkItemCallback postExecuteWorkItemCallback,
- CallToPostExecute callToPostExecute,
- WorkItemPriority workItemPriority)
- {
- WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute, workItemPriority);
- EnqueueToSTPNextWorkItem(workItem);
- return workItem.GetWorkItemResult();
- }
-
- ///
- /// Wait for the thread pool to be idle
- ///
- public void WaitForIdle()
- {
- WaitForIdle(Timeout.Infinite);
- }
-
- ///
- /// Wait for the thread pool to be idle
- ///
- public bool WaitForIdle(TimeSpan timeout)
- {
- return WaitForIdle((int)timeout.TotalMilliseconds);
- }
-
- ///
- /// Wait for the thread pool to be idle
- ///
- public bool WaitForIdle(int millisecondsTimeout)
- {
- _stp.ValidateWorkItemsGroupWaitForIdle(this);
- return _isIdleWaitHandle.WaitOne(millisecondsTimeout, false);
- }
-
- public int WaitingCallbacks
- {
- get
- {
- return _workItemsQueue.Count;
- }
- }
-
- public event WorkItemsGroupIdleHandler OnIdle
- {
- add
- {
- _onIdle += value;
- }
- remove
- {
- _onIdle -= value;
- }
- }
-
- public void Cancel()
- {
- lock(_lock)
- {
- _canceledWorkItemsGroup.IsCanceled = true;
- _workItemsQueue.Clear();
- _workItemsInStpQueue = 0;
- _canceledWorkItemsGroup = new CanceledWorkItemsGroup();
- }
- }
-
- public void Start()
- {
- lock (this)
- {
- if (!_workItemsGroupStartInfo.StartSuspended)
- {
- return;
- }
- _workItemsGroupStartInfo.StartSuspended = false;
- }
-
- for(int i = 0; i < _concurrency; ++i)
- {
- EnqueueToSTPNextWorkItem(null, false);
- }
- }
-
- #endregion
-
- #region Private methods
-
- private void RegisterToWorkItemCompletion(IWorkItemResult wir)
- {
- IInternalWorkItemResult iwir = wir as IInternalWorkItemResult;
- iwir.OnWorkItemStarted += new WorkItemStateCallback(OnWorkItemStartedCallback);
- iwir.OnWorkItemCompleted += new WorkItemStateCallback(OnWorkItemCompletedCallback);
- }
-
- public void OnSTPIsStarting()
- {
- lock (this)
- {
- if (_workItemsGroupStartInfo.StartSuspended)
- {
- return;
- }
- }
-
- for(int i = 0; i < _concurrency; ++i)
- {
- EnqueueToSTPNextWorkItem(null, false);
- }
- }
-
- private object FireOnIdle(object state)
- {
- FireOnIdleImpl(_onIdle);
- return null;
- }
-
- [MethodImpl(MethodImplOptions.NoInlining)]
- private void FireOnIdleImpl(WorkItemsGroupIdleHandler onIdle)
- {
- if(null == onIdle)
- {
- return;
- }
-
- Delegate[] delegates = onIdle.GetInvocationList();
- foreach(WorkItemsGroupIdleHandler eh in delegates)
- {
- try
- {
- eh(this);
- }
- // Ignore exceptions
- catch{}
- }
- }
-
- private void OnWorkItemStartedCallback(WorkItem workItem)
- {
- lock(_lock)
- {
- ++_workItemsExecutingInStp;
- }
- }
-
- private void OnWorkItemCompletedCallback(WorkItem workItem)
- {
- EnqueueToSTPNextWorkItem(null, true);
- }
-
- private void EnqueueToSTPNextWorkItem(WorkItem workItem)
- {
- EnqueueToSTPNextWorkItem(workItem, false);
- }
-
- private void EnqueueToSTPNextWorkItem(WorkItem workItem, bool decrementWorkItemsInStpQueue)
- {
- lock(_lock)
- {
- // Got here from OnWorkItemCompletedCallback()
- if (decrementWorkItemsInStpQueue)
- {
- --_workItemsInStpQueue;
-
- if(_workItemsInStpQueue < 0)
- {
- _workItemsInStpQueue = 0;
- }
-
- --_workItemsExecutingInStp;
-
- if(_workItemsExecutingInStp < 0)
- {
- _workItemsExecutingInStp = 0;
- }
- }
-
- // If the work item is not null then enqueue it
- if (null != workItem)
- {
- workItem.CanceledWorkItemsGroup = _canceledWorkItemsGroup;
-
- RegisterToWorkItemCompletion(workItem.GetWorkItemResult());
- _workItemsQueue.Enqueue(workItem);
- //_stp.IncrementWorkItemsCount();
-
- if ((1 == _workItemsQueue.Count) &&
- (0 == _workItemsInStpQueue))
- {
- _stp.RegisterWorkItemsGroup(this);
- Trace.WriteLine("WorkItemsGroup " + Name + " is NOT idle");
- _isIdleWaitHandle.Reset();
- }
- }
-
- // If the work items queue of the group is empty than quit
- if (0 == _workItemsQueue.Count)
- {
- if (0 == _workItemsInStpQueue)
- {
- _stp.UnregisterWorkItemsGroup(this);
- Trace.WriteLine("WorkItemsGroup " + Name + " is idle");
- _isIdleWaitHandle.Set();
- _stp.QueueWorkItem(new WorkItemCallback(this.FireOnIdle));
- }
- return;
- }
-
- if (!_workItemsGroupStartInfo.StartSuspended)
- {
- if (_workItemsInStpQueue < _concurrency)
- {
- WorkItem nextWorkItem = _workItemsQueue.Dequeue() as WorkItem;
- _stp.Enqueue(nextWorkItem, true);
- ++_workItemsInStpQueue;
- }
- }
- }
- }
-
- #endregion
- }
-
- #endregion
-}
+using System;
+using System.Threading;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
+
+namespace Amib.Threading.Internal
+{
+
+ #region WorkItemsGroup class
+
+ ///
+ /// Summary description for WorkItemsGroup.
+ ///
+ public class WorkItemsGroup : WorkItemsGroupBase
+ {
+ #region Private members
+
+ private readonly object _lock = new object();
+
+ ///
+ /// A reference to the SmartThreadPool instance that created this
+ /// WorkItemsGroup.
+ ///
+ private readonly SmartThreadPool _stp;
+
+ ///
+ /// The OnIdle event
+ ///
+ private event WorkItemsGroupIdleHandler _onIdle;
+
+ ///
+ /// A flag to indicate if the Work Items Group is now suspended.
+ ///
+ private bool _isSuspended;
+
+ ///
+ /// Defines how many work items of this WorkItemsGroup can run at once.
+ ///
+ private int _concurrency;
+
+ ///
+ /// Priority queue to hold work items before they are passed
+ /// to the SmartThreadPool.
+ ///
+ private readonly PriorityQueue _workItemsQueue;
+
+ ///
+ /// Indicate how many work items are waiting in the SmartThreadPool
+ /// queue.
+ /// This value is used to apply the concurrency.
+ ///
+ private int _workItemsInStpQueue;
+
+ ///
+ /// Indicate how many work items are currently running in the SmartThreadPool.
+ /// This value is used with the Cancel, to calculate if we can send new
+ /// work items to the STP.
+ ///
+ private int _workItemsExecutingInStp = 0;
+
+ ///
+ /// WorkItemsGroup start information
+ ///
+ private readonly WIGStartInfo _workItemsGroupStartInfo;
+
+ ///
+ /// Signaled when all of the WorkItemsGroup's work item completed.
+ ///
+ //private readonly ManualResetEvent _isIdleWaitHandle = new ManualResetEvent(true);
+ private readonly ManualResetEvent _isIdleWaitHandle = EventWaitHandleFactory.CreateManualResetEvent(true);
+
+ ///
+ /// A common object for all the work items that this work items group
+ /// generate so we can mark them to cancel in O(1)
+ ///
+ private CanceledWorkItemsGroup _canceledWorkItemsGroup = new CanceledWorkItemsGroup();
+
+ #endregion
+
+ #region Construction
+
+ public WorkItemsGroup(
+ SmartThreadPool stp,
+ int concurrency,
+ WIGStartInfo wigStartInfo)
+ {
+ if (concurrency <= 0)
+ {
+ throw new ArgumentOutOfRangeException(
+ "concurrency",
+#if !(_WINDOWS_CE) && !(_SILVERLIGHT) && !(WINDOWS_PHONE)
+ concurrency,
+#endif
+ "concurrency must be greater than zero");
+ }
+ _stp = stp;
+ _concurrency = concurrency;
+ _workItemsGroupStartInfo = new WIGStartInfo(wigStartInfo).AsReadOnly();
+ _workItemsQueue = new PriorityQueue();
+ Name = "WorkItemsGroup";
+
+ // The _workItemsInStpQueue gets the number of currently executing work items,
+ // because once a work item is executing, it cannot be cancelled.
+ _workItemsInStpQueue = _workItemsExecutingInStp;
+
+ _isSuspended = _workItemsGroupStartInfo.StartSuspended;
+ }
+
+ #endregion
+
+ #region WorkItemsGroupBase Overrides
+
+ public override int Concurrency
+ {
+ get { return _concurrency; }
+ set
+ {
+ Debug.Assert(value > 0);
+
+ int diff = value - _concurrency;
+ _concurrency = value;
+ if (diff > 0)
+ {
+ EnqueueToSTPNextNWorkItem(diff);
+ }
+ }
+ }
+
+ public override int WaitingCallbacks
+ {
+ get { return _workItemsQueue.Count; }
+ }
+
+ public override object[] GetStates()
+ {
+ lock (_lock)
+ {
+ object[] states = new object[_workItemsQueue.Count];
+ int i = 0;
+ foreach (WorkItem workItem in _workItemsQueue)
+ {
+ states[i] = workItem.GetWorkItemResult().State;
+ ++i;
+ }
+ return states;
+ }
+ }
+
+ ///
+ /// WorkItemsGroup start information
+ ///
+ public override WIGStartInfo WIGStartInfo
+ {
+ get { return _workItemsGroupStartInfo; }
+ }
+
+ ///
+ /// Start the Work Items Group if it was started suspended
+ ///
+ public override void Start()
+ {
+ // If the Work Items Group already started then quit
+ if (!_isSuspended)
+ {
+ return;
+ }
+ _isSuspended = false;
+
+ EnqueueToSTPNextNWorkItem(Math.Min(_workItemsQueue.Count, _concurrency));
+ }
+
+ public override void Cancel(bool abortExecution)
+ {
+ lock (_lock)
+ {
+ _canceledWorkItemsGroup.IsCanceled = true;
+ _workItemsQueue.Clear();
+ _workItemsInStpQueue = 0;
+ _canceledWorkItemsGroup = new CanceledWorkItemsGroup();
+ }
+
+ if (abortExecution)
+ {
+ _stp.CancelAbortWorkItemsGroup(this);
+ }
+ }
+
+ ///
+ /// Wait for the thread pool to be idle
+ ///
+ public override bool WaitForIdle(int millisecondsTimeout)
+ {
+ SmartThreadPool.ValidateWorkItemsGroupWaitForIdle(this);
+ return STPEventWaitHandle.WaitOne(_isIdleWaitHandle, millisecondsTimeout, false);
+ }
+
+ public override event WorkItemsGroupIdleHandler OnIdle
+ {
+ add { _onIdle += value; }
+ remove { _onIdle -= value; }
+ }
+
+ #endregion
+
+ #region Private methods
+
+ private void RegisterToWorkItemCompletion(IWorkItemResult wir)
+ {
+ IInternalWorkItemResult iwir = (IInternalWorkItemResult)wir;
+ iwir.OnWorkItemStarted += OnWorkItemStartedCallback;
+ iwir.OnWorkItemCompleted += OnWorkItemCompletedCallback;
+ }
+
+ public void OnSTPIsStarting()
+ {
+ if (_isSuspended)
+ {
+ return;
+ }
+
+ EnqueueToSTPNextNWorkItem(_concurrency);
+ }
+
+ public void EnqueueToSTPNextNWorkItem(int count)
+ {
+ for (int i = 0; i < count; ++i)
+ {
+ EnqueueToSTPNextWorkItem(null, false);
+ }
+ }
+
+ private object FireOnIdle(object state)
+ {
+ FireOnIdleImpl(_onIdle);
+ return null;
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private void FireOnIdleImpl(WorkItemsGroupIdleHandler onIdle)
+ {
+ if(null == onIdle)
+ {
+ return;
+ }
+
+ Delegate[] delegates = onIdle.GetInvocationList();
+ foreach(WorkItemsGroupIdleHandler eh in delegates)
+ {
+ try
+ {
+ eh(this);
+ }
+ catch { } // Suppress exceptions
+ }
+ }
+
+ private void OnWorkItemStartedCallback(WorkItem workItem)
+ {
+ lock(_lock)
+ {
+ ++_workItemsExecutingInStp;
+ }
+ }
+
+ private void OnWorkItemCompletedCallback(WorkItem workItem)
+ {
+ EnqueueToSTPNextWorkItem(null, true);
+ }
+
+ internal override void Enqueue(WorkItem workItem)
+ {
+ EnqueueToSTPNextWorkItem(workItem);
+ }
+
+ private void EnqueueToSTPNextWorkItem(WorkItem workItem)
+ {
+ EnqueueToSTPNextWorkItem(workItem, false);
+ }
+
+ private void EnqueueToSTPNextWorkItem(WorkItem workItem, bool decrementWorkItemsInStpQueue)
+ {
+ lock(_lock)
+ {
+ // Got here from OnWorkItemCompletedCallback()
+ if (decrementWorkItemsInStpQueue)
+ {
+ --_workItemsInStpQueue;
+
+ if(_workItemsInStpQueue < 0)
+ {
+ _workItemsInStpQueue = 0;
+ }
+
+ --_workItemsExecutingInStp;
+
+ if(_workItemsExecutingInStp < 0)
+ {
+ _workItemsExecutingInStp = 0;
+ }
+ }
+
+ // If the work item is not null then enqueue it
+ if (null != workItem)
+ {
+ workItem.CanceledWorkItemsGroup = _canceledWorkItemsGroup;
+
+ RegisterToWorkItemCompletion(workItem.GetWorkItemResult());
+ _workItemsQueue.Enqueue(workItem);
+ //_stp.IncrementWorkItemsCount();
+
+ if ((1 == _workItemsQueue.Count) &&
+ (0 == _workItemsInStpQueue))
+ {
+ _stp.RegisterWorkItemsGroup(this);
+ IsIdle = false;
+ _isIdleWaitHandle.Reset();
+ }
+ }
+
+ // If the work items queue of the group is empty than quit
+ if (0 == _workItemsQueue.Count)
+ {
+ if (0 == _workItemsInStpQueue)
+ {
+ _stp.UnregisterWorkItemsGroup(this);
+ IsIdle = true;
+ _isIdleWaitHandle.Set();
+ if (decrementWorkItemsInStpQueue && _onIdle != null && _onIdle.GetInvocationList().Length > 0)
+ {
+ _stp.QueueWorkItem(new WorkItemCallback(FireOnIdle));
+ }
+ }
+ return;
+ }
+
+ if (!_isSuspended)
+ {
+ if (_workItemsInStpQueue < _concurrency)
+ {
+ WorkItem nextWorkItem = _workItemsQueue.Dequeue() as WorkItem;
+ try
+ {
+ _stp.Enqueue(nextWorkItem);
+ }
+ catch (ObjectDisposedException e)
+ {
+ e.GetHashCode();
+ // The STP has been shutdown
+ }
+
+ ++_workItemsInStpQueue;
+ }
+ }
+ }
+ }
+
+ #endregion
+ }
+
+ #endregion
+}
--
cgit v1.1