public abstract void AttachPerformanceCountersToMembers ( string categoryName , string instanceName , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializePerformanceCounterInstanceRawValue = null );
private static PerformanceCounter CreatePerformanceCounter ( string categoryName , string counterName , string instanceName , PerformanceCounterInstanceLifetime instanceLifetime , long?instanceInitializeRawValue ) { var performanceCounter = new PerformanceCounter() { CategoryName = categoryName , CounterName = counterName , InstanceLifetime = instanceLifetime , InstanceName = instanceName , ReadOnly = false // , //RawValue = 0 }; if (instanceInitializeRawValue != null) { performanceCounter.RawValue = instanceInitializeRawValue.Value; } return(performanceCounter); }
public override void AttachPerformanceCountersToMembers ( string categoryName , string instanceName , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long? initializePerformanceCounterInstanceRawValue = null ) { AttachPerformanceCountersToMembers //<CommonPerformanceCountersContainer> ( categoryName , instanceName , this , performanceCounterInstanceLifetime , initializePerformanceCounterInstanceRawValue ); InitializeProcessingTypedPerformanceCounters //<CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .IncrementOnBegin ); InitializeProcessingTypedPerformanceCounters //<CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .IncrementOnEnd ); InitializeProcessingTypedPerformanceCounters <CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .DecrementOnEnd ); InitializeProcessingTypedPerformanceCounters <CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .TimeBasedOnBeginOnEnd ); InitializeProcessingTypedPerformanceCountersPairs <CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .TimeBasedOnBeginOnEnd ); }
public override void AttachPerformanceCountersToMembers ( string categoryName , string instanceName , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializePerformanceCounterInstanceRawValue = null ) { AttachPerformanceCountersToMembers //<CommonPerformanceCountersContainer> ( categoryName , instanceName , this , performanceCounterInstanceLifetime , initializePerformanceCounterInstanceRawValue ); InitializeProcessingTypedPerformanceCounters //<CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .IncrementOnBegin ); InitializeProcessingTypedPerformanceCounters //<CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .IncrementOnEnd ); InitializeProcessingTypedPerformanceCounters <CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .DecrementOnEnd ); InitializeProcessingTypedPerformanceCounters <CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .TimeBasedOnBeginOnEnd ); InitializeProcessingTypedPerformanceCountersPairs <CommonPerformanceCountersContainer> ( this , PerformanceCounterProcessingFlagsType .TimeBasedOnBeginOnEnd ); }
/// <summary> /// Initializes the performance counter component /// </summary> /// <param name="id">Unique identifier for a performance counter</param> /// <param name="categoryName">The category of performance counter</param> /// <param name="counterName">Name of the performance counter</param> /// <param name="instanceName">Performance counter instance</param> /// <param name="machineName"> The computer on which the performance counter and its associated category exists</param> /// <param name="counterLifeTime">Specifies the life time of performance counter instance</param> internal Counter(int id, string categoryName, string counterName, string instanceName, string machineName, PerformanceCounterInstanceLifetime counterLifeTime) { this.performanceCounter = new PerformanceCounter() { CategoryName = categoryName, CounterName = counterName, InstanceName = instanceName, InstanceLifetime = counterLifeTime, MachineName = machineName, ReadOnly = false }; this.ID = id; }
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 ); } }
protected void AttachPerformanceCountersToMembers <TContainer> ( string categoryName , string instanceName , TContainer container , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializePerformanceCounterInstanceRawValue = null ) { PerformanceCountersHelper .AttachPerformanceCountersToMembers <TContainer> ( categoryName , instanceName , container , performanceCounterInstanceLifetime , initializePerformanceCounterInstanceRawValue ); }
/// <summary> /// Create a Performance counter install attribute to assist in run-time perfmon counter creation /// </summary> /// <param name="type">This counters internal type. Needed base types are automagically created with the name appended with 'base'</param> /// <param name="category">This counters category. All categories are fixed at the time of creation</param> /// <param name="lifetime">This counters lifetime, by default all counters are global except for dynamically created instances</param> /// <param name="categoryType">The category type (multi or single instance)</param> /// <param name="ConnectInstancetype">The CSGO instance type </param> /// <param name="counterName">This counters name</param> /// <param name="counterHelp">This counters help string</param> public PerformanceCounterInstallAttribute( PerformanceCounterType type, PerformanceCounterCategories category, PerformanceCounterInstanceLifetime lifetime, PerformanceCounterCategoryType categoryType, CounterInstanceType counterInstancetype, string counterName, string counterHelp, string instanceType) { _type = type; _category = category; _lifeTime = lifetime; _categoryType = categoryType; _counterInstanceType = counterInstancetype; _counterName = counterName; _counterHelp = counterHelp; _instanceType = instanceType; }
public static void AttachPerformanceCountersCategoryInstance ( string performanceCountersCategoryName , string performanceCountersCategoryInstanceName , out TPerformanceCountersContainer container , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializePerformanceCounterInstanceRawValue = null ) { string key = string.Format ( "{1}{0}{2}" , "-" , performanceCountersCategoryName , performanceCountersCategoryInstanceName ); //TPerformanceCountersContainer container = null; if (!_dictionary.TryGetValue(key, out container)) { lock (_lockerObject) { container = new TPerformanceCountersContainer(); //default(TPerformanceCountersContainer); _dictionary .Add ( key , container ); container .AttachPerformanceCountersToMembers ( performanceCountersCategoryName , performanceCountersCategoryInstanceName , performanceCounterInstanceLifetime , initializePerformanceCounterInstanceRawValue ); } } }
internal unsafe SharedPerformanceCounter(string catName, string counterName, string instanceName, PerformanceCounterInstanceLifetime lifetime) { this.InitialOffset = 4; this.thisInstanceOffset = -1; this.categoryName = catName; this.categoryNameHashCode = GetWstrHashCode(this.categoryName); this.categoryData = this.GetCategoryData(); if (this.categoryData.UseUniqueSharedMemory) { if ((instanceName != null) && (instanceName.Length > 0x7f)) { throw new InvalidOperationException(SR.GetString("InstanceNameTooLong")); } } else if (lifetime != PerformanceCounterInstanceLifetime.Global) { throw new InvalidOperationException(SR.GetString("ProcessLifetimeNotValidInGlobal")); } if (((counterName != null) && (instanceName != null)) && this.categoryData.CounterNames.Contains(counterName)) { this.counterEntryPointer = this.GetCounter(counterName, instanceName, this.categoryData.EnableReuse, lifetime); } }
public override void AttachPerformanceCountersToMembers ( string categoryName , string instanceName , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializePerformanceCounterInstanceRawValue = null ) { if (!_isAttachedPerformanceCounters) { //var type = this.GetType(); AttachPerformanceCountersToMembers <QueuePerformanceCountersContainer> ( categoryName , instanceName , this , performanceCounterInstanceLifetime , initializePerformanceCounterInstanceRawValue ); } _isAttachedPerformanceCounters = true; }
public void AttachPerformanceCounters ( string categoryName , string instanceNamePrefix , QueuePerformanceCountersContainer performanceCounters , Func <bool> onEnabledCountPerformanceProcessFunc = null , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializePerformanceCounterInstanceRawValue = null ) { var process = Process.GetCurrentProcess(); var processName = process.ProcessName; var instanceName = string .Format ( "{0}-{1}" , instanceNamePrefix , processName ); PerformanceCountersContainer = performanceCounters; PerformanceCountersContainer .AttachPerformanceCountersToMembers ( categoryName , instanceName , performanceCounterInstanceLifetime , initializePerformanceCounterInstanceRawValue ); PerformanceCountersContainer .RegisterCountersUsage(); _isAttachedPerformanceCounters = true; _onEnabledCountPerformanceProcessFunc = onEnabledCountPerformanceProcessFunc; }
/// <summary> /// In this method we instantiate the PerformanceCounter object and return it. /// </summary> /// <param name="categoryName">Category name</param> /// <param name="counterName">Counter name</param> /// <param name="instanceName">Counter instance name</param> /// <param name="instanceLifeTime">The life time of this instance</param> /// <param name="readOnly">Is counter for read only?</param> /// <returns>Performance counter</returns> public static PerformanceCounter getCounter( string categoryName, string counterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifeTime, bool readOnly ) { PerformanceCounter counter = null; // Check if the category exists if (PerformanceCounterCategory.Exists(categoryName)) { counter = new PerformanceCounter( categoryName, counterName, instanceName, readOnly ); } return(counter); }
static internal PerformanceCounter GetPerformanceCounterInternal(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { PerformanceCounter counter = null; try { counter = new PerformanceCounter(); counter.CategoryName = categoryName; counter.CounterName = perfCounterName; counter.InstanceName = instanceName; counter.ReadOnly = false; counter.InstanceLifetime = instanceLifetime; // We now need to access the counter raw data to // force the counter object to be initialized. This // will force any exceptions due to mis-installation // of counters to occur here and be traced appropriately. try { long rawValue = counter.RawValue; } catch (InvalidOperationException) { counter = null; throw; } catch (SecurityException securityException) { // Cannot access performance counter due to partial trust scenarios // Disable the default performance counters' access otherwise // in PT the service will be broken PerformanceCounters.scope = PerformanceCounterScope.Off; DiagnosticUtility.TraceHandledException(new SecurityException(SR.GetString( SR.PartialTrustPerformanceCountersNotEnabled), securityException), TraceEventType.Warning); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new SecurityException(SR.GetString( SR.PartialTrustPerformanceCountersNotEnabled))); } } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (null != counter) { if (!counter.ReadOnly) { try { counter.RemoveInstance(); } // Already inside a catch block for a failure case // ok to ---- any exceptions here and trace the // original failure. #pragma warning suppress 56500 // covered by FxCOP catch (Exception e1) { if (Fx.IsFatal(e1)) { throw; } } } counter = null; } bool logEvent = true; if (categoryName == PerformanceCounterStrings.SERVICEMODELSERVICE.ServicePerfCounters) { if (serviceOOM == false) { serviceOOM = true; } else { logEvent = false; } } else if (categoryName == PerformanceCounterStrings.SERVICEMODELOPERATION.OperationPerfCounters) { if (operationOOM == false) { operationOOM = true; } else { logEvent = false; } } else if (categoryName == PerformanceCounterStrings.SERVICEMODELENDPOINT.EndpointPerfCounters) { if (endpointOOM == false) { endpointOOM = true; } else { logEvent = false; } } if (logEvent) { DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error, (ushort)System.Runtime.Diagnostics.EventLogCategory.PerformanceCounter, (uint)System.Runtime.Diagnostics.EventLogEventId.FailedToLoadPerformanceCounter, categoryName, perfCounterName, e.ToString()); } } return(counter); }
static internal PerformanceCounter GetPerformanceCounter(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { PerformanceCounter counter = null; if (PerformanceCounters.PerformanceCountersEnabled || PerformanceCounters.MinimalPerformanceCountersEnabled) { counter = PerformanceCounters.GetPerformanceCounterInternal(categoryName, perfCounterName, instanceName, instanceLifetime); } return counter; }
static PerformanceCounter GetListenerPerformanceCounter(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { return(PerformanceCounters.GetPerformanceCounterInternal(categoryName, perfCounterName, instanceName, instanceLifetime)); }
private unsafe static void PopulateLifetimeEntry(ProcessLifetimeEntry *lifetimeEntry, PerformanceCounterInstanceLifetime lifetime) { if (lifetime == PerformanceCounterInstanceLifetime.Process) { lifetimeEntry->LifetimeType = (int) PerformanceCounterInstanceLifetime.Process; lifetimeEntry->ProcessId = ProcessData.ProcessId; lifetimeEntry->StartupTime = ProcessData.StartupTime; } else { lifetimeEntry->ProcessId = 0; lifetimeEntry->StartupTime = 0; } }
private unsafe bool FindInstance(int instanceNameHashCode, string instanceName, CategoryEntry* categoryPointer, InstanceEntry** returnInstancePointerReference, bool activateUnusedInstances, PerformanceCounterInstanceLifetime lifetime, out bool foundFreeInstance) { InstanceEntry* currentInstancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, InstanceEntrySize)); InstanceEntry* previousInstancePointer = currentInstancePointer; foundFreeInstance = false; // Look at the first instance to determine if this is single or multi instance. if (currentInstancePointer->InstanceNameHashCode == SingleInstanceHashCode) { if (StringEquals(SingleInstanceName, currentInstancePointer->InstanceNameOffset)){ if (instanceName != SingleInstanceName) throw new InvalidOperationException(SR.GetString(SR.SingleInstanceOnly, categoryName)); } else { if (instanceName == SingleInstanceName) throw new InvalidOperationException(SR.GetString(SR.MultiInstanceOnly, categoryName)); } } else { if (instanceName == SingleInstanceName) throw new InvalidOperationException(SR.GetString(SR.MultiInstanceOnly, categoryName)); } // // 1st pass find exact matching! // // We don't need to aggressively claim unused instances. For performance, we would proactively // verify lifetime of instances if activateUnusedInstances is specified and certain time // has elapsed since last sweep or we are running out of shared memory. bool verifyLifeTime = activateUnusedInstances; if (activateUnusedInstances) { int totalSize = InstanceEntrySize + ProcessLifetimeEntrySize + InstanceNameSlotSize + (CounterEntrySize * categoryData.CounterNames.Count); int freeMemoryOffset = *((int *) baseAddress); int alignmentAdjustment; int newOffset = CalculateMemoryNoBoundsCheck(freeMemoryOffset, totalSize, out alignmentAdjustment); if (!(newOffset > FileView.FileMappingSize || newOffset < 0)) { long tickDelta = (DateTime.Now.Ticks - Volatile.Read(ref LastInstanceLifetimeSweepTick)); if (tickDelta < InstanceLifetimeSweepWindow) verifyLifeTime = false; } } new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert(); try { for(;;) { bool verifiedLifetimeOfThisInstance = false; if (verifyLifeTime && (currentInstancePointer->RefCount != 0)) { verifiedLifetimeOfThisInstance = true; VerifyLifetime(currentInstancePointer); } if (currentInstancePointer->InstanceNameHashCode == instanceNameHashCode) { if (StringEquals(instanceName, currentInstancePointer->InstanceNameOffset)){ // we found a matching instance. *returnInstancePointerReference = currentInstancePointer; CounterEntry* firstCounter = (CounterEntry*) ResolveOffset(currentInstancePointer->FirstCounterOffset, CounterEntrySize); ProcessLifetimeEntry* lifetimeEntry; if (categoryData.UseUniqueSharedMemory) lifetimeEntry = (ProcessLifetimeEntry*) ResolveOffset(firstCounter->LifetimeOffset, ProcessLifetimeEntrySize); else lifetimeEntry = null; // ensure that we have verified the lifetime of the matched instance if (!verifiedLifetimeOfThisInstance && currentInstancePointer->RefCount != 0) VerifyLifetime(currentInstancePointer); if (currentInstancePointer->RefCount != 0) { if (lifetimeEntry != null && lifetimeEntry->ProcessId != 0) { if (lifetime != PerformanceCounterInstanceLifetime.Process) throw new InvalidOperationException(SR.GetString(SR.CantConvertProcessToGlobal)); // make sure only one process is using this instance. if (ProcessData.ProcessId != lifetimeEntry->ProcessId) throw new InvalidOperationException(SR.GetString(SR.InstanceAlreadyExists, instanceName)); // compare start time of the process, account for ACL issues in querying process information if ((lifetimeEntry->StartupTime != -1) && (ProcessData.StartupTime != -1)) { if (ProcessData.StartupTime != lifetimeEntry->StartupTime) throw new InvalidOperationException(SR.GetString(SR.InstanceAlreadyExists, instanceName)); } } else { if (lifetime == PerformanceCounterInstanceLifetime.Process) throw new InvalidOperationException(SR.GetString(SR.CantConvertGlobalToProcess)); } return true; } if (activateUnusedInstances) { Mutex mutex = null; RuntimeHelpers.PrepareConstrainedRegions(); try { SharedUtils.EnterMutexWithoutGlobal(categoryData.MutexName, ref mutex); ClearCounterValues(currentInstancePointer); if (lifetimeEntry != null) PopulateLifetimeEntry(lifetimeEntry, lifetime); currentInstancePointer->RefCount = 1; return true; } finally { if (mutex != null) { mutex.ReleaseMutex(); mutex.Close(); } } } else return false; } } if (currentInstancePointer->RefCount == 0) { foundFreeInstance = true; } previousInstancePointer = currentInstancePointer; if (currentInstancePointer->NextInstanceOffset != 0) currentInstancePointer = (InstanceEntry*)(ResolveOffset(currentInstancePointer->NextInstanceOffset, InstanceEntrySize)); else { *returnInstancePointerReference = previousInstancePointer; return false; } } } finally { SecurityPermission.RevertAssert(); if (verifyLifeTime) Volatile.Write(ref LastInstanceLifetimeSweepTick, DateTime.Now.Ticks); } }
private unsafe CounterEntry* GetCounter(string counterName, string instanceName, bool enableReuse, PerformanceCounterInstanceLifetime lifetime) { int singleInstanceHashCode; CounterEntry* entryPtr5; int wstrHashCode = GetWstrHashCode(counterName); if ((instanceName != null) && (instanceName.Length != 0)) { singleInstanceHashCode = GetWstrHashCode(instanceName); } else { singleInstanceHashCode = SingleInstanceHashCode; instanceName = "systemdiagnosticssharedsingleinstance"; } Mutex mutex = null; CounterEntry* returnCounterPointerReference = null; InstanceEntry* instancePointer = null; RuntimeHelpers.PrepareConstrainedRegions(); try { CategoryEntry* entryPtr3; bool flag2; bool flag5; SharedUtils.EnterMutexWithoutGlobal(this.categoryData.MutexName, ref mutex); while (!this.FindCategory(&entryPtr3)) { bool flag; if (this.categoryData.UseUniqueSharedMemory) { flag = true; } else { WaitAndEnterCriticalSection(&entryPtr3->SpinLock, out flag); } if (flag) { int num3; try { num3 = this.CreateCategory(entryPtr3, singleInstanceHashCode, instanceName, lifetime); } finally { if (!this.categoryData.UseUniqueSharedMemory) { ExitCriticalSection(&entryPtr3->SpinLock); } } entryPtr3 = (CategoryEntry*) this.ResolveOffset(num3, CategoryEntrySize); instancePointer = (InstanceEntry*) this.ResolveOffset(entryPtr3->FirstInstanceOffset, InstanceEntrySize); this.FindCounter(wstrHashCode, counterName, instancePointer, &returnCounterPointerReference); return returnCounterPointerReference; } } while (!this.FindInstance(singleInstanceHashCode, instanceName, entryPtr3, &instancePointer, true, lifetime, out flag2)) { bool flag3; InstanceEntry* lockInstancePointer = instancePointer; if (this.categoryData.UseUniqueSharedMemory) { flag3 = true; } else { WaitAndEnterCriticalSection(&lockInstancePointer->SpinLock, out flag3); } if (flag3) { try { bool flag4 = false; if (enableReuse && flag2) { flag4 = this.TryReuseInstance(singleInstanceHashCode, instanceName, entryPtr3, &instancePointer, lifetime, lockInstancePointer); } if (!flag4) { int offset = this.CreateInstance(entryPtr3, singleInstanceHashCode, instanceName, lifetime); instancePointer = (InstanceEntry*) this.ResolveOffset(offset, InstanceEntrySize); this.FindCounter(wstrHashCode, counterName, instancePointer, &returnCounterPointerReference); return returnCounterPointerReference; } continue; } finally { if (!this.categoryData.UseUniqueSharedMemory) { ExitCriticalSection(&lockInstancePointer->SpinLock); } } } } if (!this.categoryData.UseUniqueSharedMemory) { goto Label_01FC; } this.FindCounter(wstrHashCode, counterName, instancePointer, &returnCounterPointerReference); return returnCounterPointerReference; Label_01C0: WaitAndEnterCriticalSection(&returnCounterPointerReference->SpinLock, out flag5); if (flag5) { try { int num5 = this.CreateCounter(returnCounterPointerReference, wstrHashCode, counterName); return (CounterEntry*) this.ResolveOffset(num5, CounterEntrySize); } finally { ExitCriticalSection(&returnCounterPointerReference->SpinLock); } } Label_01FC: if (!this.FindCounter(wstrHashCode, counterName, instancePointer, &returnCounterPointerReference)) { goto Label_01C0; } entryPtr5 = returnCounterPointerReference; } finally { try { if ((returnCounterPointerReference != null) && (instancePointer != null)) { this.thisInstanceOffset = this.ResolveAddress((long) ((ulong) instancePointer), InstanceEntrySize); } } catch (InvalidOperationException) { this.thisInstanceOffset = -1; } if (mutex != null) { mutex.ReleaseMutex(); mutex.Close(); } } return entryPtr5; }
private unsafe int CreateCategory(CategoryEntry* lastCategoryPointer, int instanceNameHashCode, string instanceName, PerformanceCounterInstanceLifetime lifetime) { int categoryNameLength; int instanceNameLength; int alignmentAdjustment; int freeMemoryOffset; int newOffset = 0; int totalSize; categoryNameLength = (categoryName.Length + 1) * 2; totalSize = CategoryEntrySize + InstanceEntrySize + (CounterEntrySize * categoryData.CounterNames.Count) + categoryNameLength; for (int i=0; i<categoryData.CounterNames.Count; i++) { totalSize += (((string)categoryData.CounterNames[i]).Length + 1) * 2; } if (categoryData.UseUniqueSharedMemory) { instanceNameLength = InstanceNameSlotSize; totalSize += ProcessLifetimeEntrySize + instanceNameLength; // If we're in a separate shared memory, we need to do a two stage update of the free memory pointer. // First we calculate our alignment adjustment and where the new free offset is. Then we // write the new structs and data. The last two operations are to link the new structs into the // existing ones and update the next free offset. Our process could get killed in between those two, // leaving the memory in an inconsistent state. We use the "IsConsistent" flag to help determine // when that has happened. freeMemoryOffset = *((int *) baseAddress); newOffset = CalculateMemory(freeMemoryOffset, totalSize, out alignmentAdjustment); if (freeMemoryOffset == InitialOffset) lastCategoryPointer->IsConsistent = 0; } else { instanceNameLength = (instanceName.Length +1) * 2; totalSize += instanceNameLength; freeMemoryOffset = CalculateAndAllocateMemory(totalSize, out alignmentAdjustment); } long nextPtr = ResolveOffset(freeMemoryOffset, totalSize + alignmentAdjustment); CategoryEntry* newCategoryEntryPointer; InstanceEntry* newInstanceEntryPointer; // We need to decide where to put the padding returned in alignmentAdjustment. There are several things that // need to be aligned. First, we need to align each struct on a 4 byte boundary so we can use interlocked // operations on the int Spinlock field. Second, we need to align the CounterEntry on an 8 byte boundary so that // on 64 bit platforms we can use interlocked operations on the Value field. alignmentAdjustment guarantees 8 byte // alignemnt, so we use that for both. If we're creating the very first category, however, we can't move that // CategoryEntry. In this case we put the alignmentAdjustment before the InstanceEntry. if (freeMemoryOffset == InitialOffset) { newCategoryEntryPointer = (CategoryEntry*) nextPtr; nextPtr += CategoryEntrySize + alignmentAdjustment; newInstanceEntryPointer = (InstanceEntry*) nextPtr; } else { nextPtr += alignmentAdjustment; newCategoryEntryPointer = (CategoryEntry*) nextPtr; nextPtr += CategoryEntrySize; newInstanceEntryPointer = (InstanceEntry*) nextPtr; } nextPtr += InstanceEntrySize; // create the first CounterEntry and reserve space for all of the rest. We won't // finish creating them until the end CounterEntry* newCounterEntryPointer = (CounterEntry*) nextPtr; nextPtr += CounterEntrySize * categoryData.CounterNames.Count; if (categoryData.UseUniqueSharedMemory) { ProcessLifetimeEntry* newLifetimeEntry = (ProcessLifetimeEntry*) nextPtr; nextPtr += ProcessLifetimeEntrySize; newCounterEntryPointer->LifetimeOffset = (int)((long)newLifetimeEntry - baseAddress); PopulateLifetimeEntry(newLifetimeEntry, lifetime); } newCategoryEntryPointer->CategoryNameHashCode = categoryNameHashCode; newCategoryEntryPointer->NextCategoryOffset = 0; newCategoryEntryPointer->FirstInstanceOffset = (int)((long)newInstanceEntryPointer - baseAddress); newCategoryEntryPointer->CategoryNameOffset = (int) (nextPtr - baseAddress); SafeMarshalCopy(categoryName, (IntPtr)nextPtr); nextPtr += categoryNameLength; newInstanceEntryPointer->InstanceNameHashCode = instanceNameHashCode; newInstanceEntryPointer->NextInstanceOffset = 0; newInstanceEntryPointer->FirstCounterOffset = (int)((long)newCounterEntryPointer - baseAddress); newInstanceEntryPointer->RefCount = 1; newInstanceEntryPointer->InstanceNameOffset = (int) (nextPtr - baseAddress); SafeMarshalCopy(instanceName, (IntPtr)nextPtr); nextPtr += instanceNameLength; string counterName = (string) categoryData.CounterNames[0]; newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName); SetValue(newCounterEntryPointer, 0); newCounterEntryPointer->CounterNameOffset = (int) (nextPtr - baseAddress); SafeMarshalCopy(counterName, (IntPtr)nextPtr); nextPtr += (counterName.Length + 1) * 2; CounterEntry* previousCounterEntryPointer; for (int i=1; i<categoryData.CounterNames.Count; i++) { previousCounterEntryPointer = newCounterEntryPointer; counterName = (string) categoryData.CounterNames[i]; newCounterEntryPointer++; newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName); SetValue(newCounterEntryPointer, 0); newCounterEntryPointer->CounterNameOffset = (int) (nextPtr - baseAddress); SafeMarshalCopy(counterName, (IntPtr)nextPtr); nextPtr += (counterName.Length + 1) * 2; previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - baseAddress); } Debug.Assert(nextPtr - baseAddress == freeMemoryOffset + totalSize + alignmentAdjustment, "We should have used all of the space we requested at this point"); int offset = (int) ((long) newCategoryEntryPointer - baseAddress); lastCategoryPointer->IsConsistent = 0; // If not the first category node, link it. if (offset != InitialOffset) lastCategoryPointer->NextCategoryOffset = offset; if (categoryData.UseUniqueSharedMemory) { *((int*) baseAddress) = newOffset; lastCategoryPointer->IsConsistent = 1; } return offset; }
private unsafe bool FindInstance(int instanceNameHashCode, string instanceName, CategoryEntry* categoryPointer, InstanceEntry** returnInstancePointerReference, bool activateUnusedInstances, PerformanceCounterInstanceLifetime lifetime, out bool foundFreeInstance) { bool flag3; InstanceEntry* currentInstancePointer = (InstanceEntry*) this.ResolveOffset(categoryPointer.FirstInstanceOffset, InstanceEntrySize); InstanceEntry* entryPtr2 = currentInstancePointer; foundFreeInstance = false; if (currentInstancePointer->InstanceNameHashCode == SingleInstanceHashCode) { if (!this.StringEquals("systemdiagnosticssharedsingleinstance", currentInstancePointer->InstanceNameOffset)) { if (instanceName == "systemdiagnosticssharedsingleinstance") { throw new InvalidOperationException(SR.GetString("MultiInstanceOnly", new object[] { this.categoryName })); } } else if (instanceName != "systemdiagnosticssharedsingleinstance") { throw new InvalidOperationException(SR.GetString("SingleInstanceOnly", new object[] { this.categoryName })); } } else if (instanceName == "systemdiagnosticssharedsingleinstance") { throw new InvalidOperationException(SR.GetString("MultiInstanceOnly", new object[] { this.categoryName })); } bool flag = activateUnusedInstances; if (activateUnusedInstances) { int num3; int totalSize = ((InstanceEntrySize + ProcessLifetimeEntrySize) + 0x100) + (CounterEntrySize * this.categoryData.CounterNames.Count); int oldOffset = *((int*) this.baseAddress); int num4 = this.CalculateMemoryNoBoundsCheck(oldOffset, totalSize, out num3); if ((num4 <= this.FileView.FileMappingSize) && (num4 >= 0)) { long num5 = DateTime.Now.Ticks - LastInstanceLifetimeSweepTick; if (num5 < InstanceLifetimeSweepWindow) { flag = false; } } } new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert(); try { bool flag2; Label_0156: flag2 = false; if (flag && (currentInstancePointer->RefCount != 0)) { flag2 = true; this.VerifyLifetime(currentInstancePointer); } if ((currentInstancePointer->InstanceNameHashCode == instanceNameHashCode) && this.StringEquals(instanceName, currentInstancePointer->InstanceNameOffset)) { ProcessLifetimeEntry* entryPtr4; *((IntPtr*) returnInstancePointerReference) = currentInstancePointer; CounterEntry* entryPtr3 = (CounterEntry*) this.ResolveOffset(currentInstancePointer->FirstCounterOffset, CounterEntrySize); if (this.categoryData.UseUniqueSharedMemory) { entryPtr4 = (ProcessLifetimeEntry*) this.ResolveOffset(entryPtr3->LifetimeOffset, ProcessLifetimeEntrySize); } else { entryPtr4 = null; } if (!flag2 && (currentInstancePointer->RefCount != 0)) { this.VerifyLifetime(currentInstancePointer); } if (currentInstancePointer->RefCount != 0) { if ((entryPtr4 != null) && (entryPtr4->ProcessId != 0)) { if (lifetime != PerformanceCounterInstanceLifetime.Process) { throw new InvalidOperationException(SR.GetString("CantConvertProcessToGlobal")); } if (ProcessData.ProcessId != entryPtr4->ProcessId) { throw new InvalidOperationException(SR.GetString("InstanceAlreadyExists", new object[] { instanceName })); } if (((entryPtr4->StartupTime != -1L) && (ProcessData.StartupTime != -1L)) && (ProcessData.StartupTime != entryPtr4->StartupTime)) { throw new InvalidOperationException(SR.GetString("InstanceAlreadyExists", new object[] { instanceName })); } } else if (lifetime == PerformanceCounterInstanceLifetime.Process) { throw new InvalidOperationException(SR.GetString("CantConvertGlobalToProcess")); } return true; } if (activateUnusedInstances) { Mutex mutex = null; RuntimeHelpers.PrepareConstrainedRegions(); try { SharedUtils.EnterMutexWithoutGlobal(this.categoryData.MutexName, ref mutex); this.ClearCounterValues(currentInstancePointer); if (entryPtr4 != null) { PopulateLifetimeEntry(entryPtr4, lifetime); } currentInstancePointer->RefCount = 1; return true; } finally { if (mutex != null) { mutex.ReleaseMutex(); mutex.Close(); } } } return false; } if (currentInstancePointer->RefCount == 0) { foundFreeInstance = true; } entryPtr2 = currentInstancePointer; if (currentInstancePointer->NextInstanceOffset != 0) { currentInstancePointer = (InstanceEntry*) this.ResolveOffset(currentInstancePointer->NextInstanceOffset, InstanceEntrySize); goto Label_0156; } *((IntPtr*) returnInstancePointerReference) = entryPtr2; flag3 = false; } finally { CodeAccessPermission.RevertAssert(); if (flag) { LastInstanceLifetimeSweepTick = DateTime.Now.Ticks; } } return flag3; }
public static void AttachPerformanceCountersToMembers <T> ( string categoryName , string instanceName , T target //= default(T) , PerformanceCounterInstanceLifetime instanceLifetime = PerformanceCounterInstanceLifetime.Global , long?instanceInitializeRawValue = null ) { var type = typeof(T); var members = type .GetMembersByMemberType <PerformanceCounter>() .Concat ( type .GetMembersByMemberType <PerformanceCountersPair>() ); //.GetProperties() //.Where // ( // (pi) => // { // var parameters = pi.GetIndexParameters(); // return // ( // ( // pi.PropertyType == typeof(PerformanceCounter) // || // pi.PropertyType == typeof(PerformanceCountersPair) // ) // && (parameters == null ? 0 : parameters.Length) <= 0 // ); // } // ); if (!PerformanceCounterCategory.Exists(categoryName)) { var ccdc = new CounterCreationDataCollection(); foreach (var memberInfo in members) { var memberName = memberInfo.Name; var performanceCounterType = PerformanceCounterType .NumberOfItems64; var performanceCounterName = memberName; var attribute = memberInfo .GetCustomAttribute <PerformanceCounterDefinitionAttribute> (); if (attribute != null) { var counterName = attribute.CounterName; if (!string.IsNullOrEmpty(counterName)) { performanceCounterName = counterName; } var counterType = attribute.CounterType; //if (counterType != null) { performanceCounterType = counterType; } } var ccd = GetCounterCreationData ( performanceCounterName , performanceCounterType ); ccdc.Add(ccd); Type memberType = null; if (memberInfo is FieldInfo) { var fieldInfo = memberInfo as FieldInfo; memberType = fieldInfo.FieldType; } else if (memberInfo is PropertyInfo) { var propertyInfo = memberInfo as PropertyInfo; memberType = propertyInfo.PropertyType; } if (memberType == typeof(PerformanceCountersPair)) { performanceCounterName = string.Format("{0}.(Base)", performanceCounterName); var counterName = attribute.BaseCounterName; if (!string.IsNullOrEmpty(counterName)) { performanceCounterName = counterName; } var counterType = attribute.BaseCounterType; //if (counterType != null) { performanceCounterType = counterType; } ccd = GetCounterCreationData ( performanceCounterName , performanceCounterType ); ccdc.Add(ccd); } } PerformanceCounterCategory .Create ( categoryName , string .Format ( "{0} Category Help." , categoryName ) , PerformanceCounterCategoryType .MultiInstance , ccdc ); } foreach (var memberInfo in members) { //PerformanceCounter performanceCounter = null; var memberName = memberInfo.Name; var performanceCounterType = PerformanceCounterType .NumberOfItems64; var performanceCounterName = memberName; //var performanceCounterInstanceLifetime = defaultPerformanceCounterInstanceLifetime; long?performanceCounterInstanceInitializeRawValue = instanceInitializeRawValue; var attribute = memberInfo .GetCustomAttribute <PerformanceCounterDefinitionAttribute> (); if (attribute != null) { var counterName = attribute.CounterName; if (!string.IsNullOrEmpty(counterName)) { performanceCounterName = counterName; } var counterType = attribute.CounterType; //if (counterType != null) { performanceCounterType = counterType; } var counterInstanceLifetime = attribute.CounterInstanceLifetime; if ( counterInstanceLifetime != null && counterInstanceLifetime.HasValue ) { instanceLifetime = counterInstanceLifetime.Value; } var counterInstanceInitializeRawValue = attribute.CounterInstanceInitializeRawValue; if ( counterInstanceInitializeRawValue != null && counterInstanceInitializeRawValue.HasValue ) { performanceCounterInstanceInitializeRawValue = counterInstanceInitializeRawValue.Value; } } var performanceCounter = CreatePerformanceCounter ( categoryName , performanceCounterName , instanceName , instanceLifetime , performanceCounterInstanceInitializeRawValue ); Type memberType = null; if (memberInfo is FieldInfo) { var fieldInfo = memberInfo as FieldInfo; memberType = fieldInfo.FieldType; } else if (memberInfo is PropertyInfo) { var propertyInfo = memberInfo as PropertyInfo; memberType = propertyInfo.PropertyType; } if (memberType == typeof(PerformanceCounter)) { SetMemberValueToTarget(target, memberInfo, performanceCounter); } else if (memberType == typeof(PerformanceCountersPair)) { performanceCounterName = string.Format("{0}.(Base)", performanceCounterName); var baseCounterName = attribute.BaseCounterName; if (!string.IsNullOrEmpty(baseCounterName)) { performanceCounterName = baseCounterName; } var baseCounterType = attribute.BaseCounterType; { performanceCounterType = baseCounterType; } var basePerformanceCounter = CreatePerformanceCounter ( categoryName , performanceCounterName , instanceName , instanceLifetime , performanceCounterInstanceInitializeRawValue ); var performanceCountersPair = new PerformanceCountersPair() { Counter = performanceCounter , BaseCounter = basePerformanceCounter }; SetMemberValueToTarget ( target , memberInfo , performanceCountersPair ); } } }
private unsafe int CreateInstance(CategoryEntry* categoryPointer, int instanceNameHashCode, string instanceName, PerformanceCounterInstanceLifetime lifetime) { int num; int num3; int num4; int totalSize = InstanceEntrySize + (CounterEntrySize * this.categoryData.CounterNames.Count); int num5 = 0; if (this.categoryData.UseUniqueSharedMemory) { num = 0x100; totalSize += ProcessLifetimeEntrySize + num; num4 = *((int*) this.baseAddress); num5 = this.CalculateMemory(num4, totalSize, out num3); } else { num = (instanceName.Length + 1) * 2; totalSize += num; for (int i = 0; i < this.categoryData.CounterNames.Count; i++) { totalSize += (((string) this.categoryData.CounterNames[i]).Length + 1) * 2; } num4 = this.CalculateAndAllocateMemory(totalSize, out num3); } num4 += num3; long num7 = this.ResolveOffset(num4, totalSize); InstanceEntry* entryPtr = (InstanceEntry*) num7; num7 += InstanceEntrySize; CounterEntry* counterEntry = (CounterEntry*) num7; num7 += CounterEntrySize * this.categoryData.CounterNames.Count; if (this.categoryData.UseUniqueSharedMemory) { ProcessLifetimeEntry* lifetimeEntry = (ProcessLifetimeEntry*) num7; num7 += ProcessLifetimeEntrySize; counterEntry->LifetimeOffset = (int) (((ulong) lifetimeEntry) - this.baseAddress); PopulateLifetimeEntry(lifetimeEntry, lifetime); } entryPtr->InstanceNameHashCode = instanceNameHashCode; entryPtr->NextInstanceOffset = 0; entryPtr->FirstCounterOffset = (int) (((ulong) counterEntry) - this.baseAddress); entryPtr->RefCount = 1; entryPtr->InstanceNameOffset = (int) (num7 - this.baseAddress); SafeMarshalCopy(instanceName, (IntPtr) num7); num7 += num; if (this.categoryData.UseUniqueSharedMemory) { InstanceEntry* entryPtr4 = (InstanceEntry*) this.ResolveOffset(categoryPointer.FirstInstanceOffset, InstanceEntrySize); CounterEntry* entryPtr5 = (CounterEntry*) this.ResolveOffset(entryPtr4->FirstCounterOffset, CounterEntrySize); counterEntry->CounterNameHashCode = entryPtr5->CounterNameHashCode; SetValue(counterEntry, 0L); counterEntry->CounterNameOffset = entryPtr5->CounterNameOffset; for (int j = 1; j < this.categoryData.CounterNames.Count; j++) { CounterEntry* entryPtr6 = counterEntry; counterEntry++; entryPtr5 = (CounterEntry*) this.ResolveOffset(entryPtr5->NextCounterOffset, CounterEntrySize); counterEntry->CounterNameHashCode = entryPtr5->CounterNameHashCode; SetValue(counterEntry, 0L); counterEntry->CounterNameOffset = entryPtr5->CounterNameOffset; entryPtr6->NextCounterOffset = (int) (((ulong) counterEntry) - this.baseAddress); } } else { CounterEntry* entryPtr7 = null; for (int k = 0; k < this.categoryData.CounterNames.Count; k++) { string wstr = (string) this.categoryData.CounterNames[k]; counterEntry->CounterNameHashCode = GetWstrHashCode(wstr); counterEntry->CounterNameOffset = (int) (num7 - this.baseAddress); SafeMarshalCopy(wstr, (IntPtr) num7); num7 += (wstr.Length + 1) * 2; SetValue(counterEntry, 0L); if (k != 0) { entryPtr7->NextCounterOffset = (int) (((ulong) counterEntry) - this.baseAddress); } entryPtr7 = counterEntry; counterEntry++; } } int num10 = (int) (((ulong) entryPtr) - this.baseAddress); categoryPointer.IsConsistent = 0; entryPtr->NextInstanceOffset = categoryPointer.FirstInstanceOffset; categoryPointer.FirstInstanceOffset = num10; if (this.categoryData.UseUniqueSharedMemory) { this.baseAddress[0] = num5; categoryPointer.IsConsistent = 1; } return num4; }
private unsafe int CreateCategory(CategoryEntry* lastCategoryPointer, int instanceNameHashCode, string instanceName, PerformanceCounterInstanceLifetime lifetime) { int num2; int num3; int num4; CategoryEntry* entryPtr; InstanceEntry* entryPtr2; int num5 = 0; int num = (this.categoryName.Length + 1) * 2; int totalSize = ((CategoryEntrySize + InstanceEntrySize) + (CounterEntrySize * this.categoryData.CounterNames.Count)) + num; for (int i = 0; i < this.categoryData.CounterNames.Count; i++) { totalSize += (((string) this.categoryData.CounterNames[i]).Length + 1) * 2; } if (this.categoryData.UseUniqueSharedMemory) { num2 = 0x100; totalSize += ProcessLifetimeEntrySize + num2; num4 = *((int*) this.baseAddress); num5 = this.CalculateMemory(num4, totalSize, out num3); if (num4 == this.InitialOffset) { lastCategoryPointer.IsConsistent = 0; } } else { num2 = (instanceName.Length + 1) * 2; totalSize += num2; num4 = this.CalculateAndAllocateMemory(totalSize, out num3); } long num8 = this.ResolveOffset(num4, totalSize + num3); if (num4 == this.InitialOffset) { entryPtr = (CategoryEntry*) num8; num8 += CategoryEntrySize + num3; entryPtr2 = (InstanceEntry*) num8; } else { num8 += num3; entryPtr = (CategoryEntry*) num8; num8 += CategoryEntrySize; entryPtr2 = (InstanceEntry*) num8; } num8 += InstanceEntrySize; CounterEntry* counterEntry = (CounterEntry*) num8; num8 += CounterEntrySize * this.categoryData.CounterNames.Count; if (this.categoryData.UseUniqueSharedMemory) { ProcessLifetimeEntry* lifetimeEntry = (ProcessLifetimeEntry*) num8; num8 += ProcessLifetimeEntrySize; counterEntry->LifetimeOffset = (int) (((ulong) lifetimeEntry) - this.baseAddress); PopulateLifetimeEntry(lifetimeEntry, lifetime); } entryPtr->CategoryNameHashCode = this.categoryNameHashCode; entryPtr->NextCategoryOffset = 0; entryPtr->FirstInstanceOffset = (int) (((ulong) entryPtr2) - this.baseAddress); entryPtr->CategoryNameOffset = (int) (num8 - this.baseAddress); SafeMarshalCopy(this.categoryName, (IntPtr) num8); num8 += num; entryPtr2->InstanceNameHashCode = instanceNameHashCode; entryPtr2->NextInstanceOffset = 0; entryPtr2->FirstCounterOffset = (int) (((ulong) counterEntry) - this.baseAddress); entryPtr2->RefCount = 1; entryPtr2->InstanceNameOffset = (int) (num8 - this.baseAddress); SafeMarshalCopy(instanceName, (IntPtr) num8); num8 += num2; string wstr = (string) this.categoryData.CounterNames[0]; counterEntry->CounterNameHashCode = GetWstrHashCode(wstr); SetValue(counterEntry, 0L); counterEntry->CounterNameOffset = (int) (num8 - this.baseAddress); SafeMarshalCopy(wstr, (IntPtr) num8); num8 += (wstr.Length + 1) * 2; for (int j = 1; j < this.categoryData.CounterNames.Count; j++) { CounterEntry* entryPtr5 = counterEntry; wstr = (string) this.categoryData.CounterNames[j]; counterEntry++; counterEntry->CounterNameHashCode = GetWstrHashCode(wstr); SetValue(counterEntry, 0L); counterEntry->CounterNameOffset = (int) (num8 - this.baseAddress); SafeMarshalCopy(wstr, (IntPtr) num8); num8 += (wstr.Length + 1) * 2; entryPtr5->NextCounterOffset = (int) (((ulong) counterEntry) - this.baseAddress); } int num10 = (int) (((ulong) entryPtr) - this.baseAddress); lastCategoryPointer.IsConsistent = 0; if (num10 != this.InitialOffset) { lastCategoryPointer.NextCategoryOffset = num10; } if (this.categoryData.UseUniqueSharedMemory) { this.baseAddress[0] = num5; lastCategoryPointer.IsConsistent = 1; } return num10; }
private unsafe bool TryReuseInstance(int instanceNameHashCode, string instanceName, CategoryEntry* categoryPointer, InstanceEntry** returnInstancePointerReference, PerformanceCounterInstanceLifetime lifetime, InstanceEntry* lockInstancePointer) { InstanceEntry* entryPtr = (InstanceEntry*) this.ResolveOffset(categoryPointer.FirstInstanceOffset, InstanceEntrySize); InstanceEntry* entryPtr2 = entryPtr; Label_0015: if (entryPtr->RefCount == 0) { bool flag; long num; if (this.categoryData.UseUniqueSharedMemory) { num = this.ResolveOffset(entryPtr->InstanceNameOffset, 0x100); flag = true; } else { num = this.ResolveOffset(entryPtr->InstanceNameOffset, 0); flag = this.GetStringLength((char*) num) == instanceName.Length; } bool flag2 = (lockInstancePointer == entryPtr) || this.categoryData.UseUniqueSharedMemory; if (flag) { bool flag3; if (flag2) { flag3 = true; } else { WaitAndEnterCriticalSection(&entryPtr->SpinLock, out flag3); } if (flag3) { try { SafeMarshalCopy(instanceName, (IntPtr) num); entryPtr->InstanceNameHashCode = instanceNameHashCode; *((IntPtr*) returnInstancePointerReference) = entryPtr; this.ClearCounterValues(returnInstancePointerReference[0]); if (this.categoryData.UseUniqueSharedMemory) { CounterEntry* entryPtr3 = (CounterEntry*) this.ResolveOffset(entryPtr->FirstCounterOffset, CounterEntrySize); ProcessLifetimeEntry* lifetimeEntry = (ProcessLifetimeEntry*) this.ResolveOffset(entryPtr3->LifetimeOffset, ProcessLifetimeEntrySize); PopulateLifetimeEntry(lifetimeEntry, lifetime); } *(((IntPtr*) returnInstancePointerReference)).RefCount = 1; return true; } finally { if (!flag2) { ExitCriticalSection(&entryPtr->SpinLock); } } } } } entryPtr2 = entryPtr; if (entryPtr->NextInstanceOffset != 0) { entryPtr = (InstanceEntry*) this.ResolveOffset(entryPtr->NextInstanceOffset, InstanceEntrySize); goto Label_0015; } *((IntPtr*) returnInstancePointerReference) = entryPtr2; return false; }
private static unsafe void PopulateLifetimeEntry(ProcessLifetimeEntry* lifetimeEntry, PerformanceCounterInstanceLifetime lifetime) { if (lifetime == PerformanceCounterInstanceLifetime.Process) { lifetimeEntry.LifetimeType = 1; lifetimeEntry.ProcessId = ProcessData.ProcessId; lifetimeEntry.StartupTime = ProcessData.StartupTime; } else { lifetimeEntry.ProcessId = 0; lifetimeEntry.StartupTime = 0L; } }
public static void TryCountPerformance ( PerformanceCounterProcessingFlagsType enabledProcessingFlagsType , string categoryName , string instanceName , Func <bool> onGetEnableCountProcessFunc = null , Action onCountPerformanceInnerProcessAction = null , Func <PerformanceCounterProcessingFlagsType, PerformanceCounter, long> onPerformanceCounterChangeValueProcessFunc = null , Func <Exception, Exception, string, bool> onCaughtExceptionProcessFunc = null , Action <bool, Exception, Exception, string> onFinallyProcessAction = null , PerformanceCounterInstanceLifetime instanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializeInstanceRawValue = null ) { var enabledCountPerformance = true; Stopwatch[] stopwatches = null; var container = CountPerformanceBegin ( enabledProcessingFlagsType , categoryName , instanceName , out enabledCountPerformance , out stopwatches , onGetEnableCountProcessFunc , onPerformanceCounterChangeValueProcessFunc , instanceLifetime , initializeInstanceRawValue ); var reThrowException = false; #region Count Inner TryCatchFinally TryCatchFinallyProcessHelper .TryProcessCatchFinally ( true , () => { onCountPerformanceInnerProcessAction(); } , reThrowException , (x, y, z) => { container .CaughtExceptionsPerformanceCounter .Increment(); var r = reThrowException; if (onCaughtExceptionProcessFunc != null) { r = onCaughtExceptionProcessFunc ( x , y , z ); } return(r); } , (x, y, z, w) => { if (onFinallyProcessAction != null) { onFinallyProcessAction ( x , y , z , w ); } } ); #endregion if (enabledCountPerformance) { CountPerformanceEnd ( enabledProcessingFlagsType , categoryName , instanceName , stopwatches , onPerformanceCounterChangeValueProcessFunc ); } }
internal unsafe void RemoveInstance(string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { if ((instanceName != null) && (instanceName.Length != 0)) { CategoryEntry* entryPtr; int wstrHashCode = GetWstrHashCode(instanceName); if (this.FindCategory(&entryPtr)) { InstanceEntry* returnInstancePointerReference = null; bool flag = false; Mutex mutex = null; RuntimeHelpers.PrepareConstrainedRegions(); try { bool flag2; SharedUtils.EnterMutexWithoutGlobal(this.categoryData.MutexName, ref mutex); if (this.thisInstanceOffset != -1) { try { returnInstancePointerReference = (InstanceEntry*) this.ResolveOffset(this.thisInstanceOffset, InstanceEntrySize); if ((returnInstancePointerReference->InstanceNameHashCode == wstrHashCode) && this.StringEquals(instanceName, returnInstancePointerReference->InstanceNameOffset)) { flag = true; CounterEntry* entryPtr3 = (CounterEntry*) this.ResolveOffset(returnInstancePointerReference->FirstCounterOffset, CounterEntrySize); if (this.categoryData.UseUniqueSharedMemory) { ProcessLifetimeEntry* entryPtr4 = (ProcessLifetimeEntry*) this.ResolveOffset(entryPtr3->LifetimeOffset, ProcessLifetimeEntrySize); if (((entryPtr4 != null) && (entryPtr4->LifetimeType == 1)) && (entryPtr4->ProcessId != 0)) { flag &= instanceLifetime == PerformanceCounterInstanceLifetime.Process; flag &= ProcessData.ProcessId == entryPtr4->ProcessId; if ((entryPtr4->StartupTime != -1L) && (ProcessData.StartupTime != -1L)) { flag &= ProcessData.StartupTime == entryPtr4->StartupTime; } } else { flag &= instanceLifetime != PerformanceCounterInstanceLifetime.Process; } } } } catch (InvalidOperationException) { flag = false; } if (!flag) { this.thisInstanceOffset = -1; } } if ((flag || this.FindInstance(wstrHashCode, instanceName, entryPtr, &returnInstancePointerReference, false, instanceLifetime, out flag2)) && (returnInstancePointerReference != null)) { this.RemoveOneInstance(returnInstancePointerReference, false); } } finally { if (mutex != null) { mutex.ReleaseMutex(); mutex.Close(); } } } } }
private unsafe int CreateInstance(CategoryEntry* categoryPointer, int instanceNameHashCode, string instanceName, PerformanceCounterInstanceLifetime lifetime) { int instanceNameLength; int totalSize = InstanceEntrySize + (CounterEntrySize * categoryData.CounterNames.Count); int alignmentAdjustment; int freeMemoryOffset; int newOffset = 0; if (categoryData.UseUniqueSharedMemory) { instanceNameLength = InstanceNameSlotSize; totalSize += ProcessLifetimeEntrySize + instanceNameLength; // If we're in a separate shared memory, we need to do a two stage update of the free memory pointer. // First we calculate our alignment adjustment and where the new free offset is. Then we // write the new structs and data. The last two operations are to link the new structs into the // existing ones and update the next free offset. Our process could get killed in between those two, // leaving the memory in an inconsistent state. We use the "IsConsistent" flag to help determine // when that has happened. freeMemoryOffset = *((int *) baseAddress); newOffset = CalculateMemory(freeMemoryOffset, totalSize, out alignmentAdjustment); } else { instanceNameLength = (instanceName.Length +1) * 2; totalSize += instanceNameLength; // add in the counter names for the global shared mem. for (int i=0; i<categoryData.CounterNames.Count; i++) { totalSize += (((string)categoryData.CounterNames[i]).Length + 1) * 2; } freeMemoryOffset = CalculateAndAllocateMemory(totalSize, out alignmentAdjustment); } freeMemoryOffset += alignmentAdjustment; long nextPtr = ResolveOffset(freeMemoryOffset, totalSize); // don't add alignmentAdjustment since it's already // been added to freeMemoryOffset InstanceEntry* newInstanceEntryPointer = (InstanceEntry*) nextPtr; nextPtr += InstanceEntrySize; // create the first CounterEntry and reserve space for all of the rest. We won't // finish creating them until the end CounterEntry* newCounterEntryPointer = (CounterEntry*) nextPtr; nextPtr += CounterEntrySize * categoryData.CounterNames.Count; if (categoryData.UseUniqueSharedMemory) { ProcessLifetimeEntry* newLifetimeEntry = (ProcessLifetimeEntry*) nextPtr; nextPtr += ProcessLifetimeEntrySize; newCounterEntryPointer->LifetimeOffset = (int)((long)newLifetimeEntry - baseAddress); PopulateLifetimeEntry(newLifetimeEntry, lifetime); } // set up the InstanceEntry newInstanceEntryPointer->InstanceNameHashCode = instanceNameHashCode; newInstanceEntryPointer->NextInstanceOffset = 0; newInstanceEntryPointer->FirstCounterOffset = (int)((long)newCounterEntryPointer - baseAddress); newInstanceEntryPointer->RefCount = 1; newInstanceEntryPointer->InstanceNameOffset = (int) (nextPtr - baseAddress); SafeMarshalCopy(instanceName, (IntPtr)nextPtr); nextPtr += instanceNameLength; if (categoryData.UseUniqueSharedMemory) { // in the unique shared mem we'll assume that the CounterEntries of the first instance // are all created. Then we can just refer to the old counter name rather than copying in a new one. InstanceEntry* firstInstanceInCategoryPointer = (InstanceEntry*) ResolveOffset(categoryPointer->FirstInstanceOffset, InstanceEntrySize); CounterEntry* firstCounterInCategoryPointer = (CounterEntry*) ResolveOffset(firstInstanceInCategoryPointer->FirstCounterOffset, CounterEntrySize); newCounterEntryPointer->CounterNameHashCode = firstCounterInCategoryPointer->CounterNameHashCode; SetValue(newCounterEntryPointer, 0); newCounterEntryPointer->CounterNameOffset = firstCounterInCategoryPointer->CounterNameOffset; // now create the rest of the CounterEntrys CounterEntry* previousCounterEntryPointer; for (int i=1; i<categoryData.CounterNames.Count; i++) { previousCounterEntryPointer = newCounterEntryPointer; newCounterEntryPointer++; Debug.Assert(firstCounterInCategoryPointer->NextCounterOffset != 0, "The unique shared memory should have all of its counters created by the time we hit CreateInstance"); firstCounterInCategoryPointer = (CounterEntry*) ResolveOffset(firstCounterInCategoryPointer->NextCounterOffset, CounterEntrySize); newCounterEntryPointer->CounterNameHashCode = firstCounterInCategoryPointer->CounterNameHashCode; SetValue(newCounterEntryPointer, 0); newCounterEntryPointer->CounterNameOffset = firstCounterInCategoryPointer->CounterNameOffset; previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - baseAddress); } } else { // now create the rest of the CounterEntrys CounterEntry* previousCounterEntryPointer = null; for (int i=0; i<categoryData.CounterNames.Count; i++) { string counterName = (string) categoryData.CounterNames[i]; newCounterEntryPointer->CounterNameHashCode = GetWstrHashCode(counterName); newCounterEntryPointer->CounterNameOffset = (int) (nextPtr - baseAddress); SafeMarshalCopy(counterName, (IntPtr)nextPtr); nextPtr += (counterName.Length + 1) * 2; SetValue(newCounterEntryPointer, 0); if (i != 0) previousCounterEntryPointer->NextCounterOffset = (int)((long)newCounterEntryPointer - baseAddress); previousCounterEntryPointer = newCounterEntryPointer; newCounterEntryPointer++; } } Debug.Assert(nextPtr - baseAddress == freeMemoryOffset + totalSize, "We should have used all of the space we requested at this point"); int offset = (int) ((long) newInstanceEntryPointer - baseAddress); categoryPointer->IsConsistent = 0; // prepend the new instance rather than append, helps with perf of hooking up subsequent counters newInstanceEntryPointer->NextInstanceOffset = categoryPointer->FirstInstanceOffset; categoryPointer->FirstInstanceOffset = offset; if (categoryData.UseUniqueSharedMemory) { *((int*) baseAddress) = newOffset; categoryPointer->IsConsistent = 1; } return freeMemoryOffset; }
internal static PerformanceCounter GetPerformanceCounterInternal(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { PerformanceCounter counter = null; try { counter = new PerformanceCounter { CategoryName = categoryName, CounterName = perfCounterName, InstanceName = instanceName, ReadOnly = false, InstanceLifetime = instanceLifetime }; try { long rawValue = counter.RawValue; } catch (InvalidOperationException) { counter = null; throw; } catch (SecurityException exception) { if (MinimalPerformanceCountersEnabled) { scope = PerformanceCounterScope.Off; } if (DiagnosticUtility.ShouldTraceWarning) { DiagnosticUtility.ExceptionUtility.TraceHandledException(new SecurityException(System.ServiceModel.SR.GetString("PartialTrustPerformanceCountersNotEnabled"), exception), TraceEventType.Warning); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityException(System.ServiceModel.SR.GetString("PartialTrustPerformanceCountersNotEnabled"))); } } catch (Exception exception2) { if (Fx.IsFatal(exception2)) { throw; } if (counter != null) { if (!counter.ReadOnly) { try { counter.RemoveInstance(); } catch (Exception exception3) { if (Fx.IsFatal(exception3)) { throw; } } } counter = null; } bool flag = true; if (categoryName == "ServiceModelService 4.0.0.0") { if (!serviceOOM) { serviceOOM = true; } else { flag = false; } } else if (categoryName == "ServiceModelOperation 4.0.0.0") { if (!operationOOM) { operationOOM = true; } else { flag = false; } } else if (categoryName == "ServiceModelEndpoint 4.0.0.0") { if (!endpointOOM) { endpointOOM = true; } else { flag = false; } } if (flag) { DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error, EventLogCategory.PerformanceCounter, (EventLogEventId)(-1073610742), new string[] { categoryName, perfCounterName, exception2.ToString() }); } } return(counter); }
private unsafe CounterEntry* GetCounter(string counterName, string instanceName, bool enableReuse, PerformanceCounterInstanceLifetime lifetime) { int counterNameHashCode = GetWstrHashCode(counterName); int instanceNameHashCode; if (instanceName != null && instanceName.Length != 0) instanceNameHashCode = GetWstrHashCode(instanceName); else { instanceNameHashCode = SingleInstanceHashCode; instanceName = SingleInstanceName; } Mutex mutex = null; CounterEntry* counterPointer = null; InstanceEntry* instancePointer = null; RuntimeHelpers.PrepareConstrainedRegions(); try { SharedUtils.EnterMutexWithoutGlobal(categoryData.MutexName, ref mutex); CategoryEntry* categoryPointer; bool counterFound = false; while (!FindCategory(&categoryPointer)) { // don't bother locking again if we're using a separate shared memory. bool sectionEntered; if (categoryData.UseUniqueSharedMemory) sectionEntered = true; else WaitAndEnterCriticalSection(&(categoryPointer->SpinLock), out sectionEntered); int newCategoryOffset; if (sectionEntered) { try { newCategoryOffset = CreateCategory(categoryPointer, instanceNameHashCode, instanceName, lifetime); } finally { if (!categoryData.UseUniqueSharedMemory) ExitCriticalSection(&(categoryPointer->SpinLock)); } categoryPointer = (CategoryEntry*)(ResolveOffset(newCategoryOffset, CategoryEntrySize)); instancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, InstanceEntrySize)); counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer); Debug.Assert(counterFound, "All counters should be created, so we should always find the counter"); return counterPointer; } } bool foundFreeInstance; while (!FindInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, true, lifetime, out foundFreeInstance)) { InstanceEntry* lockInstancePointer = instancePointer; // don't bother locking again if we're using a separate shared memory. bool sectionEntered; if (categoryData.UseUniqueSharedMemory) sectionEntered = true; else WaitAndEnterCriticalSection(&(lockInstancePointer->SpinLock), out sectionEntered); if (sectionEntered) { try { bool reused = false; if (enableReuse && foundFreeInstance) { reused = TryReuseInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, lifetime, lockInstancePointer); // at this point we might have reused an instance that came from v1.1/v1.0. We can't assume it will have the counter // we're looking for. } if (!reused) { int newInstanceOffset = CreateInstance(categoryPointer, instanceNameHashCode, instanceName, lifetime); instancePointer = (InstanceEntry*)(ResolveOffset(newInstanceOffset, InstanceEntrySize)); counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer); Debug.Assert(counterFound, "All counters should be created, so we should always find the counter"); return counterPointer; } } finally { if (!categoryData.UseUniqueSharedMemory) ExitCriticalSection(&(lockInstancePointer->SpinLock)); } } } if (categoryData.UseUniqueSharedMemory) { counterFound = FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer); Debug.Assert(counterFound, "All counters should be created, so we should always find the counter"); return counterPointer; } else { while (!FindCounter(counterNameHashCode, counterName, instancePointer, &counterPointer)) { bool sectionEntered; WaitAndEnterCriticalSection(&(counterPointer->SpinLock), out sectionEntered); if (sectionEntered) { try { int newCounterOffset = CreateCounter(counterPointer, counterNameHashCode, counterName); return (CounterEntry*) (ResolveOffset(newCounterOffset, CounterEntrySize)); } finally { ExitCriticalSection(&(counterPointer->SpinLock)); } } } return counterPointer; } } finally { // cache this instance for reuse try { if (counterPointer != null && instancePointer != null) { this.thisInstanceOffset = ResolveAddress((long)instancePointer, InstanceEntrySize); } } catch (InvalidOperationException) { this.thisInstanceOffset = -1; } if (mutex != null) { mutex.ReleaseMutex(); mutex.Close(); } } }
internal static PerformanceCounter GetPerformanceCounter(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { PerformanceCounter counter = null; if (!PerformanceCountersEnabled && !MinimalPerformanceCountersEnabled) { return(counter); } return(GetPerformanceCounterInternal(categoryName, perfCounterName, instanceName, instanceLifetime)); }
internal unsafe SharedPerformanceCounter(string catName, string counterName, string instanceName, PerformanceCounterInstanceLifetime lifetime) { this.categoryName = catName; this.categoryNameHashCode = GetWstrHashCode(categoryName); categoryData = GetCategoryData(); // Check that the instance name isn't too long if we're using the new shared memory. // We allocate InstanceNameSlotSize bytes in the shared memory if (categoryData.UseUniqueSharedMemory) { if (instanceName != null && instanceName.Length > InstanceNameMaxLength) throw new InvalidOperationException(SR.GetString(SR.InstanceNameTooLong)); } else { if (lifetime != PerformanceCounterInstanceLifetime.Global) throw new InvalidOperationException(SR.GetString(SR.ProcessLifetimeNotValidInGlobal)); } if (counterName != null && instanceName != null) { if (!categoryData.CounterNames.Contains(counterName)) Debug.Assert(false, "Counter " + counterName + " does not exist in category " + catName); else this.counterEntryPointer = GetCounter(counterName, instanceName, categoryData.EnableReuse, lifetime); } }
/// <summary> /// In this method we instantiate the PerformanceCounter object and return it. /// </summary> /// <param name="categoryName">Category name</param> /// <param name="counterName">Counter name</param> /// <param name="instanceName">Counter instance name</param> /// <param name="instanceLifeTime">The life time of this instance</param> /// <param name="readOnly">Is counter for read only?</param> /// <returns>Performance counter</returns> public static PerformanceCounter getCounter( string categoryName, string counterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifeTime, bool readOnly ) { PerformanceCounter counter = null; // Check if the category exists if (PerformanceCounterCategory.Exists(categoryName)) { counter = new PerformanceCounter( categoryName, counterName, instanceName, readOnly ); } return counter; }
static internal PerformanceCounter GetPerformanceCounterInternal(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { PerformanceCounter counter = null; try { counter = new PerformanceCounter(); counter.CategoryName = categoryName; counter.CounterName = perfCounterName; counter.InstanceName = instanceName; counter.ReadOnly = false; counter.InstanceLifetime = instanceLifetime; // We now need to access the counter raw data to // force the counter object to be initialized. This // will force any exceptions due to mis-installation // of counters to occur here and be traced appropriately. try { long rawValue = counter.RawValue; } catch (InvalidOperationException) { counter = null; throw; } catch (SecurityException securityException) { // Cannot access performance counter due to partial trust scenarios // Disable the default performance counters' access otherwise // in PT the service will be broken PerformanceCounters.scope = PerformanceCounterScope.Off; DiagnosticUtility.TraceHandledException(new SecurityException(SR.GetString( SR.PartialTrustPerformanceCountersNotEnabled), securityException), TraceEventType.Warning); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new SecurityException(SR.GetString( SR.PartialTrustPerformanceCountersNotEnabled))); } } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (null != counter) { if (!counter.ReadOnly) { try { counter.RemoveInstance(); } // Already inside a catch block for a failure case // ok to ---- any exceptions here and trace the // original failure. #pragma warning suppress 56500 // covered by FxCOP catch (Exception e1) { if (Fx.IsFatal(e1)) { throw; } } } counter = null; } bool logEvent = true; if (categoryName == PerformanceCounterStrings.SERVICEMODELSERVICE.ServicePerfCounters) { if (serviceOOM == false) { serviceOOM = true; } else { logEvent = false; } } else if (categoryName == PerformanceCounterStrings.SERVICEMODELOPERATION.OperationPerfCounters) { if (operationOOM == false) { operationOOM = true; } else { logEvent = false; } } else if (categoryName == PerformanceCounterStrings.SERVICEMODELENDPOINT.EndpointPerfCounters) { if (endpointOOM == false) { endpointOOM = true; } else { logEvent = false; } } if (logEvent) { DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error, (ushort)System.Runtime.Diagnostics.EventLogCategory.PerformanceCounter, (uint)System.Runtime.Diagnostics.EventLogEventId.FailedToLoadPerformanceCounter, categoryName, perfCounterName, e.ToString()); } } return counter; }
static PerformanceCounter GetListenerPerformanceCounter(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { return PerformanceCounters.GetPerformanceCounterInternal(categoryName, perfCounterName, instanceName, instanceLifetime); }
public ChoPerformanceCounter(string categoryName, string counterName, PerformanceCounterType counterType, string instanceName, string machineName, bool readOnly, PerformanceCounterInstanceLifetime instanceLifetime) { if (instanceName == ChoPerformanceCounter.DefaultInstanceName) { _performanceCounter = new PerformanceCounter(categoryName, counterName); _performanceCounter.MachineName = machineName; } else { _performanceCounter = new PerformanceCounter(categoryName, counterName, instanceName, machineName); } _performanceCounter.ReadOnly = readOnly; _performanceCounter.InstanceLifetime = instanceLifetime; // create base counter if needed switch (counterType) { case PerformanceCounterType.AverageCount64: case PerformanceCounterType.AverageTimer32: case PerformanceCounterType.RawFraction: case PerformanceCounterType.CounterMultiTimer: case PerformanceCounterType.CounterMultiTimerInverse: case PerformanceCounterType.CounterMultiTimer100Ns: case PerformanceCounterType.CounterMultiTimer100NsInverse: case PerformanceCounterType.SampleCounter: case PerformanceCounterType.SampleFraction: { if (instanceName == ChoPerformanceCounter.DefaultInstanceName) { _performanceCounterBase = new PerformanceCounter(categoryName, ChoPerformanceCounter.GetBaseCounterName(counterName)); _performanceCounterBase.MachineName = machineName; } else { _performanceCounterBase = new PerformanceCounter(categoryName, ChoPerformanceCounter.GetBaseCounterName(counterName), instanceName, machineName); } _performanceCounterBase.ReadOnly = ReadOnly; _performanceCounterBase.InstanceLifetime = instanceLifetime; break; } default: break; } _metaDataInfo = new ChoPCMetaDataInfo(CounterName, instanceName) { TurnOn = true }; ChoPCMetaDataManager.Me.SetWatcher(this); }
public static Stopwatch CountPerformanceBegin ( MultiPerformanceCountersTypeFlags enabledPerformanceCounters , string performanceCountersCategoryName , string performanceCountersCategoryInstanceName , Func <bool> onEnabledCountPerformanceProcessFunc = null , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializePerformanceCounterInstanceRawValue = null ) { Stopwatch r = null; var enabledCountPerformance = true; { if (onEnabledCountPerformanceProcessFunc != null) { enabledCountPerformance = onEnabledCountPerformanceProcessFunc.Invoke(); } } if ( enabledCountPerformance && enabledPerformanceCounters != MultiPerformanceCountersTypeFlags.None ) { string key = string .Format ( "{1}{0}{2}" , "-" , performanceCountersCategoryName , performanceCountersCategoryInstanceName ); TPerformanceCountersContainer container = null; if (!_dictionary.TryGetValue(key, out container)) { lock (_lockerObject) { container = new TPerformanceCountersContainer(); _dictionary.Add ( key , container ); container .AttachPerformanceCountersToMembers ( performanceCountersCategoryName , performanceCountersCategoryInstanceName , performanceCounterInstanceLifetime , initializePerformanceCounterInstanceRawValue ); } } var enableProcessCounter = enabledPerformanceCounters .HasFlag ( MultiPerformanceCountersTypeFlags .ProcessCounter ); if (enableProcessCounter) { container .PrcocessPerformanceCounter .Increment(); } var enableProcessingCounter = enabledPerformanceCounters .HasFlag ( MultiPerformanceCountersTypeFlags .ProcessingCounter ); if (enableProcessingCounter) { container.ProcessingPerformanceCounter.Increment(); } var enableProcessedAverageTimerCounter = enabledPerformanceCounters .HasFlag ( MultiPerformanceCountersTypeFlags .ProcessedAverageTimerCounter ); if (enableProcessedAverageTimerCounter) { _stopwatchsPool.TryGet(out r); //Stopwatch.StartNew(); r.Restart(); } } return(r); }
static internal PerformanceCounter GetPerformanceCounter(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { PerformanceCounter counter = null; if (PerformanceCounters.PerformanceCountersEnabled || PerformanceCounters.MinimalPerformanceCountersEnabled) { counter = PerformanceCounters.GetPerformanceCounterInternal(categoryName, perfCounterName, instanceName, instanceLifetime); } return(counter); }
private unsafe bool TryReuseInstance(int instanceNameHashCode, string instanceName, CategoryEntry* categoryPointer, InstanceEntry** returnInstancePointerReference, PerformanceCounterInstanceLifetime lifetime, InstanceEntry* lockInstancePointer) { // // 2nd pass find a free instance slot // InstanceEntry* currentInstancePointer = (InstanceEntry*)(ResolveOffset(categoryPointer->FirstInstanceOffset, InstanceEntrySize)); InstanceEntry* previousInstancePointer = currentInstancePointer; for (;;) { if (currentInstancePointer->RefCount == 0) { bool hasFit; long instanceNamePtr; // we need cache this to avoid race conditions. if (categoryData.UseUniqueSharedMemory) { instanceNamePtr = ResolveOffset(currentInstancePointer->InstanceNameOffset, InstanceNameSlotSize); // In the separate shared memory case we should always have enough space for instances. The // name slot size is fixed. Debug.Assert(((instanceName.Length + 1) * 2) <= InstanceNameSlotSize, "The instance name length should always fit in our slot size"); hasFit = true; } else { // we don't know the string length yet. instanceNamePtr = ResolveOffset(currentInstancePointer->InstanceNameOffset, 0); // In the global shared memory, we require names to be exactly the same length in order // to reuse them. This way we don't end up leaking any space and we don't need to // depend on the layout of the memory to calculate the space we have. int length = GetStringLength((char*) instanceNamePtr); hasFit = (length == instanceName.Length); } bool noSpinLock = (lockInstancePointer == currentInstancePointer) || categoryData.UseUniqueSharedMemory; // Instance name fit if (hasFit) { // don't bother locking again if we're using a separate shared memory. bool sectionEntered; if (noSpinLock) sectionEntered = true; else WaitAndEnterCriticalSection(&(currentInstancePointer->SpinLock), out sectionEntered); if (sectionEntered) { try { // Make copy with zero-term SafeMarshalCopy(instanceName, (IntPtr)instanceNamePtr); currentInstancePointer->InstanceNameHashCode = instanceNameHashCode; // return *returnInstancePointerReference = currentInstancePointer; // clear the counter values. ClearCounterValues(*returnInstancePointerReference); if (categoryData.UseUniqueSharedMemory) { CounterEntry* counterPointer = (CounterEntry*)ResolveOffset(currentInstancePointer->FirstCounterOffset, CounterEntrySize); ProcessLifetimeEntry* lifetimeEntry = (ProcessLifetimeEntry*) ResolveOffset(counterPointer->LifetimeOffset, ProcessLifetimeEntrySize); PopulateLifetimeEntry(lifetimeEntry, lifetime); } (*returnInstancePointerReference)->RefCount = 1; return true; } finally { if (!noSpinLock) ExitCriticalSection(&(currentInstancePointer->SpinLock)); } } } } previousInstancePointer = currentInstancePointer; if (currentInstancePointer->NextInstanceOffset != 0) currentInstancePointer = (InstanceEntry*)(ResolveOffset(currentInstancePointer->NextInstanceOffset, InstanceEntrySize)); else { *returnInstancePointerReference = previousInstancePointer; return false; } } }
public override void AttachPerformanceCountersToMembers ( string categoryName , string instanceName , PerformanceCounterInstanceLifetime performanceCounterInstanceLifetime = PerformanceCounterInstanceLifetime.Global , long? initializePerformanceCounterInstanceRawValue = null ) { if (!_isAttachedPerformanceCounters) { //var type = this.GetType(); AttachPerformanceCountersToMembers<QueuePerformanceCountersContainer> ( categoryName , instanceName , this , performanceCounterInstanceLifetime , initializePerformanceCounterInstanceRawValue ); } _isAttachedPerformanceCounters = true; }
internal unsafe void RemoveInstance(string instanceName, PerformanceCounterInstanceLifetime instanceLifetime) { if (instanceName == null || instanceName.Length == 0) return; int instanceNameHashCode = GetWstrHashCode(instanceName); CategoryEntry* categoryPointer; if (!FindCategory(&categoryPointer)) return; InstanceEntry* instancePointer = null; bool validatedCachedInstancePointer = false; bool temp; Mutex mutex = null; RuntimeHelpers.PrepareConstrainedRegions(); try { SharedUtils.EnterMutexWithoutGlobal(categoryData.MutexName, ref mutex); if (this.thisInstanceOffset != -1) { try { // validate whether the cached instance pointer is pointing at the right instance instancePointer = (InstanceEntry*)(ResolveOffset(this.thisInstanceOffset, InstanceEntrySize)); if (instancePointer->InstanceNameHashCode == instanceNameHashCode) { if (StringEquals(instanceName, instancePointer->InstanceNameOffset)){ validatedCachedInstancePointer = true; // this is probably overkill CounterEntry* firstCounter = (CounterEntry*) ResolveOffset(instancePointer->FirstCounterOffset, CounterEntrySize); ProcessLifetimeEntry* lifetimeEntry; if (categoryData.UseUniqueSharedMemory) { lifetimeEntry = (ProcessLifetimeEntry*) ResolveOffset(firstCounter->LifetimeOffset, ProcessLifetimeEntrySize); if (lifetimeEntry != null && lifetimeEntry->LifetimeType == (int)PerformanceCounterInstanceLifetime.Process && lifetimeEntry->ProcessId != 0) { validatedCachedInstancePointer &= (instanceLifetime == PerformanceCounterInstanceLifetime.Process); validatedCachedInstancePointer &= (ProcessData.ProcessId == lifetimeEntry->ProcessId); if ((lifetimeEntry->StartupTime != -1) && (ProcessData.StartupTime != -1)) validatedCachedInstancePointer &= (ProcessData.StartupTime == lifetimeEntry->StartupTime); } else validatedCachedInstancePointer &= (instanceLifetime != PerformanceCounterInstanceLifetime.Process); } } } } catch (InvalidOperationException) { validatedCachedInstancePointer = false; } if (!validatedCachedInstancePointer) this.thisInstanceOffset = -1; } if (!validatedCachedInstancePointer && !FindInstance(instanceNameHashCode, instanceName, categoryPointer, &instancePointer, false, instanceLifetime, out temp)) return ; if (instancePointer != null) RemoveOneInstance(instancePointer, false); } finally { if (mutex != null) { mutex.ReleaseMutex(); mutex.Close(); } } }
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; }
CountPerformanceBegin ( PerformanceCounterProcessingFlagsType enabledProcessingFlagsType , string categoryName , string instanceName , out bool enabledCount , out Stopwatch[] stopwatches , Func <bool> onGetEnableCountProcessFunc = null , Func <PerformanceCounterProcessingFlagsType, PerformanceCounter, long> onPerformanceCounterChangeValueProcessFunc = null , PerformanceCounterInstanceLifetime instanceLifetime = PerformanceCounterInstanceLifetime.Global , long?initializeInstanceRawValue = null ) { TPerformanceCountersContainer container = null; Stopwatch[] stopwatchesInline = null; enabledCount = true; { if (onGetEnableCountProcessFunc != null) { enabledCount = onGetEnableCountProcessFunc(); } } if ( enabledCount && enabledProcessingFlagsType != PerformanceCounterProcessingFlagsType.None ) { var enableTimeBasedOnBeginOnEnd = false; PerformanceCountersPair[] performanceCountersPairs = null; var stopwatchIndex = 0; if (enabledCount) { #region get Container string key = string .Format ( "{1}{0}{2}" , "-" , categoryName , instanceName ); if (!_dictionary.TryGetValue(key, out container)) { lock (_lockerObject) { container = new TPerformanceCountersContainer(); _dictionary .Add ( key , container ); container .AttachPerformanceCountersToMembers ( categoryName , instanceName ); } } #endregion var enableIncrementOnBegin = enabledProcessingFlagsType .HasFlag ( PerformanceCounterProcessingFlagsType .IncrementOnBegin ); if (enableIncrementOnBegin) { Array .ForEach ( container .IncrementOnBeginPerformanceCounters , (x) => { var increment = 1L; if (onPerformanceCounterChangeValueProcessFunc != null) { increment = onPerformanceCounterChangeValueProcessFunc ( PerformanceCounterProcessingFlagsType.IncrementOnBegin , x ); } if (increment == 1) { x.Increment(); } else { x.IncrementBy(increment); } } ); } enableTimeBasedOnBeginOnEnd = enabledProcessingFlagsType .HasFlag ( PerformanceCounterProcessingFlagsType .TimeBasedOnBeginOnEnd ); if (enableTimeBasedOnBeginOnEnd) { performanceCountersPairs = container .TimeBasedOnBeginOnEndPerformanceCountersPairs; stopwatchesInline = new Stopwatch[performanceCountersPairs.Length]; Array .ForEach ( performanceCountersPairs , (x) => { var stopwatch = _stopwatchsPool.Get(); stopwatchesInline[stopwatchIndex++] = stopwatch; stopwatch.Restart(); } ); } } } stopwatches = stopwatchesInline; return(container); }