Dump OpenSim 0.9.0.1 into it's own branch.

1 files changed, 226 insertions, 226 deletions

diff --git a/ThirdParty/SmartThreadPool/WorkItemsGroup.cs b/ThirdParty/SmartThreadPool/WorkItemsGroup.cs
index d9d34ac..d429bc6 100644
--- a/ThirdParty/SmartThreadPool/WorkItemsGroup.cs
+++ b/ThirdParty/SmartThreadPool/WorkItemsGroup.cs
@@ -6,107 +6,107 @@ using System.Diagnostics;
 namespace Amib.Threading.Internal
 {
 
-        #region WorkItemsGroup class 
+    #region WorkItemsGroup class
 
-        /// <summary>
-        /// Summary description for WorkItemsGroup.
-        /// </summary>
-        public class WorkItemsGroup : WorkItemsGroupBase
-        {
-                #region Private members
+    /// <summary>
+    /// Summary description for WorkItemsGroup.
+    /// </summary>
+    public class WorkItemsGroup : WorkItemsGroupBase
+    {
+        #region Private members
 
-                private readonly object _lock = new object();
+        private readonly object _lock = new object();
 
-                /// <summary>
-                /// A reference to the SmartThreadPool instance that created this 
-                /// WorkItemsGroup.
-                /// </summary>
-                private readonly SmartThreadPool _stp;
+        /// <summary>
+        /// A reference to the SmartThreadPool instance that created this
+        /// WorkItemsGroup.
+        /// </summary>
+        private readonly SmartThreadPool _stp;
 
-                /// <summary>
-                /// The OnIdle event
-                /// </summary>
-                private event WorkItemsGroupIdleHandler _onIdle;
+        /// <summary>
+        /// The OnIdle event
+        /// </summary>
+        private event WorkItemsGroupIdleHandler _onIdle;
 
         /// <summary>
         /// A flag to indicate if the Work Items Group is now suspended.
         /// </summary>
         private bool _isSuspended;
 
-                /// <summary>
-                /// Defines how many work items of this WorkItemsGroup can run at once.
-                /// </summary>
-                private int _concurrency;
-
-                /// <summary>
-                /// Priority queue to hold work items before they are passed 
-                /// to the SmartThreadPool.
-                /// </summary>
-                private readonly PriorityQueue _workItemsQueue;
-
-                /// <summary>
-                /// Indicate how many work items are waiting in the SmartThreadPool
-                /// queue.
-                /// This value is used to apply the concurrency.
-                /// </summary>
-                private int _workItemsInStpQueue;
-
-                /// <summary>
-                /// 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.
-                /// </summary>
-                private int _workItemsExecutingInStp = 0;
-
-                /// <summary>
-                /// WorkItemsGroup start information
-                /// </summary>
-                private readonly WIGStartInfo _workItemsGroupStartInfo;
-
-                /// <summary>
-                /// Signaled when all of the WorkItemsGroup's work item completed.
-                /// </summary>
+        /// <summary>
+        /// Defines how many work items of this WorkItemsGroup can run at once.
+        /// </summary>
+        private int _concurrency;
+
+        /// <summary>
+        /// Priority queue to hold work items before they are passed
+        /// to the SmartThreadPool.
+        /// </summary>
+        private readonly PriorityQueue _workItemsQueue;
+
+        /// <summary>
+        /// Indicate how many work items are waiting in the SmartThreadPool
+        /// queue.
+        /// This value is used to apply the concurrency.
+        /// </summary>
+        private int _workItemsInStpQueue;
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        private int _workItemsExecutingInStp = 0;
+
+        /// <summary>
+        /// WorkItemsGroup start information
+        /// </summary>
+        private readonly WIGStartInfo _workItemsGroupStartInfo;
+
+        /// <summary>
+        /// Signaled when all of the WorkItemsGroup's work item completed.
+        /// </summary>
         //private readonly ManualResetEvent _isIdleWaitHandle = new ManualResetEvent(true);
         private readonly ManualResetEvent _isIdleWaitHandle = EventWaitHandleFactory.CreateManualResetEvent(true);
 
-                /// <summary>
-                /// A common object for all the work items that this work items group
-                /// generate so we can mark them to cancel in O(1)
-                /// </summary>
-                private CanceledWorkItemsGroup _canceledWorkItemsGroup = new CanceledWorkItemsGroup();
+        /// <summary>
+        /// A common object for all the work items that this work items group
+        /// generate so we can mark them to cancel in O(1)
+        /// </summary>
+        private CanceledWorkItemsGroup _canceledWorkItemsGroup = new CanceledWorkItemsGroup();
 
-                #endregion 
+        #endregion
 
-                #region Construction
+        #region Construction
 
-            public WorkItemsGroup(
-                        SmartThreadPool stp, 
-                        int concurrency, 
-                        WIGStartInfo wigStartInfo)
-                {
-                        if (concurrency <= 0)
-                        {
-                                throw new ArgumentOutOfRangeException(
+        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";
+            }
+            _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;
+            // 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 
+        #endregion
 
         #region WorkItemsGroupBase Overrides
 
@@ -146,7 +146,7 @@ namespace Amib.Threading.Internal
             }
         }
 
-            /// <summary>
+        /// <summary>
         /// WorkItemsGroup start information
         /// </summary>
         public override WIGStartInfo WIGStartInfo
@@ -154,38 +154,38 @@ namespace Amib.Threading.Internal
             get { return _workItemsGroupStartInfo; }
         }
 
-            /// <summary>
-            /// Start the Work Items Group if it was started suspended
-            /// </summary>
-            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);
-                }
-            }
-
-            /// <summary>
+        /// <summary>
+        /// Start the Work Items Group if it was started suspended
+        /// </summary>
+        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);
+            }
+        }
+
+        /// <summary>
         /// Wait for the thread pool to be idle
         /// </summary>
         public override bool WaitForIdle(int millisecondsTimeout)
@@ -194,34 +194,34 @@ namespace Amib.Threading.Internal
             return STPEventWaitHandle.WaitOne(_isIdleWaitHandle, millisecondsTimeout, false);
         }
 
-            public override event WorkItemsGroupIdleHandler OnIdle
-                {
-                        add { _onIdle += value; }
-                        remove { _onIdle -= value; }
-                }
+        public override event WorkItemsGroupIdleHandler OnIdle
+        {
+            add { _onIdle += value; }
+            remove { _onIdle -= value; }
+        }
 
-            #endregion 
+        #endregion
 
-                #region Private methods
+        #region Private methods
 
-            private void RegisterToWorkItemCompletion(IWorkItemResult wir)
-                {
-                        IInternalWorkItemResult iwir = (IInternalWorkItemResult)wir;
-                        iwir.OnWorkItemStarted += OnWorkItemStartedCallback;
-                        iwir.OnWorkItemCompleted += OnWorkItemCompletedCallback;
-                }
+        private void RegisterToWorkItemCompletion(IWorkItemResult wir)
+        {
+            IInternalWorkItemResult iwir = (IInternalWorkItemResult)wir;
+            iwir.OnWorkItemStarted += OnWorkItemStartedCallback;
+            iwir.OnWorkItemCompleted += OnWorkItemCompletedCallback;
+        }
 
-            public void OnSTPIsStarting()
-                {
+        public void OnSTPIsStarting()
+        {
             if (_isSuspended)
             {
                 return;
             }
-                        
+
             EnqueueToSTPNextNWorkItem(_concurrency);
-                }
+        }
 
-            public void EnqueueToSTPNextNWorkItem(int count)
+        public void EnqueueToSTPNextNWorkItem(int count)
         {
             for (int i = 0; i < count; ++i)
             {
@@ -229,115 +229,115 @@ namespace Amib.Threading.Internal
             }
         }
 
-                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);
-                                }
+        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);
-                }
+            }
+        }
+
+        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);
+        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);
+                    }
+                }
+
+                // 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;
-                                }
+                    }
+                    return;
+                }
 
                 if (!_isSuspended)
-                                {
-                                        if (_workItemsInStpQueue < _concurrency)
-                                        {
-                                                WorkItem nextWorkItem = _workItemsQueue.Dequeue() as WorkItem;
+                {
+                    if (_workItemsInStpQueue < _concurrency)
+                    {
+                        WorkItem nextWorkItem = _workItemsQueue.Dequeue() as WorkItem;
                         try
                         {
                             _stp.Enqueue(nextWorkItem);
@@ -348,14 +348,14 @@ namespace Amib.Threading.Internal
                             // The STP has been shutdown
                         }
 
-                                                ++_workItemsInStpQueue;
-                                        }
-                                }
-                        }
-                }
+                        ++_workItemsInStpQueue;
+                    }
+                }
+            }
+        }
 
-                #endregion
+        #endregion
     }
 
-        #endregion
+    #endregion
 }