1 files changed, 448 insertions, 354 deletions
diff --git a/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs b/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs
index 077cf17..2508661 100644
--- a/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs
+++ b/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs
@@ -1,354 +1,448 @@
-using System;
+using System;
-using System.Diagnostics;
+using System.Diagnostics;
+using System.Threading;
-namespace Amib.Threading.Internal
-{
+namespace Amib.Threading
-    internal enum STPPerformanceCounterType
+{
-    {
+    public interface ISTPPerformanceCountersReader
-        // Fields
+    {
-        ActiveThreads                = 0,
+        long InUseThreads { get; }
-        InUseThreads                = 1,
+        long ActiveThreads { get; }
-        OverheadThreads                = 2,
+        long WorkItemsQueued { get; }
-        OverheadThreadsPercent        = 3,
+        long WorkItemsProcessed { get; }
-        OverheadThreadsPercentBase    = 4,
+    }
+}
-        WorkItems                    = 5,
-        WorkItemsInQueue            = 6,
+namespace Amib.Threading.Internal
-        WorkItemsProcessed            = 7,
+{
+    internal interface ISTPInstancePerformanceCounters : IDisposable
-        WorkItemsQueuedPerSecond    = 8,
+    {
-        WorkItemsProcessedPerSecond    = 9,
+        void Close();
+        void SampleThreads(long activeThreads, long inUseThreads);
-        AvgWorkItemWaitTime            = 10,
+        void SampleWorkItems(long workItemsQueued, long workItemsProcessed);
-        AvgWorkItemWaitTimeBase        = 11,
+        void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime);
+        void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime);
-        AvgWorkItemProcessTime        = 12,
+    }
-        AvgWorkItemProcessTimeBase    = 13,
+#if !(_WINDOWS_CE) && !(_SILVERLIGHT) && !(WINDOWS_PHONE)
-        WorkItemsGroups                = 14,
+    internal enum STPPerformanceCounterType
+        {
-        LastCounter                    = 14,
+                // Fields
-    }
+                ActiveThreads                           = 0,
- 
+                InUseThreads                            = 1,
+                OverheadThreads                         = 2,
-    /// <summary>
+                OverheadThreadsPercent          = 3,
-    /// Summary description for STPPerformanceCounter.
+                OverheadThreadsPercentBase      = 4,
-    /// </summary>
-    internal class STPPerformanceCounter
+                WorkItems                                       = 5,
-    {
+                WorkItemsInQueue                        = 6,
-        // Fields
+                WorkItemsProcessed                      = 7,
-        private PerformanceCounterType _pcType;
-        protected string _counterHelp;
+                WorkItemsQueuedPerSecond        = 8,
-        protected string _counterName;
+                WorkItemsProcessedPerSecond     = 9,
-        // Methods
+                AvgWorkItemWaitTime                     = 10,
-        public STPPerformanceCounter(
+                AvgWorkItemWaitTimeBase         = 11,
-            string counterName, 
-            string counterHelp, 
+                AvgWorkItemProcessTime          = 12,
-            PerformanceCounterType pcType)
+                AvgWorkItemProcessTimeBase      = 13,
-        {
-            this._counterName = counterName;
+                WorkItemsGroups                         = 14,
-            this._counterHelp = counterHelp;
-            this._pcType = pcType;
+                LastCounter                                     = 14,
-        }
+        }
+ 
-        public void AddCounterToCollection(CounterCreationDataCollection counterData)
-        {
+        /// <summary>
-            CounterCreationData counterCreationData = new CounterCreationData(
+        /// Summary description for STPPerformanceCounter.
-                _counterName, 
+        /// </summary>
-                _counterHelp, 
+        internal class STPPerformanceCounter
-                _pcType);
+        {
+                // Fields
-            counterData.Add(counterCreationData);
+                private readonly PerformanceCounterType _pcType;
-        }
+                protected string _counterHelp;
- 
+                protected string _counterName;
-        // Properties
-        public string Name
+                // Methods
-        {
+                public STPPerformanceCounter(
-            get
+                        string counterName, 
-            {
+                        string counterHelp, 
-                return _counterName;
+                        PerformanceCounterType pcType)
-            }
+                {
-        }
+                        _counterName = counterName;
-    }
+                        _counterHelp = counterHelp;
+                        _pcType = pcType;
-    internal class STPPerformanceCounters
+                }
-    {
-        // Fields
+                public void AddCounterToCollection(CounterCreationDataCollection counterData)
-        internal STPPerformanceCounter[] _stpPerformanceCounters;
+                {
-        private static STPPerformanceCounters _instance;
+                        CounterCreationData counterCreationData = new CounterCreationData(
-        internal const string _stpCategoryHelp = "SmartThreadPool performance counters";
+                                _counterName, 
-        internal const string _stpCategoryName = "SmartThreadPool";
+                                _counterHelp, 
+                                _pcType);
-        // Methods
-        static STPPerformanceCounters()
+                        counterData.Add(counterCreationData);
-        {
+                }
-            _instance = new STPPerformanceCounters();
+ 
-        }
+                // Properties
- 
+                public string Name
-        private STPPerformanceCounters()
+                {
-        {
+                        get
-            STPPerformanceCounter[] stpPerformanceCounters = new STPPerformanceCounter[] 
+                        {
-                { 
+                                return _counterName;
-                    new STPPerformanceCounter("Active threads", "The current number of available in the thread pool.", PerformanceCounterType.NumberOfItems32), 
+                        }
-                    new STPPerformanceCounter("In use threads", "The current number of threads that execute a work item.", PerformanceCounterType.NumberOfItems32), 
+                }
-                    new STPPerformanceCounter("Overhead threads", "The current number of threads that are active, but are not in use.", PerformanceCounterType.NumberOfItems32), 
+        }
-                    new STPPerformanceCounter("% overhead threads", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawFraction), 
-                    new STPPerformanceCounter("% overhead threads base", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawBase), 
+        internal class STPPerformanceCounters
+        {
-                    new STPPerformanceCounter("Work Items", "The number of work items in the Smart Thread Pool. Both queued and processed.", PerformanceCounterType.NumberOfItems32), 
+                // Fields
-                    new STPPerformanceCounter("Work Items in queue", "The current number of work items in the queue", PerformanceCounterType.NumberOfItems32), 
+                internal STPPerformanceCounter[] _stpPerformanceCounters;
-                    new STPPerformanceCounter("Work Items processed", "The number of work items already processed", PerformanceCounterType.NumberOfItems32), 
+                private static readonly STPPerformanceCounters _instance;
+                internal const string _stpCategoryHelp = "SmartThreadPool performance counters";
-                    new STPPerformanceCounter("Work Items queued/sec", "The number of work items queued per second", PerformanceCounterType.RateOfCountsPerSecond32), 
+                internal const string _stpCategoryName = "SmartThreadPool";
-                    new STPPerformanceCounter("Work Items processed/sec", "The number of work items processed per second", PerformanceCounterType.RateOfCountsPerSecond32), 
+                // Methods
-                    new STPPerformanceCounter("Avg. Work Item wait time/sec", "The average time a work item supends in the queue waiting for its turn to execute.", PerformanceCounterType.AverageCount64), 
+                static STPPerformanceCounters()
-                    new STPPerformanceCounter("Avg. Work Item wait time base", "The average time a work item supends in the queue waiting for its turn to execute.", PerformanceCounterType.AverageBase), 
+                {
+                        _instance = new STPPerformanceCounters();
-                    new STPPerformanceCounter("Avg. Work Item process time/sec", "The average time it takes to process a work item.", PerformanceCounterType.AverageCount64), 
+                }
-                    new STPPerformanceCounter("Avg. Work Item process time base", "The average time it takes to process a work item.", PerformanceCounterType.AverageBase), 
+ 
+                private STPPerformanceCounters()
-                    new STPPerformanceCounter("Work Items Groups", "The current number of work item groups associated with the Smart Thread Pool.", PerformanceCounterType.NumberOfItems32), 
+                {
-                };
+                        STPPerformanceCounter[] stpPerformanceCounters = new STPPerformanceCounter[] 
+                                { 
-            _stpPerformanceCounters = stpPerformanceCounters;
+                                        new STPPerformanceCounter("Active threads", "The current number of available in the thread pool.", PerformanceCounterType.NumberOfItems32), 
-            SetupCategory();
+                                        new STPPerformanceCounter("In use threads", "The current number of threads that execute a work item.", PerformanceCounterType.NumberOfItems32), 
-        }
+                                        new STPPerformanceCounter("Overhead threads", "The current number of threads that are active, but are not in use.", PerformanceCounterType.NumberOfItems32), 
- 
+                                        new STPPerformanceCounter("% overhead threads", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawFraction), 
-        private void SetupCategory()
+                                        new STPPerformanceCounter("% overhead threads base", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawBase), 
-        {
-            if (!PerformanceCounterCategory.Exists(_stpCategoryName))
+                                        new STPPerformanceCounter("Work Items", "The number of work items in the Smart Thread Pool. Both queued and processed.", PerformanceCounterType.NumberOfItems32), 
-            {
+                                        new STPPerformanceCounter("Work Items in queue", "The current number of work items in the queue", PerformanceCounterType.NumberOfItems32), 
-                CounterCreationDataCollection counters = new CounterCreationDataCollection();
+                                        new STPPerformanceCounter("Work Items processed", "The number of work items already processed", PerformanceCounterType.NumberOfItems32), 
-                for (int i = 0; i < _stpPerformanceCounters.Length; i++)
+                                        new STPPerformanceCounter("Work Items queued/sec", "The number of work items queued per second", PerformanceCounterType.RateOfCountsPerSecond32), 
-                {
+                                        new STPPerformanceCounter("Work Items processed/sec", "The number of work items processed per second", PerformanceCounterType.RateOfCountsPerSecond32), 
-                    _stpPerformanceCounters[i].AddCounterToCollection(counters);
-                }
+                                        new STPPerformanceCounter("Avg. Work Item wait time/sec", "The average time a work item supends in the queue waiting for its turn to execute.", PerformanceCounterType.AverageCount64), 
+                                        new STPPerformanceCounter("Avg. Work Item wait time base", "The average time a work item supends in the queue waiting for its turn to execute.", PerformanceCounterType.AverageBase), 
-                // *********** Remark for .NET 2.0 ***********
+                                        new STPPerformanceCounter("Avg. Work Item process time/sec", "The average time it takes to process a work item.", PerformanceCounterType.AverageCount64), 
-                // If you are here, it means you got the warning that this overload
+                                        new STPPerformanceCounter("Avg. Work Item process time base", "The average time it takes to process a work item.", PerformanceCounterType.AverageBase), 
-                // of the method is deprecated in .NET 2.0. To use the correct 
-                // method overload, uncomment the third argument of
+                                        new STPPerformanceCounter("Work Items Groups", "The current number of work item groups associated with the Smart Thread Pool.", PerformanceCounterType.NumberOfItems32), 
-                // the method.
+                                };
-                #pragma warning disable 0618
-                PerformanceCounterCategory.Create(
+                        _stpPerformanceCounters = stpPerformanceCounters;
-                    _stpCategoryName, 
+                        SetupCategory();
-                    _stpCategoryHelp, 
+                }
-                    //PerformanceCounterCategoryType.MultiInstance,
+ 
-                    counters);
+                private void SetupCategory()
-                #pragma warning restore 0618
+                {
-            }
+                        if (!PerformanceCounterCategory.Exists(_stpCategoryName))
-        }
+                        {
- 
+                                CounterCreationDataCollection counters = new CounterCreationDataCollection();
-        // Properties
-        public static STPPerformanceCounters Instance
+                                for (int i = 0; i < _stpPerformanceCounters.Length; i++)
-        {
+                                {
-            get
+                                        _stpPerformanceCounters[i].AddCounterToCollection(counters);
-            {
+                                }
-                return _instance;
-            }
+                                PerformanceCounterCategory.Create(
-        }
+                                        _stpCategoryName, 
-     }
+                                        _stpCategoryHelp, 
+                    PerformanceCounterCategoryType.MultiInstance,
-    internal class STPInstancePerformanceCounter : IDisposable
+                                        counters);
-    {
+                                        
-        // Fields
+                        }
-        private PerformanceCounter _pcs;
+                }
+ 
-        // Methods
+                // Properties
-        protected STPInstancePerformanceCounter()
+                public static STPPerformanceCounters Instance
-        {
+                {
-        }
+                        get
+                        {
-        public STPInstancePerformanceCounter(
+                                return _instance;
-            string instance, 
+                        }
-            STPPerformanceCounterType spcType)
+                }
-        {
+        }
-            STPPerformanceCounters counters = STPPerformanceCounters.Instance;
-            _pcs = new PerformanceCounter(
+        internal class STPInstancePerformanceCounter : IDisposable
-                STPPerformanceCounters._stpCategoryName, 
+        {
-                counters._stpPerformanceCounters[(int) spcType].Name, 
+                // Fields
-                instance, 
+        private bool _isDisposed;
-                false);
+                private PerformanceCounter _pcs;
-            _pcs.RawValue = _pcs.RawValue;
-        }
+                // Methods
+                protected STPInstancePerformanceCounter()
-        ~STPInstancePerformanceCounter()
+                {
-        {
+            _isDisposed = false;
-            Close();
+                }
-        }
+                public STPInstancePerformanceCounter(
-        public void Close()
+                        string instance, 
-        {
+                        STPPerformanceCounterType spcType) : this()
-            if (_pcs != null)
+                {
-            {
+                        STPPerformanceCounters counters = STPPerformanceCounters.Instance;
-                _pcs.RemoveInstance();
+                        _pcs = new PerformanceCounter(
-                _pcs.Close();
+                                STPPerformanceCounters._stpCategoryName, 
-                _pcs = null;
+                                counters._stpPerformanceCounters[(int) spcType].Name, 
-            }
+                                instance, 
-        }
+                                false);
- 
+                        _pcs.RawValue = _pcs.RawValue;
-        public void Dispose()
+                }
-        {
-            Close();
-            GC.SuppressFinalize(this);
+                public void Close()
-        }
+                {
- 
+                        if (_pcs != null)
-        public virtual void Increment()
+                        {
-        {
+                                _pcs.RemoveInstance();
-            _pcs.Increment();
+                                _pcs.Close();
-        }
+                                _pcs = null;
- 
+                        }
-        public virtual void IncrementBy(long val)
+                }
-        {
+ 
-            _pcs.IncrementBy(val);
+                public void Dispose()
-        }
+                {
+            Dispose(true);
-        public virtual void Set(long val)
+                }
-        {
-            _pcs.RawValue = val;
+        public virtual void Dispose(bool disposing)
-        }
+        {
-    }
+            if (!_isDisposed)
+            {
-    internal class STPInstanceNullPerformanceCounter : STPInstancePerformanceCounter
+                if (disposing)
-    {
+                {
-        // Methods
+                    Close();
-        public STPInstanceNullPerformanceCounter() {}
+                }
-        public override void Increment() {}
+            }
-        public override void IncrementBy(long value) {}
+            _isDisposed = true;
-        public override void Set(long val) {}
+        }
-    }
+ 
-        
+                public virtual void Increment()
-    internal interface ISTPInstancePerformanceCounters : IDisposable
+                {
-    {
+                        _pcs.Increment();
-        void Close();
+                }
-        void SampleThreads(long activeThreads, long inUseThreads);
+ 
-        void SampleWorkItems(long workItemsQueued, long workItemsProcessed);
+                public virtual void IncrementBy(long val)
-        void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime);
+                {
-        void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime);
+                        _pcs.IncrementBy(val);
-    }
+                }
+                public virtual void Set(long val)
-    internal class STPInstancePerformanceCounters : ISTPInstancePerformanceCounters, IDisposable
+                {
-    {
+                        _pcs.RawValue = val;
-        // Fields
+                }
-        private STPInstancePerformanceCounter[] _pcs;
+        }
-        private static STPInstancePerformanceCounter _stpInstanceNullPerformanceCounter;
+        internal class STPInstanceNullPerformanceCounter : STPInstancePerformanceCounter
-        // Methods
+        {
-        static STPInstancePerformanceCounters()
+                // Methods
-        {
+                public override void Increment() {}
-            _stpInstanceNullPerformanceCounter = new STPInstanceNullPerformanceCounter();
+                public override void IncrementBy(long value) {}
-        }
+                public override void Set(long val) {}
- 
+        }
-        public STPInstancePerformanceCounters(string instance)
-        {
-            _pcs = new STPInstancePerformanceCounter[(int)STPPerformanceCounterType.LastCounter];
-            // STPPerformanceCounters counters = STPPerformanceCounters.Instance;
+        internal class STPInstancePerformanceCounters : ISTPInstancePerformanceCounters
-            for (int i = 0; i < _pcs.Length; i++)
+        {
-            {
+        private bool _isDisposed;
-                if (instance != null)
+                // Fields
-                {
+                private STPInstancePerformanceCounter[] _pcs;
-                    _pcs[i] = new STPInstancePerformanceCounter(
+                private static readonly STPInstancePerformanceCounter _stpInstanceNullPerformanceCounter;
-                        instance, 
-                        (STPPerformanceCounterType) i);
+                // Methods
-                }
+                static STPInstancePerformanceCounters()
-                else
+                {
-                {
+                        _stpInstanceNullPerformanceCounter = new STPInstanceNullPerformanceCounter();
-                    _pcs[i] = _stpInstanceNullPerformanceCounter;
+                }
-                }
+ 
-            }
+                public STPInstancePerformanceCounters(string instance)
-        }
+                {
- 
+            _isDisposed = false;
+                        _pcs = new STPInstancePerformanceCounter[(int)STPPerformanceCounterType.LastCounter];
-        public void Close()
-        {
+            // Call the STPPerformanceCounters.Instance so the static constructor will
-            if (null != _pcs)
+            // intialize the STPPerformanceCounters singleton.
-            {
+                        STPPerformanceCounters.Instance.GetHashCode();
-                for (int i = 0; i < _pcs.Length; i++)
-                {
+                        for (int i = 0; i < _pcs.Length; i++)
-                    if (null != _pcs[i])
+                        {
-                    {
+                                if (instance != null)
-                        _pcs[i].Close();
+                                {
-                    }
+                                        _pcs[i] = new STPInstancePerformanceCounter(
-                }
+                                                instance, 
-                _pcs = null;
+                                                (STPPerformanceCounterType) i);
-            }
+                                }
-        }
+                                else
+                                {
-        ~STPInstancePerformanceCounters()
+                                        _pcs[i] = _stpInstanceNullPerformanceCounter;
-        {
+                                }
-            Close();
+                        }
-        }
+                }
+ 
-        public void Dispose()
-        {
+                public void Close()
-            Close();
+                {
-            GC.SuppressFinalize(this);
+                        if (null != _pcs)
-        }
+                        {
- 
+                                for (int i = 0; i < _pcs.Length; i++)
-        private STPInstancePerformanceCounter GetCounter(STPPerformanceCounterType spcType)
+                                {
-        {
+                    if (null != _pcs[i])
-            return _pcs[(int) spcType];
+                    {
-        }
+                        _pcs[i].Dispose();
+                    }
-        public void SampleThreads(long activeThreads, long inUseThreads)
+                                }
-        {
+                                _pcs = null;
-            GetCounter(STPPerformanceCounterType.ActiveThreads).Set(activeThreads);
+                        }
-            GetCounter(STPPerformanceCounterType.InUseThreads).Set(inUseThreads);
+                }
-            GetCounter(STPPerformanceCounterType.OverheadThreads).Set(activeThreads-inUseThreads);
+                public void Dispose()
-            GetCounter(STPPerformanceCounterType.OverheadThreadsPercentBase).Set(activeThreads-inUseThreads);
+                {
-            GetCounter(STPPerformanceCounterType.OverheadThreadsPercent).Set(inUseThreads);
+            Dispose(true);
-        }
+                }
-        public void SampleWorkItems(long workItemsQueued, long workItemsProcessed)
+        public virtual void Dispose(bool disposing)
-        {
+        {
-            GetCounter(STPPerformanceCounterType.WorkItems).Set(workItemsQueued+workItemsProcessed);
+            if (!_isDisposed)
-            GetCounter(STPPerformanceCounterType.WorkItemsInQueue).Set(workItemsQueued);
+            {
-            GetCounter(STPPerformanceCounterType.WorkItemsProcessed).Set(workItemsProcessed);
+                if (disposing)
+                {
-            GetCounter(STPPerformanceCounterType.WorkItemsQueuedPerSecond).Set(workItemsQueued);
+                    Close();
-            GetCounter(STPPerformanceCounterType.WorkItemsProcessedPerSecond).Set(workItemsProcessed);
+                }
-        }
+            }
+            _isDisposed = true;
-        public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime)
+        }
-        {
+ 
-            GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTime).IncrementBy((long)workItemWaitTime.TotalMilliseconds);
+                private STPInstancePerformanceCounter GetCounter(STPPerformanceCounterType spcType)
-            GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTimeBase).Increment();
+                {
-        }
+                        return _pcs[(int) spcType];
+                }
-        public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime)
-        {
+                public void SampleThreads(long activeThreads, long inUseThreads)
-            GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTime).IncrementBy((long)workItemProcessTime.TotalMilliseconds);
+                {
-            GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTimeBase).Increment();
+                        GetCounter(STPPerformanceCounterType.ActiveThreads).Set(activeThreads);
-        }
+                        GetCounter(STPPerformanceCounterType.InUseThreads).Set(inUseThreads);
-    }
+                        GetCounter(STPPerformanceCounterType.OverheadThreads).Set(activeThreads-inUseThreads);
-    internal class NullSTPInstancePerformanceCounters : ISTPInstancePerformanceCounters, IDisposable
+                        GetCounter(STPPerformanceCounterType.OverheadThreadsPercentBase).Set(activeThreads-inUseThreads);
-    {
+                        GetCounter(STPPerformanceCounterType.OverheadThreadsPercent).Set(inUseThreads);
-        static NullSTPInstancePerformanceCounters()
+                }
-        {
-        }
+                public void SampleWorkItems(long workItemsQueued, long workItemsProcessed)
+                {
-        private static NullSTPInstancePerformanceCounters _instance = new NullSTPInstancePerformanceCounters(null);
+                        GetCounter(STPPerformanceCounterType.WorkItems).Set(workItemsQueued+workItemsProcessed);
+                        GetCounter(STPPerformanceCounterType.WorkItemsInQueue).Set(workItemsQueued);
-        public static NullSTPInstancePerformanceCounters Instance
+                        GetCounter(STPPerformanceCounterType.WorkItemsProcessed).Set(workItemsProcessed);
-        {
-            get { return _instance; }
+                        GetCounter(STPPerformanceCounterType.WorkItemsQueuedPerSecond).Set(workItemsQueued);
-        }
+                        GetCounter(STPPerformanceCounterType.WorkItemsProcessedPerSecond).Set(workItemsProcessed);
+                }
-        public NullSTPInstancePerformanceCounters(string instance) {}
-         public void Close() {}
+                public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime)
-        public void Dispose() {}
+                {
- 
+                        GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTime).IncrementBy((long)workItemWaitTime.TotalMilliseconds);
-        public void SampleThreads(long activeThreads, long inUseThreads) {}
+                        GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTimeBase).Increment();
-        public void SampleWorkItems(long workItemsQueued, long workItemsProcessed) {}
+                }
-        public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime) {}
-        public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime) {}
+                public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime)
-    }
+                {
+                        GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTime).IncrementBy((long)workItemProcessTime.TotalMilliseconds);
-}
+                        GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTimeBase).Increment();
+                }
+    }
+#endif
+    internal class NullSTPInstancePerformanceCounters : ISTPInstancePerformanceCounters, ISTPPerformanceCountersReader
+        {
+                private static readonly NullSTPInstancePerformanceCounters _instance = new NullSTPInstancePerformanceCounters();
+                public static NullSTPInstancePerformanceCounters Instance
+                {
+                        get { return _instance; }
+                }
+                public void Close() {}
+                public void Dispose() {}
+ 
+                public void SampleThreads(long activeThreads, long inUseThreads) {}
+                public void SampleWorkItems(long workItemsQueued, long workItemsProcessed) {}
+                public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime) {}
+                public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime) {}
+        public long InUseThreads
+        {
+            get { return 0; }
+        }
+        public long ActiveThreads
+        {
+            get { return 0; }
+        }
+        public long WorkItemsQueued
+        {
+            get { return 0; }
+        }
+        public long WorkItemsProcessed
+        {
+            get { return 0; }
+        }
+        }
+    internal class LocalSTPInstancePerformanceCounters : ISTPInstancePerformanceCounters, ISTPPerformanceCountersReader
+    {
+        public void Close() { }
+        public void Dispose() { }
+        private long _activeThreads;
+        private long _inUseThreads;
+        private long _workItemsQueued;
+        private long _workItemsProcessed;
+        public long InUseThreads
+        {
+            get { return _inUseThreads; }
+        }
+        public long ActiveThreads
+        {
+            get { return _activeThreads; }
+        }
+        public long WorkItemsQueued
+        {
+            get { return _workItemsQueued; }
+        }
+        public long WorkItemsProcessed
+        {
+            get { return _workItemsProcessed; }
+        }
+        public void SampleThreads(long activeThreads, long inUseThreads)
+        {
+            _activeThreads = activeThreads;
+            _inUseThreads = inUseThreads;
+        }
+        public void SampleWorkItems(long workItemsQueued, long workItemsProcessed)
+        {
+            _workItemsQueued = workItemsQueued;
+            _workItemsProcessed = workItemsProcessed;
+        }
+        public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime)
+        {
+            // Not supported
+        }
+        public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime)
+        {
+            // Not supported
+        }
+    }
+}