static float[] ExtractSamples(int categoryIndex, string counter, InstanceDataCollectionCollection[][] samples, string instance) { float[] result = new float[samples.Length - 1]; CounterSample oldSample = CounterSample.Empty; for (int i = 0; i < samples.Length; i++) { InstanceDataCollectionCollection idcc = samples[i][categoryIndex]; if (idcc == null) { return(null); } InstanceDataCollection idc = idcc[counter]; if (idc == null) { return(null); } InstanceData id = idc[instance]; if (id == null) { id = idc[TruncatedAppName(instance)]; if (id == null) { return(null); } } CounterSample sample = id.Sample; if (i > 0) { result[i - 1] = Calculate(oldSample, sample); } oldSample = sample; } return(result); }
protected override void PerformMainLoopService() { if (sampleIntervalTimer.Started != BaseState.IsOnline) { if (BaseState.IsOnline) { sampleIntervalTimer.Reset(triggerImmediately: true); } else { sampleIntervalTimer.Stop(); } } bool sampleIntervalTimerTriggered = sampleIntervalTimer.IsTriggered; if (sampleIntervalTimerTriggered) { try { foreach (var tuple in pccTupleArray) { InstanceDataCollectionCollection categorySample = tuple.Item1.ReadCategory(); tuple.Item2.DoForEach(pct => pct.Service(Log, categorySample)); } mdrfWriter.RecordGroups(); } catch (System.Exception ex) { Log.Debug.Emit("{0} generated unexpected exception: {1}", CurrentMethodName, ex.ToString(ExceptionFormat.TypeAndMessage)); } } }
public Dictionary <string, float> Refresh(float minValue) { InstanceDataCollectionCollection allData = TryGetPerformanceData(() => this.category.ReadCategory(), out Exception ex); Dictionary <string, float> result = new Dictionary <string, float>(StringComparer.CurrentCultureIgnoreCase); if (allData != null) { InstanceDataCollection processData = allData["% Processor Time"]; if (processData != null) { Dictionary <string, CounterSample> currentSamples = new Dictionary <string, CounterSample>(); foreach (InstanceData data in processData.Values) { string instanceName = data.InstanceName; CounterSample currentSample = data.Sample; currentSamples[instanceName] = currentSample; if (this.previousSamples != null && this.previousSamples.TryGetValue(instanceName, out CounterSample previousSample)) { // We have to average the usage across all the logical processors. // On an 8 processor machine, the counter can return up to 800! float value = CounterSampleCalculator.ComputeCounterValue(previousSample, currentSample) / ProcessorCount; result[data.InstanceName] = value >= minValue ? value : float.NaN; } } this.previousSamples = currentSamples; } } return(result); }
public static void PerformanceCounterCategory_ReadCategory() { PerformanceCounterCategory pcc = Helpers.RetryOnAllPlatforms(() => new PerformanceCounterCategory("Processor")); InstanceDataCollectionCollection idColCol = pcc.ReadCategory(); Assert.NotNull(idColCol); }
public static void InstanceDataCollectionCollection_CopyTo() { InstanceDataCollectionCollection idcc = GetInstanceDataCollectionCollection(); InstanceDataCollection[] idc = new InstanceDataCollection[idcc.Values.Count]; idcc.CopyTo(idc, 0); Assert.True(idc.Length > 0); }
private static string FindProcessInstance(int pid, IEnumerable <string> instances, string categoryName, string counterName) { Tuple <DateTime, PerformanceCounterCategory, InstanceDataCollectionCollection> cached; DateTime utcNow = DateTime.UtcNow; InstanceDataCollectionCollection result = null; PerformanceCounterCategory category = null; if (cache.TryGetValue(categoryName, out cached)) { category = cached.Item2; if (cached.Item1 < utcNow) { result = cached.Item3; } } if (result == null) { if (category == null) { category = new PerformanceCounterCategory(categoryName); } result = category.ReadCategory(); cache.TryAdd(categoryName, new Tuple <DateTime, PerformanceCounterCategory, InstanceDataCollectionCollection>(utcNow.AddMinutes(1), category, result)); } InstanceDataCollection counters = result[counterName]; if (counters != null) { foreach (string i in instances) { InstanceData instance = counters[i]; if ((instance != null) && (pid == instance.RawValue)) { return(i); } } } return(null); }
static InstanceDataCollectionCollection[] SampleCategories(PerformanceCounterCategory[] categories) { InstanceDataCollectionCollection[] idcc = new InstanceDataCollectionCollection[categories.Length]; for (int i = 0; i < categories.Length; i++) { try { idcc[i] = categories[i].ReadCategory(); } catch (Exception) { } } return(idcc); }
public void Service(Logging.IBasicLogger logger, InstanceDataCollectionCollection categorySample, bool rethrow = false) { if (!isUsable) { return; } try { InstanceDataCollection instanceDataCollection = categorySample[pcs.CounterName]; InstanceData instanceData = instanceDataCollection[pcs.InstanceName.MapNullToEmpty()]; // use empty string for counters that only have one value CounterSample counterSample = instanceData.Sample; if (!useRawPerfCtrValue) { gpInfo.VC = new ValueContainer(CounterSample.Calculate(lastCounterSample, counterSample)); } else { gpInfo.VC = new ValueContainer(counterSample.RawValue); } lastCounterSample = counterSample; logExceptionElevationHoldoffTimer.StopIfNeeded(); } catch (System.Exception ex) { bool useHighLevelMesg = (logExceptionElevationHoldoffTimer.IsTriggered || !logExceptionElevationHoldoffTimer.Started); logExceptionElevationHoldoffTimer.StartIfNeeded(); Logging.IMesgEmitter emitter = (logger == null ? Logging.NullEmitter : (useHighLevelMesg ? logger.Info : logger.Trace)); emitter.Emit("{0} for '{1}' generated exception: {2}", CurrentMethodName, gpInfo.Name, ex.ToString(ExceptionFormat.TypeAndMessage)); } }
public static void InstanceDataCollectionCollection_GetValues() { InstanceDataCollectionCollection idcc = GetInstanceDataCollectionCollection(); Assert.True(idcc.Values.Count > 0); }
public static void InstanceDataCollectionCollection_GetItem_Invalid() { InstanceDataCollectionCollection idcc = GetInstanceDataCollectionCollection(); Assert.Throws <ArgumentNullException>(() => idcc[null]); }
public static InstanceDataCollection GetInstanceDataCollection() { InstanceDataCollectionCollection idcc = GetInstanceDataCollectionCollection(); return(idcc["% User Time"]); }
public static void InstanceDataCollectionCollection_Contains_inValid() { InstanceDataCollectionCollection idcc = GetInstanceDataCollectionCollection(); Assert.Throws <ArgumentNullException>(() => idcc.Contains(null)); }
public static void InstanceDataCollectionCollection_Contains_Valid() { InstanceDataCollectionCollection idcc = GetInstanceDataCollectionCollection(); Assert.False(idcc.Contains("Not a real instance")); }
//</snippet7> public static void Main() { string catNumStr; int categoryNum; PerformanceCounterCategory[] categories = PerformanceCounterCategory.GetCategories(); // Create and sort an array of category names. string[] categoryNames = new string[categories.Length]; int catX; for (catX = 0; catX < categories.Length; catX++) { categoryNames[catX] = categories[catX].CategoryName; } Array.Sort(categoryNames); Console.WriteLine("These categories are registered on this computer:"); for (catX = 0; catX < categories.Length; catX++) { Console.WriteLine("{0,4} - {1}", catX + 1, categoryNames[catX]); } // Ask the user to choose a category. Console.Write("Enter the category number from the above list: "); catNumStr = Console.ReadLine(); // Validate the entered category number. try { categoryNum = int.Parse(catNumStr); if (categoryNum < 1 || categoryNum > categories.Length) { throw new Exception(String.Format("The category number must be in the " + "range 1..{0}.", categories.Length)); } categoryName = categoryNames[(categoryNum - 1)]; } catch (Exception ex) { Console.WriteLine("\"{0}\" is not a valid category number." + "\r\n{1}", catNumStr, ex.Message); return; } //<snippet5> //<snippet6> // Process the InstanceDataCollectionCollection for this category. PerformanceCounterCategory pcc = new PerformanceCounterCategory(categoryName); InstanceDataCollectionCollection idColCol = pcc.ReadCategory(); InstanceDataCollection[] idColArray = new InstanceDataCollection[idColCol.Count]; Console.WriteLine("InstanceDataCollectionCollection for \"{0}\" " + "has {1} elements.", categoryName, idColCol.Count); //</snippet6> // Copy and process the InstanceDataCollection array. idColCol.CopyTo(idColArray, 0); foreach (InstanceDataCollection idCol in idColArray) { ProcessInstanceDataCollection(idCol); } //</snippet5> }
public static void Main() { string catNumStr; int categoryNum; PerformanceCounterCategory[] categories = PerformanceCounterCategory.GetCategories(); Console.WriteLine("These categories are registered on this computer:"); int catX; for (catX = 0; catX < categories.Length; catX++) { Console.WriteLine("{0,4} - {1}", catX + 1, categories[catX].CategoryName); } // Ask the user to choose a category. Console.Write("Enter the category number from the above list: "); catNumStr = Console.ReadLine(); // Validate the entered category number. try { categoryNum = int.Parse(catNumStr); if (categoryNum < 1 || categoryNum > categories.Length) { throw new Exception(String.Format("The category number must be in the " + "range 1..{0}.", categories.Length)); } categoryName = categories[(categoryNum - 1)].CategoryName; } catch (Exception ex) { Console.WriteLine("\"{0}\" is not a valid category number." + "\r\n{1}", catNumStr, ex.Message); return; } // Process the InstanceDataCollectionCollection for this category. PerformanceCounterCategory pcc = new PerformanceCounterCategory(categoryName); InstanceDataCollectionCollection idColCol = pcc.ReadCategory(); ICollection idColColKeys = idColCol.Keys; string[] idCCKeysArray = new string[idColColKeys.Count]; idColColKeys.CopyTo(idCCKeysArray, 0); ICollection idColColValues = idColCol.Values; InstanceDataCollection[] idCCValuesArray = new InstanceDataCollection[idColColValues.Count]; idColColValues.CopyTo(idCCValuesArray, 0); Console.WriteLine("InstanceDataCollectionCollection for \"{0}\" " + "has {1} elements.", categoryName, idColCol.Count); // Display the InstanceDataCollectionCollection Keys and Values. // The Keys and Values collections have the same number of elements. int index; for (index = 0; index < idCCKeysArray.Length; index++) { Console.WriteLine(" Next InstanceDataCollectionCollection " + "Key is \"{0}\"", idCCKeysArray[index]); ProcessInstanceDataCollection(idCCValuesArray[index]); } }
//<snippet2> public static void Main(string[] args) { // These values can be used as arguments. string categoryName = "Process"; string counterName = "Private Bytes"; string instanceName = "Explorer"; InstanceDataCollection idCol; const string SINGLE_INSTANCE_NAME = "systemdiagnosticsperfcounterlibsingleinstance"; // Copy the supplied arguments into the local variables. try { categoryName = args[0]; counterName = args[1]; instanceName = args[2]; } catch { // Ignore the exception from non-supplied arguments. } try { // Get the InstanceDataCollectionCollection for this category. PerformanceCounterCategory pcc = new PerformanceCounterCategory(categoryName); InstanceDataCollectionCollection idColCol = pcc.ReadCategory(); // Get the InstanceDataCollection for this counter. idCol = idColCol[counterName]; if (idCol == null) { throw new Exception("Counter does not exist."); } } catch (Exception ex) { Console.WriteLine("An error occurred getting the InstanceDataCollection for " + "category \"{0}\", counter \"{1}\"." + "\n" + ex.Message, categoryName, counterName); return; } // If the instance name is empty, use the single-instance name. if (instanceName.Length == 0) { instanceName = SINGLE_INSTANCE_NAME; } //<snippet3> // Check if this instance name exists using the Contains // method of the InstanceDataCollection. if (!idCol.Contains(instanceName)) //</snippet3> { Console.WriteLine("Instance \"{0}\" does not exist in counter \"{1}\", " + "category \"{2}\".", instanceName, counterName, categoryName); return; } else { //<snippet4> // The instance name exists, now get its InstanceData object // using the indexer (Item property) for the InstanceDataCollection. InstanceData instData = idCol[instanceName]; //</snippet4> Console.WriteLine("CategoryName: {0}", categoryName); Console.WriteLine("CounterName: {0}", counterName); Console.WriteLine("InstanceName: {0}", instData.InstanceName); Console.WriteLine("RawValue: {0}", instData.RawValue); } }
public void Update() { foreach (string categoryName in subscribers.Select(kvp => kvp.Key.Item1).Distinct()) { PerformanceCounterCategory pcc = new PerformanceCounterCategory(categoryName); #if DEBUG Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); #endif InstanceDataCollectionCollection idcc = pcc.ReadCategory(); #if DEBUG stopwatch.Stop(); Console.WriteLine("{0:f4} ms\t{1}", stopwatch.Elapsed.TotalMilliseconds, categoryName); #endif foreach (InstanceDataCollection idc in idcc.Values) { string counterName = idc.CounterName; Tuple <string, string> tuple = Tuple.Create(categoryName, counterName); List <IPerfmonCallback> list; if (subscribers.TryGetValue(tuple, out list)) { List <Instance> instances = new List <Instance>(); DateTime? timestamp = null; foreach (InstanceData id in idc.Values) { string instanceName = (pcc.CategoryType == PerformanceCounterCategoryType.MultiInstance ? id.InstanceName : "*"); string path = string.Format(@"\{0}({1})\{2}", categoryName, instanceName, counterName); CounterSample sample = id.Sample; if (timestamp == null) { timestamp = DateTime.FromFileTime(sample.TimeStamp100nSec); } CounterSample prevSample; if (prevSamples.TryGetValue(path, out prevSample)) { float value = CounterSample.Calculate(prevSample, sample); instances.Add(new Instance() { Name = instanceName, Value = value }); } prevSamples[path] = sample; } // If there are instances available but we don't have a previous sample // to calculate their value, then don't send anything to the client yet if (idc.Count > 0 && instances.Count == 0) { continue; } // Otherwise let the client know that there are no instances by sending // an empty list with the current time if (timestamp == null) { timestamp = DateTime.Now; } Counter counter = new Counter() { Name = counterName, Instances = instances }; Category category = new Category() { Name = categoryName, Counters = new List <Counter>() { counter } }; EventData e = new EventData() { Category = category, Timestamp = timestamp.Value }; ThreadPool.QueueUserWorkItem(_ => { Parallel.ForEach(list, subscriber => { try { subscriber.OnNext(e); } catch (CommunicationException) { } }); }); } } } }
static void Main(string[] args) { bool doModuleList = true; bool doWorkingSet = true; int measurementTime = 10 /*secs*/; string[] configCounters = ReadConfigCounters("PerfStats.cfg"); Console.WriteLine(); // print usage information if (args.Length == 1 && (args[0] == "/?" || args[0].ToLower(CultureInfo.InvariantCulture) == "/help" || args[0] == "-?" || args[0].ToLower(CultureInfo.InvariantCulture) == "-help")) { Usage(); return; } // process command line string processName = null; int processId = 0; Process process = null; for (int i = 0; i < args.Length; i++) { // Can it be an option? if (args[i].Length >= 1 && (args[i][0] == '-' || args[i][0] == '/')) { switch (args[i].Substring(1).ToLower(CultureInfo.InvariantCulture)) { case "m": case "m+": doModuleList = true; break; case "m-": doModuleList = false; break; case "p": i++; if (i < args.Length) { processId = Int32.Parse(args[i]); process = Process.GetProcessById(processId); if (process == null) { Console.WriteLine("Process id not found: {0}", processId); } else { processName = process.MainModule.ModuleName; if (processName.EndsWith(".exe") || processName.EndsWith(".EXE")) { processName = processName.Substring(0, processName.Length - 4); } processName = FindProcessById(processName, processId); } } else { Console.WriteLine("-P option missing argument"); } break; case "w": case "w+": doWorkingSet = true; break; case "w-": doWorkingSet = true; break; case "t": i++; if (i < args.Length) { measurementTime = Int32.Parse(args[i]); if (measurementTime < 1) { Console.WriteLine("Measurement time must be at least 1 seconds"); measurementTime = 1; } } else { Console.WriteLine("-T option missing argument"); } break; default: Console.WriteLine("Unrecognized option {0}", args[i]); break; } } else { if (processName != null || processId != 0) { Console.WriteLine("More than one process specified"); } else { processName = args[i]; if (processName.ToLower(CultureInfo.InvariantCulture).EndsWith(".exe")) { processName = processName.Substring(0, processName.Length - 4); } } } } if (processName != null) { if (process == null) { processId = ProcessId(processName); if (processId >= 0) { process = Process.GetProcessById(processId); } } if (process == null) { Console.WriteLine("Process {0} not found", processName); } } if (process == null) { MakeApplyToAllInstances(stdCounters); MakeApplyToAllInstances(configCounters); } long startCycleCount = GetCycleCount64(); int startTickCount = GetTickCount(); Hashtable categoryHash = new Hashtable(); AddCategories(categoryHash, stdCounters); AddCategories(categoryHash, configCounters); PerformanceCounterCategory[] categories = new PerformanceCounterCategory[categoryHash.Count]; int j = 0; foreach (PerformanceCounterCategory pcc in categoryHash.Values) { categories[j++] = pcc; } InstanceDataCollectionCollection[][] samples = new InstanceDataCollectionCollection[measurementTime + 1][]; Console.Write("Taking measurements for {0} seconds: ", measurementTime); samples[0] = SampleCategories(categories); for (int t = 1; t <= measurementTime; t++) { System.Threading.Thread.Sleep(1000); samples[t] = SampleCategories(categories); Console.Write("{0}", (char)((t % 10) + '0')); } Console.WriteLine(); Console.WriteLine(); Console.WriteLine("System information:"); Console.WriteLine("==================="); PrintSystemInformation(); long elapsedCycleCount = GetCycleCount64() - startCycleCount; int elapsedTickCount = GetTickCount() - startTickCount; double clockSpeed = (double)elapsedCycleCount / elapsedTickCount / 1000.0; Console.WriteLine("{0,-41}{1,7:n0} MHz", "Clock speed:", clockSpeed); int l2CacheSize = GetL2CacheSize(); if (l2CacheSize == 0) { Console.WriteLine("{0,-41}{1,11}", "L2 Cache size:", "Unknown"); } else { Console.WriteLine("{0,-41}{1,8:n0} kB", "L2 Cache size:", l2CacheSize / 1024); } PrintCounters(stdCounters, categories, samples, null); PrintCounters(configCounters, categories, samples, null); if (process != null) { Console.WriteLine(); Console.WriteLine("Process information for {0}:", processName); Console.WriteLine("========================{0}=", new string('=', processName.Length)); PrintCounters(stdCounters, categories, samples, processName); PrintCounters(configCounters, categories, samples, processName); if (doModuleList) { PrintModuleList(process); } if (doWorkingSet) { WorkingSetAnalysis(process, processName); } } }