private void CountPerformanceEnd
(
HttpActionExecutedContext actionExecutedContext
, string stopwatchKey
, string performanceCountersCategoryNameKey
, string performanceCountersInstanceNameKey
)
{
if (actionExecutedContext.Request.Properties.ContainsKey(stopwatchKey))
{
var stopwatch = actionExecutedContext
.Request
.Properties[stopwatchKey] as Stopwatch;
if (stopwatch != null)
{
var enableCountPerformance = false;
if (OnCheckEnabledCountPerformanceProcessFunc != null)
{
enableCountPerformance = OnCheckEnabledCountPerformanceProcessFunc();
}
if (enableCountPerformance)
{
var performanceCountersCategoryName
= actionExecutedContext
.Request
.Properties[performanceCountersCategoryNameKey] as string;
var performanceCountersInstanceName = actionExecutedContext
.Request
.Properties[performanceCountersInstanceNameKey] as string;
if
(
!string.IsNullOrEmpty(performanceCountersCategoryName)
&&
!string.IsNullOrEmpty(performanceCountersInstanceName)
)
{
EasyPerformanceCountersHelper <CommonPerformanceCountersContainer>
.CountPerformanceEnd
(
EnabledCounters
, performanceCountersCategoryName
, performanceCountersInstanceName
, stopwatch
);
}
}
if (stopwatch != null)
{
stopwatch = null;
}
}
}
}
public static void AttachPerformanceCountersCategoryInstance
(
string performanceCountersCategoryName
, string performanceCountersCategoryInstanceName
)
{
EasyPerformanceCountersHelper <SessionsPerformanceCountersContainer> .AttachPerformanceCountersCategoryInstance
(
performanceCountersCategoryName
, performanceCountersCategoryInstanceName
);
}
public void AttachPerformanceCountersCategoryInstance
(
string performanceCountersCategoryName
, string performanceCountersCategoryInstanceNamePrefix
, MultiPerformanceCountersTypeFlags enablePerformanceCounters = MultiPerformanceCountersTypeFlags.ProcessNonTimeBasedCounters
, PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Process
)
{
if (!_isAttachPerformanceCounters)
{
_isAttachPerformanceCounters = true;
}
else
{
CommonPerformanceCountersContainer container = null;
EasyPerformanceCountersHelper <CommonPerformanceCountersContainer>
.AttachPerformanceCountersCategoryInstance
(
performanceCountersCategoryName
, string.Format
(
"{1}{0}{2}"
, "-"
, "Non-Pooled Objects"
, performanceCountersCategoryInstanceNamePrefix
)
, out container
, PerformanceCounterInstanceLifetime.Process
, initializePerformanceCounterInstanceRawValue : 1009
);
EasyPerformanceCountersHelper <CommonPerformanceCountersContainer>
.AttachPerformanceCountersCategoryInstance
(
performanceCountersCategoryName
, string.Format
(
"{1}{0}{2}"
, "-"
, "Pooled Objects"
, performanceCountersCategoryInstanceNamePrefix
)
, out container
, PerformanceCounterInstanceLifetime.Process
, initializePerformanceCounterInstanceRawValue : 1009
);
}
}
private void CountPerformanceBegin
(
HttpActionContext actionContext
, string performanceCountersCategoryName
, string performanceCountersInstanceName
, string stopwatchKey
)
{
var enableCountPerformance = false;
if (OnCheckEnabledCountPerformanceProcessFunc != null)
{
enableCountPerformance = OnCheckEnabledCountPerformanceProcessFunc();
}
if (enableCountPerformance)
{
Stopwatch stopwatch =
EasyPerformanceCountersHelper <CommonPerformanceCountersContainer>
.CountPerformanceBegin
(
EnabledCounters
, performanceCountersCategoryName
, performanceCountersInstanceName
, () =>
{
return(enableCountPerformance);
}
);
if (stopwatch != null)
{
actionContext
.Request
.Properties[stopwatchKey] = stopwatch;
}
}
}
public static void ParallelTime
(
string name
, int iterations
, Action actionOnce
, int maxDegreeOfParallelism //= 1
, MultiPerformanceCountersTypeFlags enablePerformanceCounters //= false
, string performanceCountersCategoryName
, string performanceCountersCategoryInstanceName
)
{
// 1.
ConsoleColor currentForeColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(name);
// 2.
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
int[] gcCounts = new int[GC.MaxGeneration + 1];
for (int i = 0; i <= GC.MaxGeneration; i++)
{
gcCounts[i] = GC.CollectionCount(i);
}
IntPtr threadID = GetCurrentThreadId();
Stopwatch watch = Stopwatch.StartNew();
ulong cycleCount = GetCurrentThreadCycleCount();
#if NET45
//#endif
Parallel.For
(
0
, iterations
, new ParallelOptions()
{
MaxDegreeOfParallelism = maxDegreeOfParallelism
//, TaskScheduler = null
}
, (x) =>
{
EasyPerformanceCountersHelper <SessionsPerformanceCountersContainer> .CountPerformance
(
enablePerformanceCounters
, performanceCountersCategoryName
, performanceCountersCategoryInstanceName
, null
, actionOnce
, null
, null
, null
);
}
);
//#if NET45
#endif
ulong cpuCycles = GetCurrentThreadCycleCount() - cycleCount;
watch.Stop();
//watch = null;
// 4.
Console.ForegroundColor = currentForeColor;
Console.WriteLine
(
"{0}Time Elapsed:{0}{1}ms"
, "\t"
, watch.ElapsedMilliseconds.ToString("N0")
);
Console.WriteLine
(
"{0}CPU Cycles:{0}{1}"
, "\t"
, cpuCycles.ToString("N0")
);
// 5.
for (int i = 0; i <= GC.MaxGeneration; i++)
{
int count = GC.CollectionCount(i) - gcCounts[i];
Console.WriteLine
(
"{0}Gen{1}:{0}{0}{2}"
, "\t"
, i
, count
);
}
Console.WriteLine();
}
public void AttachPerformanceCountersCategoryInstance
(
string performanceCountersCategoryNamePrefix
, string performanceCountersCategoryInstanceNamePrefix
, Func <bool> onGetEnabledCountPerformanceProcessFunc = null
, PerformanceCounterInstanceLifetime
performanceCounterInstanceLifetime
= PerformanceCounterInstanceLifetime.Process
)
{
var process = Process.GetCurrentProcess();
var processName = process.ProcessName;
var instanceNamePrefix = string
.Format
(
"{0}-{1}"
, processName
, performanceCountersCategoryInstanceNamePrefix
);
instanceNamePrefix = performanceCountersCategoryInstanceNamePrefix;
var suffix = "-Queue";
_performanceCountersCategoryNameForQueueProcess = performanceCountersCategoryNamePrefix + suffix;
_performanceCountersCategoryInstanceNameForQueueProcess = instanceNamePrefix + suffix;
var qpcc = _queuePerformanceCountersContainer;
qpcc
.AttachPerformanceCountersToMembers
(
_performanceCountersCategoryNameForQueueProcess
, _performanceCountersCategoryInstanceNameForQueueProcess
, performanceCounterInstanceLifetime
);
qpcc
.RegisterCountersUsage();
suffix = "-BatchProcess";
_performanceCountersCategoryNameForBatchProcess = performanceCountersCategoryNamePrefix + suffix;
_performanceCountersCategoryInstanceNameForBatchProcess = instanceNamePrefix + suffix;
CommonPerformanceCountersContainer container = null;
EasyPerformanceCountersHelper <CommonPerformanceCountersContainer>
.AttachPerformanceCountersCategoryInstance
(
_performanceCountersCategoryNameForBatchProcess
, _performanceCountersCategoryInstanceNameForBatchProcess
, out container
, performanceCounterInstanceLifetime
);
if (_timerCounters == null)
{
_timerCounters = new WriteableTuple
<
bool
, Stopwatch
, PerformanceCounter
, PerformanceCounter
>[]
{
WriteableTuple
.Create
<
bool
, Stopwatch
, PerformanceCounter
, PerformanceCounter
>
(
false
, null
, _queuePerformanceCountersContainer
.QueuedWaitAverageTimerPerformanceCounter
, _queuePerformanceCountersContainer
.QueuedWaitAverageBasePerformanceCounter
)
, WriteableTuple
.Create
<
bool
, Stopwatch
, PerformanceCounter
, PerformanceCounter
>
(
true
, null
, _queuePerformanceCountersContainer
.DequeueProcessedAverageTimerPerformanceCounter
, _queuePerformanceCountersContainer
.DequeueProcessedAverageBasePerformanceCounter
)
};
}
_isAttachedPerformanceCounters = true;
OnGetEnabledCountPerformanceProcessFunc = onGetEnabledCountPerformanceProcessFunc;
}
private void DequeueProcess
(
Action <long, T> onOnceDequeueProcessAction = null
, int sleepInMilliseconds = 100
, Action <long, List <Tuple <long, T> > > onBatchDequeuesProcessAction = null
, int waitOneBatchTimeOutInMilliseconds = 1000
, int waitOneBatchMaxDequeuedTimes = 100
, Func <Exception, Exception, string, bool> onDequeueProcessCaughtExceptionProcessFunc = null
, Action <bool, Exception, Exception, string> onDequeueProcessFinallyProcessAction = null
, Func <Exception, Exception, string, bool> onDequeuesBatchProcessCaughtExceptionProcessFunc = null
, Action <bool, Exception, Exception, string> onDequeuesBatchProcessFinallyProcessAction = null
)
{
if (_isStartedDequeueProcess)
{
return;
}
List <Tuple <long, T> > list = null;
long i = 0;
Stopwatch stopwatch = null;
if (onBatchDequeuesProcessAction != null)
{
list = new List <Tuple <long, T> >();
stopwatch = new Stopwatch();
stopwatch.Start();
}
while (true)
{
TryCatchFinallyProcessHelper
.TryProcessCatchFinally
(
true
, () =>
{
if (!_queue.IsEmpty)
{
Tuple <Stopwatch, T> element = null;
if (_queue.TryDequeue(out element))
{
var enabledCountPerformance = true;
{
if (OnGetEnabledCountPerformanceProcessFunc != null)
{
enabledCountPerformance = OnGetEnabledCountPerformanceProcessFunc();
}
}
var qpcc = _queuePerformanceCountersContainer;
Stopwatch stopwatchDequeue = null;
var stopwatchEnqueue = element.Item1;
if (enabledCountPerformance)
{
stopwatchDequeue = _stopwatchsPool.Get();
}
_timerCounters[0].Item2 = stopwatchEnqueue;
_timerCounters[1].Item2 = stopwatchDequeue;
#region while queue.IsEmpty loop
var reThrowException = false;
PerformanceCountersHelper
.TryCountPerformance
(
() =>
{
return(enabledCountPerformance);
}
, reThrowException
, qpcc.IncrementCountersBeforeCountPerformanceForDequeue
, qpcc.DecrementCountersBeforeCountPerformanceForDequeue
, _timerCounters
, () => //try
{
if (onOnceDequeueProcessAction != null)
{
var item = element.Item2;
onOnceDequeueProcessAction
(i, item);
}
}
, (x, y, z) => //catch
{
qpcc
.CaughtExceptionsPerformanceCounter
.Increment();
z = "OnDequeueProcessCaughtExceptionProcessFunc\r\n" + z;
if (onDequeueProcessCaughtExceptionProcessFunc != null)
{
reThrowException = onDequeueProcessCaughtExceptionProcessFunc
(
x
, y
, z
);
}
else if (OnCaughtException != null)
{
reThrowException = OnCaughtException(this, x, y, z);
}
return(reThrowException);
}
, onDequeueProcessFinallyProcessAction //finally
, null
, qpcc.IncrementCountersAfterCountPerformanceForDequeue
);
#endregion while queue.IsEmpty loop
//池化
if (stopwatchEnqueue != null)
{
stopwatchEnqueue.Reset();
var r = _stopwatchsPool.Put(stopwatchEnqueue);
if (!r)
{
stopwatchEnqueue.Stop();
stopwatchEnqueue = null;
}
}
if (stopwatchDequeue != null)
{
stopwatchDequeue.Reset();
var r = _stopwatchsPool.Put(stopwatchDequeue);
if (!r)
{
stopwatchDequeue.Stop();
stopwatchDequeue = null;
}
}
if (onBatchDequeuesProcessAction != null)
{
i++;
var item = element.Item2;
var tuple
= Tuple
.Create <long, T>
(
i
, item
);
list.Add(tuple);
}
}
}
else
{
if (sleepInMilliseconds > 0)
{
Thread.Sleep(sleepInMilliseconds);
}
}
if (onBatchDequeuesProcessAction != null)
{
if
(
i >= waitOneBatchMaxDequeuedTimes
||
stopwatch.ElapsedMilliseconds > waitOneBatchTimeOutInMilliseconds
)
{
if (i > 0)
{
if (stopwatch != null)
{
stopwatch.Stop();
}
EasyPerformanceCountersHelper <CommonPerformanceCountersContainer>
.TryCountPerformance
(
PerformanceCounterProcessingFlagsType.All
, _performanceCountersCategoryNameForBatchProcess
, _performanceCountersCategoryInstanceNameForBatchProcess
, () =>
{
return(OnGetEnabledCountPerformanceProcessFunc());
}
, () =>
{
onBatchDequeuesProcessAction
(
i
, list
);
}
, null
, (xx, yy, zz) =>
{
var rrr = false;
zz = "OnDequeueProcessCaughtExceptionProcessFunc\r\n" + zz;
if (onDequeuesBatchProcessCaughtExceptionProcessFunc != null)
{
rrr = onDequeuesBatchProcessCaughtExceptionProcessFunc
(
xx, yy, zz
);
}
else if (OnCaughtException != null)
{
rrr = OnCaughtException(this, xx, yy, zz);
}
return(rrr);
}
, (xx, yy, zz, ww) =>
{
i = 0;
list.Clear();
if (stopwatch != null)
{
stopwatch.Restart();
}
onDequeuesBatchProcessFinallyProcessAction?
.Invoke(xx, yy, zz, ww);
}
);
}
}
}
}
, false
, (x, y, z) =>
{
var rr = false;
if (OnCaughtException != null)
{
rr = OnCaughtException
(
this, x, y, z
);
}
return(rr);
}
);
}
}
private void DequeueProcess <TBatchGroupByKey>
(
Func <long, JToken, bool> onOnceDequeueProcessFunc
, int sleepInMilliseconds = 100
, Func <JToken, TBatchGroupByKey> keySelector = null
, Action <long, bool, TBatchGroupByKey, IEnumerable <JToken> > onBatchDequeuesProcessAction = null
, int waitOneBatchTimeOutInMilliseconds = 1000
, int waitOneBatchMaxDequeuedTimes = 100
, Func <Exception, Exception, string, bool> onDequeueProcessCaughtExceptionProcessFunc = null
, Action <bool, Exception, Exception, string> onDequeueProcessFinallyProcessAction = null
, Func <Exception, Exception, string, bool> onDequeuesBatchProcessCaughtExceptionProcessFunc = null
, Action <bool, Exception, Exception, string> onDequeuesBatchProcessFinallyProcessAction = null
)
{
if (_isStartedDequeueProcess)
{
return;
}
List <JToken> list = null;
var needBatchGroupBy = false;
if (keySelector != null)
{
needBatchGroupBy = true;
}
long i = 0;
Stopwatch stopwatch = null;
if (onBatchDequeuesProcessAction != null)
{
list = new List <JToken>();
stopwatch = new Stopwatch();
stopwatch.Start();
}
while (true)
{
TryCatchFinallyProcessHelper
.TryProcessCatchFinally
(
true
, () =>
{
if (!_queue.IsEmpty)
{
Tuple <Stopwatch, JToken> element = null;
if (_queue.TryDequeue(out element))
{
var enabledCountPerformance = true;
{
if (OnGetEnabledCountPerformanceProcessFunc != null)
{
enabledCountPerformance = OnGetEnabledCountPerformanceProcessFunc();
}
}
var qpcc = _queuePerformanceCountersContainer;
Stopwatch stopwatchDequeue = null;
var stopwatchEnqueue = element.Item1;
if (enabledCountPerformance)
{
_stopwatchsPool.TryGet(out stopwatchDequeue);
}
_timerCounters[0].Item2 = stopwatchEnqueue;
_timerCounters[1].Item2 = stopwatchDequeue;
#region while queue.IsEmpty loop
var reThrowException = false;
JToken item = null;
bool needAdd = false;
PerformanceCountersHelper
.TryCountPerformance
(
() =>
{
return(enabledCountPerformance);
}
, reThrowException
, qpcc.IncrementCountersBeforeCountPerformanceForDequeue
, qpcc.DecrementCountersBeforeCountPerformanceForDequeue
, _timerCounters
, () => //try
{
if (onOnceDequeueProcessFunc != null)
{
item = element.Item2;
needAdd = onOnceDequeueProcessFunc
(i, item);
}
}
, (x, y, z) => //catch
{
qpcc
.CaughtExceptionsPerformanceCounter
.Increment();
z = "OnDequeueProcessCaughtExceptionProcessFunc\r\n" + z;
if (onDequeueProcessCaughtExceptionProcessFunc != null)
{
reThrowException = onDequeueProcessCaughtExceptionProcessFunc
(
x
, y
, z
);
}
else if (OnCaughtException != null)
{
reThrowException = OnCaughtException(this, x, y, z);
}
return(reThrowException);
}
, onDequeueProcessFinallyProcessAction //finally
, null
, qpcc.IncrementCountersAfterCountPerformanceForDequeue
);
#endregion while queue.IsEmpty loop
//池化
if (stopwatchEnqueue != null)
{
stopwatchEnqueue.Reset();
var r = _stopwatchsPool.TryPut(stopwatchEnqueue);
if (!r)
{
stopwatchEnqueue.Stop();
stopwatchEnqueue = null;
}
}
if (stopwatchDequeue != null)
{
stopwatchDequeue.Reset();
var r = _stopwatchsPool.TryPut(stopwatchDequeue);
if (!r)
{
stopwatchDequeue.Stop();
stopwatchDequeue = null;
}
}
if (onBatchDequeuesProcessAction != null)
{
//var item = element.Item2;
if (needAdd)
{
i++;
list.Add(item);
}
}
}
}
else
{
if (sleepInMilliseconds > 0)
{
Thread.Sleep(sleepInMilliseconds);
}
}
if (onBatchDequeuesProcessAction != null)
{
if
(
i >= waitOneBatchMaxDequeuedTimes
||
stopwatch.ElapsedMilliseconds > waitOneBatchTimeOutInMilliseconds
)
{
if (i > 0)
{
if (stopwatch != null)
{
stopwatch.Stop();
}
EasyPerformanceCountersHelper <CommonPerformanceCountersContainer>
.TryCountPerformance
(
PerformanceCounterProcessingFlagsType.All
, _performanceCountersCategoryNameForBatchProcess
, _performanceCountersCategoryInstanceNameForBatchProcess
, () =>
{
return(OnGetEnabledCountPerformanceProcessFunc());
}
, () =>
{
if (needBatchGroupBy)
{
var groups = list
.GroupBy
(
(x) =>
{
return(keySelector(x));
}
);
groups
.AsParallel()
.ForAll
(
(group) =>
{
onBatchDequeuesProcessAction
(
i
, needBatchGroupBy
, group.Key
, group.AsEnumerable()
);
}
);
//foreach (var group in groups)
//{
//}
}
else
{
onBatchDequeuesProcessAction
(
i
, needBatchGroupBy
, default(TBatchGroupByKey)
, list
);
}
}
, null
, (xx, yy, zz) =>
{
var rrr = false;
zz = "OnDequeueProcessCaughtExceptionProcessFunc\r\n" + zz;
if (onDequeuesBatchProcessCaughtExceptionProcessFunc != null)
{
rrr = onDequeuesBatchProcessCaughtExceptionProcessFunc
(
xx, yy, zz
);
}
else if (OnCaughtException != null)
{
rrr = OnCaughtException(this, xx, yy, zz);
}
return(rrr);
}
, (xx, yy, zz, ww) =>
{
i = 0;
list.Clear();
if (stopwatch != null)
{
stopwatch.Restart();
}
onDequeuesBatchProcessFinallyProcessAction?
.Invoke(xx, yy, zz, ww);
}
);
}
}
}
}
, false
, (x, y, z) =>
{
var rr = false;
if (OnCaughtException != null)
{
rr = OnCaughtException
(
this, x, y, z
);
}
return(rr);
}
);
}
}
