diff options
author | David Walter Seikel | 2016-11-03 21:44:39 +1000 |
---|---|---|
committer | David Walter Seikel | 2016-11-03 21:44:39 +1000 |
commit | 134f86e8d5c414409631b25b8c6f0ee45fbd8631 (patch) | |
tree | 216b89d3fb89acfb81be1e440c25c41ab09fa96d /ThirdParty/SmartThreadPool/STPPerformanceCounter.cs | |
parent | More changing to production grid. Double oops. (diff) | |
download | opensim-SC-134f86e8d5c414409631b25b8c6f0ee45fbd8631.zip opensim-SC-134f86e8d5c414409631b25b8c6f0ee45fbd8631.tar.gz opensim-SC-134f86e8d5c414409631b25b8c6f0ee45fbd8631.tar.bz2 opensim-SC-134f86e8d5c414409631b25b8c6f0ee45fbd8631.tar.xz |
Initial update to OpenSim 0.8.2.1 source code.
Diffstat (limited to 'ThirdParty/SmartThreadPool/STPPerformanceCounter.cs')
-rw-r--r-- | ThirdParty/SmartThreadPool/STPPerformanceCounter.cs | 648 |
1 files changed, 371 insertions, 277 deletions
diff --git a/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs b/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs index 077cf17..0663d1d 100644 --- a/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs +++ b/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs | |||
@@ -1,354 +1,448 @@ | |||
1 | using System; | 1 | using System; |
2 | using System.Diagnostics; | 2 | using System.Diagnostics; |
3 | using System.Threading; | ||
4 | |||
5 | namespace Amib.Threading | ||
6 | { | ||
7 | public interface ISTPPerformanceCountersReader | ||
8 | { | ||
9 | long InUseThreads { get; } | ||
10 | long ActiveThreads { get; } | ||
11 | long WorkItemsQueued { get; } | ||
12 | long WorkItemsProcessed { get; } | ||
13 | } | ||
14 | } | ||
3 | 15 | ||
4 | namespace Amib.Threading.Internal | 16 | namespace Amib.Threading.Internal |
5 | { | 17 | { |
6 | internal enum STPPerformanceCounterType | 18 | internal interface ISTPInstancePerformanceCounters : IDisposable |
7 | { | 19 | { |
8 | // Fields | 20 | void Close(); |
9 | ActiveThreads = 0, | 21 | void SampleThreads(long activeThreads, long inUseThreads); |
10 | InUseThreads = 1, | 22 | void SampleWorkItems(long workItemsQueued, long workItemsProcessed); |
11 | OverheadThreads = 2, | 23 | void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime); |
12 | OverheadThreadsPercent = 3, | 24 | void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime); |
13 | OverheadThreadsPercentBase = 4, | 25 | } |
26 | #if !(_WINDOWS_CE) && !(_SILVERLIGHT) && !(WINDOWS_PHONE) | ||
14 | 27 | ||
15 | WorkItems = 5, | 28 | internal enum STPPerformanceCounterType |
16 | WorkItemsInQueue = 6, | 29 | { |
17 | WorkItemsProcessed = 7, | 30 | // Fields |
31 | ActiveThreads = 0, | ||
32 | InUseThreads = 1, | ||
33 | OverheadThreads = 2, | ||
34 | OverheadThreadsPercent = 3, | ||
35 | OverheadThreadsPercentBase = 4, | ||
18 | 36 | ||
19 | WorkItemsQueuedPerSecond = 8, | 37 | WorkItems = 5, |
20 | WorkItemsProcessedPerSecond = 9, | 38 | WorkItemsInQueue = 6, |
39 | WorkItemsProcessed = 7, | ||
21 | 40 | ||
22 | AvgWorkItemWaitTime = 10, | 41 | WorkItemsQueuedPerSecond = 8, |
23 | AvgWorkItemWaitTimeBase = 11, | 42 | WorkItemsProcessedPerSecond = 9, |
24 | 43 | ||
25 | AvgWorkItemProcessTime = 12, | 44 | AvgWorkItemWaitTime = 10, |
26 | AvgWorkItemProcessTimeBase = 13, | 45 | AvgWorkItemWaitTimeBase = 11, |
27 | 46 | ||
28 | WorkItemsGroups = 14, | 47 | AvgWorkItemProcessTime = 12, |
48 | AvgWorkItemProcessTimeBase = 13, | ||
29 | 49 | ||
30 | LastCounter = 14, | 50 | WorkItemsGroups = 14, |
31 | } | ||
32 | |||
33 | 51 | ||
34 | /// <summary> | 52 | LastCounter = 14, |
35 | /// Summary description for STPPerformanceCounter. | 53 | } |
36 | /// </summary> | 54 | |
37 | internal class STPPerformanceCounter | ||
38 | { | ||
39 | // Fields | ||
40 | private PerformanceCounterType _pcType; | ||
41 | protected string _counterHelp; | ||
42 | protected string _counterName; | ||
43 | |||
44 | // Methods | ||
45 | public STPPerformanceCounter( | ||
46 | string counterName, | ||
47 | string counterHelp, | ||
48 | PerformanceCounterType pcType) | ||
49 | { | ||
50 | this._counterName = counterName; | ||
51 | this._counterHelp = counterHelp; | ||
52 | this._pcType = pcType; | ||
53 | } | ||
54 | |||
55 | public void AddCounterToCollection(CounterCreationDataCollection counterData) | ||
56 | { | ||
57 | CounterCreationData counterCreationData = new CounterCreationData( | ||
58 | _counterName, | ||
59 | _counterHelp, | ||
60 | _pcType); | ||
61 | 55 | ||
62 | counterData.Add(counterCreationData); | 56 | /// <summary> |
63 | } | 57 | /// Summary description for STPPerformanceCounter. |
58 | /// </summary> | ||
59 | internal class STPPerformanceCounter | ||
60 | { | ||
61 | // Fields | ||
62 | private readonly PerformanceCounterType _pcType; | ||
63 | protected string _counterHelp; | ||
64 | protected string _counterName; | ||
65 | |||
66 | // Methods | ||
67 | public STPPerformanceCounter( | ||
68 | string counterName, | ||
69 | string counterHelp, | ||
70 | PerformanceCounterType pcType) | ||
71 | { | ||
72 | _counterName = counterName; | ||
73 | _counterHelp = counterHelp; | ||
74 | _pcType = pcType; | ||
75 | } | ||
76 | |||
77 | public void AddCounterToCollection(CounterCreationDataCollection counterData) | ||
78 | { | ||
79 | CounterCreationData counterCreationData = new CounterCreationData( | ||
80 | _counterName, | ||
81 | _counterHelp, | ||
82 | _pcType); | ||
83 | |||
84 | counterData.Add(counterCreationData); | ||
85 | } | ||
86 | |||
87 | // Properties | ||
88 | public string Name | ||
89 | { | ||
90 | get | ||
91 | { | ||
92 | return _counterName; | ||
93 | } | ||
94 | } | ||
95 | } | ||
96 | |||
97 | internal class STPPerformanceCounters | ||
98 | { | ||
99 | // Fields | ||
100 | internal STPPerformanceCounter[] _stpPerformanceCounters; | ||
101 | private static readonly STPPerformanceCounters _instance; | ||
102 | internal const string _stpCategoryHelp = "SmartThreadPool performance counters"; | ||
103 | internal const string _stpCategoryName = "SmartThreadPool"; | ||
104 | |||
105 | // Methods | ||
106 | static STPPerformanceCounters() | ||
107 | { | ||
108 | _instance = new STPPerformanceCounters(); | ||
109 | } | ||
110 | |||
111 | private STPPerformanceCounters() | ||
112 | { | ||
113 | STPPerformanceCounter[] stpPerformanceCounters = new STPPerformanceCounter[] | ||
114 | { | ||
115 | new STPPerformanceCounter("Active threads", "The current number of available in the thread pool.", PerformanceCounterType.NumberOfItems32), | ||
116 | new STPPerformanceCounter("In use threads", "The current number of threads that execute a work item.", PerformanceCounterType.NumberOfItems32), | ||
117 | new STPPerformanceCounter("Overhead threads", "The current number of threads that are active, but are not in use.", PerformanceCounterType.NumberOfItems32), | ||
118 | new STPPerformanceCounter("% overhead threads", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawFraction), | ||
119 | new STPPerformanceCounter("% overhead threads base", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawBase), | ||
120 | |||
121 | new STPPerformanceCounter("Work Items", "The number of work items in the Smart Thread Pool. Both queued and processed.", PerformanceCounterType.NumberOfItems32), | ||
122 | new STPPerformanceCounter("Work Items in queue", "The current number of work items in the queue", PerformanceCounterType.NumberOfItems32), | ||
123 | new STPPerformanceCounter("Work Items processed", "The number of work items already processed", PerformanceCounterType.NumberOfItems32), | ||
124 | |||
125 | new STPPerformanceCounter("Work Items queued/sec", "The number of work items queued per second", PerformanceCounterType.RateOfCountsPerSecond32), | ||
126 | new STPPerformanceCounter("Work Items processed/sec", "The number of work items processed per second", PerformanceCounterType.RateOfCountsPerSecond32), | ||
127 | |||
128 | 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), | ||
129 | 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), | ||
130 | |||
131 | new STPPerformanceCounter("Avg. Work Item process time/sec", "The average time it takes to process a work item.", PerformanceCounterType.AverageCount64), | ||
132 | new STPPerformanceCounter("Avg. Work Item process time base", "The average time it takes to process a work item.", PerformanceCounterType.AverageBase), | ||
133 | |||
134 | new STPPerformanceCounter("Work Items Groups", "The current number of work item groups associated with the Smart Thread Pool.", PerformanceCounterType.NumberOfItems32), | ||
135 | }; | ||
136 | |||
137 | _stpPerformanceCounters = stpPerformanceCounters; | ||
138 | SetupCategory(); | ||
139 | } | ||
140 | |||
141 | private void SetupCategory() | ||
142 | { | ||
143 | if (!PerformanceCounterCategory.Exists(_stpCategoryName)) | ||
144 | { | ||
145 | CounterCreationDataCollection counters = new CounterCreationDataCollection(); | ||
146 | |||
147 | for (int i = 0; i < _stpPerformanceCounters.Length; i++) | ||
148 | { | ||
149 | _stpPerformanceCounters[i].AddCounterToCollection(counters); | ||
150 | } | ||
151 | |||
152 | PerformanceCounterCategory.Create( | ||
153 | _stpCategoryName, | ||
154 | _stpCategoryHelp, | ||
155 | PerformanceCounterCategoryType.MultiInstance, | ||
156 | counters); | ||
157 | |||
158 | } | ||
159 | } | ||
64 | 160 | ||
65 | // Properties | 161 | // Properties |
66 | public string Name | 162 | public static STPPerformanceCounters Instance |
163 | { | ||
164 | get | ||
165 | { | ||
166 | return _instance; | ||
167 | } | ||
168 | } | ||
169 | } | ||
170 | |||
171 | internal class STPInstancePerformanceCounter : IDisposable | ||
172 | { | ||
173 | // Fields | ||
174 | private bool _isDisposed; | ||
175 | private PerformanceCounter _pcs; | ||
176 | |||
177 | // Methods | ||
178 | protected STPInstancePerformanceCounter() | ||
179 | { | ||
180 | _isDisposed = false; | ||
181 | } | ||
182 | |||
183 | public STPInstancePerformanceCounter( | ||
184 | string instance, | ||
185 | STPPerformanceCounterType spcType) : this() | ||
186 | { | ||
187 | STPPerformanceCounters counters = STPPerformanceCounters.Instance; | ||
188 | _pcs = new PerformanceCounter( | ||
189 | STPPerformanceCounters._stpCategoryName, | ||
190 | counters._stpPerformanceCounters[(int) spcType].Name, | ||
191 | instance, | ||
192 | false); | ||
193 | _pcs.RawValue = _pcs.RawValue; | ||
194 | } | ||
195 | |||
196 | |||
197 | public void Close() | ||
198 | { | ||
199 | if (_pcs != null) | ||
200 | { | ||
201 | _pcs.RemoveInstance(); | ||
202 | _pcs.Close(); | ||
203 | _pcs = null; | ||
204 | } | ||
205 | } | ||
206 | |||
207 | public void Dispose() | ||
208 | { | ||
209 | Dispose(true); | ||
210 | } | ||
211 | |||
212 | public virtual void Dispose(bool disposing) | ||
67 | { | 213 | { |
68 | get | 214 | if (!_isDisposed) |
69 | { | 215 | { |
70 | return _counterName; | 216 | if (disposing) |
217 | { | ||
218 | Close(); | ||
219 | } | ||
71 | } | 220 | } |
72 | } | 221 | _isDisposed = true; |
73 | } | ||
74 | |||
75 | internal class STPPerformanceCounters | ||
76 | { | ||
77 | // Fields | ||
78 | internal STPPerformanceCounter[] _stpPerformanceCounters; | ||
79 | private static STPPerformanceCounters _instance; | ||
80 | internal const string _stpCategoryHelp = "SmartThreadPool performance counters"; | ||
81 | internal const string _stpCategoryName = "SmartThreadPool"; | ||
82 | |||
83 | // Methods | ||
84 | static STPPerformanceCounters() | ||
85 | { | ||
86 | _instance = new STPPerformanceCounters(); | ||
87 | } | 222 | } |
88 | 223 | ||
89 | private STPPerformanceCounters() | 224 | public virtual void Increment() |
90 | { | 225 | { |
91 | STPPerformanceCounter[] stpPerformanceCounters = new STPPerformanceCounter[] | 226 | _pcs.Increment(); |
92 | { | 227 | } |
93 | new STPPerformanceCounter("Active threads", "The current number of available in the thread pool.", PerformanceCounterType.NumberOfItems32), | 228 | |
94 | new STPPerformanceCounter("In use threads", "The current number of threads that execute a work item.", PerformanceCounterType.NumberOfItems32), | 229 | public virtual void IncrementBy(long val) |
95 | new STPPerformanceCounter("Overhead threads", "The current number of threads that are active, but are not in use.", PerformanceCounterType.NumberOfItems32), | 230 | { |
96 | new STPPerformanceCounter("% overhead threads", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawFraction), | 231 | _pcs.IncrementBy(val); |
97 | new STPPerformanceCounter("% overhead threads base", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawBase), | 232 | } |
98 | 233 | ||
99 | new STPPerformanceCounter("Work Items", "The number of work items in the Smart Thread Pool. Both queued and processed.", PerformanceCounterType.NumberOfItems32), | 234 | public virtual void Set(long val) |
100 | new STPPerformanceCounter("Work Items in queue", "The current number of work items in the queue", PerformanceCounterType.NumberOfItems32), | 235 | { |
101 | new STPPerformanceCounter("Work Items processed", "The number of work items already processed", PerformanceCounterType.NumberOfItems32), | 236 | _pcs.RawValue = val; |
102 | 237 | } | |
103 | new STPPerformanceCounter("Work Items queued/sec", "The number of work items queued per second", PerformanceCounterType.RateOfCountsPerSecond32), | 238 | } |
104 | new STPPerformanceCounter("Work Items processed/sec", "The number of work items processed per second", PerformanceCounterType.RateOfCountsPerSecond32), | 239 | |
105 | 240 | internal class STPInstanceNullPerformanceCounter : STPInstancePerformanceCounter | |
106 | 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), | 241 | { |
107 | 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), | 242 | // Methods |
243 | public override void Increment() {} | ||
244 | public override void IncrementBy(long value) {} | ||
245 | public override void Set(long val) {} | ||
246 | } | ||
247 | |||
248 | |||
249 | |||
250 | internal class STPInstancePerformanceCounters : ISTPInstancePerformanceCounters | ||
251 | { | ||
252 | private bool _isDisposed; | ||
253 | // Fields | ||
254 | private STPInstancePerformanceCounter[] _pcs; | ||
255 | private static readonly STPInstancePerformanceCounter _stpInstanceNullPerformanceCounter; | ||
256 | |||
257 | // Methods | ||
258 | static STPInstancePerformanceCounters() | ||
259 | { | ||
260 | _stpInstanceNullPerformanceCounter = new STPInstanceNullPerformanceCounter(); | ||
261 | } | ||
262 | |||
263 | public STPInstancePerformanceCounters(string instance) | ||
264 | { | ||
265 | _isDisposed = false; | ||
266 | _pcs = new STPInstancePerformanceCounter[(int)STPPerformanceCounterType.LastCounter]; | ||
267 | |||
268 | // Call the STPPerformanceCounters.Instance so the static constructor will | ||
269 | // intialize the STPPerformanceCounters singleton. | ||
270 | STPPerformanceCounters.Instance.GetHashCode(); | ||
271 | |||
272 | for (int i = 0; i < _pcs.Length; i++) | ||
273 | { | ||
274 | if (instance != null) | ||
275 | { | ||
276 | _pcs[i] = new STPInstancePerformanceCounter( | ||
277 | instance, | ||
278 | (STPPerformanceCounterType) i); | ||
279 | } | ||
280 | else | ||
281 | { | ||
282 | _pcs[i] = _stpInstanceNullPerformanceCounter; | ||
283 | } | ||
284 | } | ||
285 | } | ||
286 | |||
108 | 287 | ||
109 | new STPPerformanceCounter("Avg. Work Item process time/sec", "The average time it takes to process a work item.", PerformanceCounterType.AverageCount64), | 288 | public void Close() |
110 | new STPPerformanceCounter("Avg. Work Item process time base", "The average time it takes to process a work item.", PerformanceCounterType.AverageBase), | 289 | { |
290 | if (null != _pcs) | ||
291 | { | ||
292 | for (int i = 0; i < _pcs.Length; i++) | ||
293 | { | ||
294 | if (null != _pcs[i]) | ||
295 | { | ||
296 | _pcs[i].Dispose(); | ||
297 | } | ||
298 | } | ||
299 | _pcs = null; | ||
300 | } | ||
301 | } | ||
111 | 302 | ||
112 | new STPPerformanceCounter("Work Items Groups", "The current number of work item groups associated with the Smart Thread Pool.", PerformanceCounterType.NumberOfItems32), | 303 | public void Dispose() |
113 | }; | 304 | { |
305 | Dispose(true); | ||
306 | } | ||
114 | 307 | ||
115 | _stpPerformanceCounters = stpPerformanceCounters; | 308 | public virtual void Dispose(bool disposing) |
116 | SetupCategory(); | ||
117 | } | ||
118 | |||
119 | private void SetupCategory() | ||
120 | { | 309 | { |
121 | if (!PerformanceCounterCategory.Exists(_stpCategoryName)) | 310 | if (!_isDisposed) |
122 | { | 311 | { |
123 | CounterCreationDataCollection counters = new CounterCreationDataCollection(); | 312 | if (disposing) |
124 | |||
125 | for (int i = 0; i < _stpPerformanceCounters.Length; i++) | ||
126 | { | 313 | { |
127 | _stpPerformanceCounters[i].AddCounterToCollection(counters); | 314 | Close(); |
128 | } | 315 | } |
129 | |||
130 | |||
131 | // *********** Remark for .NET 2.0 *********** | ||
132 | // If you are here, it means you got the warning that this overload | ||
133 | // of the method is deprecated in .NET 2.0. To use the correct | ||
134 | // method overload, uncomment the third argument of | ||
135 | // the method. | ||
136 | #pragma warning disable 0618 | ||
137 | PerformanceCounterCategory.Create( | ||
138 | _stpCategoryName, | ||
139 | _stpCategoryHelp, | ||
140 | //PerformanceCounterCategoryType.MultiInstance, | ||
141 | counters); | ||
142 | #pragma warning restore 0618 | ||
143 | } | 316 | } |
317 | _isDisposed = true; | ||
144 | } | 318 | } |
145 | 319 | ||
146 | // Properties | 320 | private STPInstancePerformanceCounter GetCounter(STPPerformanceCounterType spcType) |
147 | public static STPPerformanceCounters Instance | 321 | { |
148 | { | 322 | return _pcs[(int) spcType]; |
149 | get | 323 | } |
150 | { | 324 | |
151 | return _instance; | 325 | public void SampleThreads(long activeThreads, long inUseThreads) |
152 | } | 326 | { |
153 | } | 327 | GetCounter(STPPerformanceCounterType.ActiveThreads).Set(activeThreads); |
154 | } | 328 | GetCounter(STPPerformanceCounterType.InUseThreads).Set(inUseThreads); |
329 | GetCounter(STPPerformanceCounterType.OverheadThreads).Set(activeThreads-inUseThreads); | ||
330 | |||
331 | GetCounter(STPPerformanceCounterType.OverheadThreadsPercentBase).Set(activeThreads-inUseThreads); | ||
332 | GetCounter(STPPerformanceCounterType.OverheadThreadsPercent).Set(inUseThreads); | ||
333 | } | ||
334 | |||
335 | public void SampleWorkItems(long workItemsQueued, long workItemsProcessed) | ||
336 | { | ||
337 | GetCounter(STPPerformanceCounterType.WorkItems).Set(workItemsQueued+workItemsProcessed); | ||
338 | GetCounter(STPPerformanceCounterType.WorkItemsInQueue).Set(workItemsQueued); | ||
339 | GetCounter(STPPerformanceCounterType.WorkItemsProcessed).Set(workItemsProcessed); | ||
340 | |||
341 | GetCounter(STPPerformanceCounterType.WorkItemsQueuedPerSecond).Set(workItemsQueued); | ||
342 | GetCounter(STPPerformanceCounterType.WorkItemsProcessedPerSecond).Set(workItemsProcessed); | ||
343 | } | ||
344 | |||
345 | public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime) | ||
346 | { | ||
347 | GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTime).IncrementBy((long)workItemWaitTime.TotalMilliseconds); | ||
348 | GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTimeBase).Increment(); | ||
349 | } | ||
350 | |||
351 | public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime) | ||
352 | { | ||
353 | GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTime).IncrementBy((long)workItemProcessTime.TotalMilliseconds); | ||
354 | GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTimeBase).Increment(); | ||
355 | } | ||
356 | } | ||
357 | #endif | ||
155 | 358 | ||
156 | internal class STPInstancePerformanceCounter : IDisposable | 359 | internal class NullSTPInstancePerformanceCounters : ISTPInstancePerformanceCounters, ISTPPerformanceCountersReader |
157 | { | 360 | { |
158 | // Fields | 361 | private static readonly NullSTPInstancePerformanceCounters _instance = new NullSTPInstancePerformanceCounters(); |
159 | private PerformanceCounter _pcs; | ||
160 | 362 | ||
161 | // Methods | 363 | public static NullSTPInstancePerformanceCounters Instance |
162 | protected STPInstancePerformanceCounter() | 364 | { |
163 | { | 365 | get { return _instance; } |
164 | } | 366 | } |
165 | 367 | ||
166 | public STPInstancePerformanceCounter( | 368 | public void Close() {} |
167 | string instance, | 369 | public void Dispose() {} |
168 | STPPerformanceCounterType spcType) | 370 | |
371 | public void SampleThreads(long activeThreads, long inUseThreads) {} | ||
372 | public void SampleWorkItems(long workItemsQueued, long workItemsProcessed) {} | ||
373 | public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime) {} | ||
374 | public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime) {} | ||
375 | public long InUseThreads | ||
169 | { | 376 | { |
170 | STPPerformanceCounters counters = STPPerformanceCounters.Instance; | 377 | get { return 0; } |
171 | _pcs = new PerformanceCounter( | ||
172 | STPPerformanceCounters._stpCategoryName, | ||
173 | counters._stpPerformanceCounters[(int) spcType].Name, | ||
174 | instance, | ||
175 | false); | ||
176 | _pcs.RawValue = _pcs.RawValue; | ||
177 | } | 378 | } |
178 | 379 | ||
179 | ~STPInstancePerformanceCounter() | 380 | public long ActiveThreads |
180 | { | 381 | { |
181 | Close(); | 382 | get { return 0; } |
182 | } | 383 | } |
183 | 384 | ||
184 | public void Close() | 385 | public long WorkItemsQueued |
185 | { | ||
186 | if (_pcs != null) | ||
187 | { | ||
188 | _pcs.RemoveInstance(); | ||
189 | _pcs.Close(); | ||
190 | _pcs = null; | ||
191 | } | ||
192 | } | ||
193 | |||
194 | public void Dispose() | ||
195 | { | 386 | { |
196 | Close(); | 387 | get { return 0; } |
197 | GC.SuppressFinalize(this); | ||
198 | } | ||
199 | |||
200 | public virtual void Increment() | ||
201 | { | ||
202 | _pcs.Increment(); | ||
203 | } | ||
204 | |||
205 | public virtual void IncrementBy(long val) | ||
206 | { | ||
207 | _pcs.IncrementBy(val); | ||
208 | } | 388 | } |
209 | 389 | ||
210 | public virtual void Set(long val) | 390 | public long WorkItemsProcessed |
211 | { | 391 | { |
212 | _pcs.RawValue = val; | 392 | get { return 0; } |
213 | } | 393 | } |
214 | } | 394 | } |
215 | 395 | ||
216 | internal class STPInstanceNullPerformanceCounter : STPInstancePerformanceCounter | 396 | internal class LocalSTPInstancePerformanceCounters : ISTPInstancePerformanceCounters, ISTPPerformanceCountersReader |
217 | { | 397 | { |
218 | // Methods | 398 | public void Close() { } |
219 | public STPInstanceNullPerformanceCounter() {} | 399 | public void Dispose() { } |
220 | public override void Increment() {} | ||
221 | public override void IncrementBy(long value) {} | ||
222 | public override void Set(long val) {} | ||
223 | } | ||
224 | |||
225 | internal interface ISTPInstancePerformanceCounters : IDisposable | ||
226 | { | ||
227 | void Close(); | ||
228 | void SampleThreads(long activeThreads, long inUseThreads); | ||
229 | void SampleWorkItems(long workItemsQueued, long workItemsProcessed); | ||
230 | void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime); | ||
231 | void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime); | ||
232 | } | ||
233 | 400 | ||
401 | private long _activeThreads; | ||
402 | private long _inUseThreads; | ||
403 | private long _workItemsQueued; | ||
404 | private long _workItemsProcessed; | ||
234 | 405 | ||
235 | internal class STPInstancePerformanceCounters : ISTPInstancePerformanceCounters, IDisposable | 406 | public long InUseThreads |
236 | { | ||
237 | // Fields | ||
238 | private STPInstancePerformanceCounter[] _pcs; | ||
239 | private static STPInstancePerformanceCounter _stpInstanceNullPerformanceCounter; | ||
240 | |||
241 | // Methods | ||
242 | static STPInstancePerformanceCounters() | ||
243 | { | 407 | { |
244 | _stpInstanceNullPerformanceCounter = new STPInstanceNullPerformanceCounter(); | 408 | get { return _inUseThreads; } |
245 | } | ||
246 | |||
247 | public STPInstancePerformanceCounters(string instance) | ||
248 | { | ||
249 | _pcs = new STPInstancePerformanceCounter[(int)STPPerformanceCounterType.LastCounter]; | ||
250 | // STPPerformanceCounters counters = STPPerformanceCounters.Instance; | ||
251 | for (int i = 0; i < _pcs.Length; i++) | ||
252 | { | ||
253 | if (instance != null) | ||
254 | { | ||
255 | _pcs[i] = new STPInstancePerformanceCounter( | ||
256 | instance, | ||
257 | (STPPerformanceCounterType) i); | ||
258 | } | ||
259 | else | ||
260 | { | ||
261 | _pcs[i] = _stpInstanceNullPerformanceCounter; | ||
262 | } | ||
263 | } | ||
264 | } | 409 | } |
265 | |||
266 | 410 | ||
267 | public void Close() | 411 | public long ActiveThreads |
268 | { | 412 | { |
269 | if (null != _pcs) | 413 | get { return _activeThreads; } |
270 | { | ||
271 | for (int i = 0; i < _pcs.Length; i++) | ||
272 | { | ||
273 | if (null != _pcs[i]) | ||
274 | { | ||
275 | _pcs[i].Close(); | ||
276 | } | ||
277 | } | ||
278 | _pcs = null; | ||
279 | } | ||
280 | } | 414 | } |
281 | 415 | ||
282 | ~STPInstancePerformanceCounters() | 416 | public long WorkItemsQueued |
283 | { | 417 | { |
284 | Close(); | 418 | get { return _workItemsQueued; } |
285 | } | 419 | } |
286 | 420 | ||
287 | public void Dispose() | 421 | public long WorkItemsProcessed |
288 | { | ||
289 | Close(); | ||
290 | GC.SuppressFinalize(this); | ||
291 | } | ||
292 | |||
293 | private STPInstancePerformanceCounter GetCounter(STPPerformanceCounterType spcType) | ||
294 | { | 422 | { |
295 | return _pcs[(int) spcType]; | 423 | get { return _workItemsProcessed; } |
296 | } | 424 | } |
297 | 425 | ||
298 | public void SampleThreads(long activeThreads, long inUseThreads) | 426 | public void SampleThreads(long activeThreads, long inUseThreads) |
299 | { | 427 | { |
300 | GetCounter(STPPerformanceCounterType.ActiveThreads).Set(activeThreads); | 428 | _activeThreads = activeThreads; |
301 | GetCounter(STPPerformanceCounterType.InUseThreads).Set(inUseThreads); | 429 | _inUseThreads = inUseThreads; |
302 | GetCounter(STPPerformanceCounterType.OverheadThreads).Set(activeThreads-inUseThreads); | ||
303 | |||
304 | GetCounter(STPPerformanceCounterType.OverheadThreadsPercentBase).Set(activeThreads-inUseThreads); | ||
305 | GetCounter(STPPerformanceCounterType.OverheadThreadsPercent).Set(inUseThreads); | ||
306 | } | 430 | } |
307 | 431 | ||
308 | public void SampleWorkItems(long workItemsQueued, long workItemsProcessed) | 432 | public void SampleWorkItems(long workItemsQueued, long workItemsProcessed) |
309 | { | 433 | { |
310 | GetCounter(STPPerformanceCounterType.WorkItems).Set(workItemsQueued+workItemsProcessed); | 434 | _workItemsQueued = workItemsQueued; |
311 | GetCounter(STPPerformanceCounterType.WorkItemsInQueue).Set(workItemsQueued); | 435 | _workItemsProcessed = workItemsProcessed; |
312 | GetCounter(STPPerformanceCounterType.WorkItemsProcessed).Set(workItemsProcessed); | ||
313 | |||
314 | GetCounter(STPPerformanceCounterType.WorkItemsQueuedPerSecond).Set(workItemsQueued); | ||
315 | GetCounter(STPPerformanceCounterType.WorkItemsProcessedPerSecond).Set(workItemsProcessed); | ||
316 | } | 436 | } |
317 | 437 | ||
318 | public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime) | 438 | public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime) |
319 | { | 439 | { |
320 | GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTime).IncrementBy((long)workItemWaitTime.TotalMilliseconds); | 440 | // Not supported |
321 | GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTimeBase).Increment(); | ||
322 | } | 441 | } |
323 | 442 | ||
324 | public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime) | 443 | public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime) |
325 | { | 444 | { |
326 | GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTime).IncrementBy((long)workItemProcessTime.TotalMilliseconds); | 445 | // Not supported |
327 | GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTimeBase).Increment(); | ||
328 | } | ||
329 | } | ||
330 | |||
331 | internal class NullSTPInstancePerformanceCounters : ISTPInstancePerformanceCounters, IDisposable | ||
332 | { | ||
333 | static NullSTPInstancePerformanceCounters() | ||
334 | { | ||
335 | } | 446 | } |
336 | |||
337 | private static NullSTPInstancePerformanceCounters _instance = new NullSTPInstancePerformanceCounters(null); | ||
338 | |||
339 | public static NullSTPInstancePerformanceCounters Instance | ||
340 | { | ||
341 | get { return _instance; } | ||
342 | } | ||
343 | |||
344 | public NullSTPInstancePerformanceCounters(string instance) {} | ||
345 | public void Close() {} | ||
346 | public void Dispose() {} | ||
347 | |||
348 | public void SampleThreads(long activeThreads, long inUseThreads) {} | ||
349 | public void SampleWorkItems(long workItemsQueued, long workItemsProcessed) {} | ||
350 | public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime) {} | ||
351 | public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime) {} | ||
352 | } | 447 | } |
353 | |||
354 | } | 448 | } |