| public NextSample ( ) : System.Diagnostics.CounterSample | ||
| return | System.Diagnostics.CounterSample | |
public void WatchCpuAndMemory()
{
var pc = new PerformanceCounter("Processor Information", "% Processor Time");
var cat = new PerformanceCounterCategory("Processor Information");
var cpuInstances = cat.GetInstanceNames();
var cpus = new Dictionary<string, CounterSample>();
var memoryCounter = new PerformanceCounter("Memory", "Available MBytes");
foreach (var s in cpuInstances)
{
pc.InstanceName = s;
cpus.Add(s, pc.NextSample());
}
var t = DateTime.Now;
while (t.AddMinutes(1) > DateTime.Now)
{
Trace.WriteLine(string.Format("Memory:{0}MB", memoryCounter.NextValue()));
foreach (var s in cpuInstances)
{
pc.InstanceName = s;
Trace.WriteLine(string.Format("CPU:{0} - {1:f}", s, Calculate(cpus[s], pc.NextSample())));
cpus[s] = pc.NextSample();
}
//Trace.Flush();
System.Threading.Thread.Sleep(1000);
}
}
protected void FirePerfCounter(string category, string counterName, PerfCounterEventDelegate action)
{
PerformanceCounter counter = new PerformanceCounter(category, counterName, "_total_");
CounterSample sample = counter.NextSample();
float startVal = sample.RawValue;
action();
action();
action();
sample = counter.NextSample();
float endVal = sample.RawValue;
Assert.AreEqual(startVal + 3, endVal);
}
public ActionResult CpuUtilization()
{
PerformanceCounter cpuCounter = new PerformanceCounter
{
CategoryName = "Processor",
CounterName = "% Processor Time",
InstanceName = "_Total"
};
var sample1 = cpuCounter.NextSample();
System.Threading.Thread.Sleep(100);
var sample2 = cpuCounter.NextSample();
var finalCpuCounter = CounterSample.Calculate(sample1, sample2);
return Json(Math.Round(finalCpuCounter,2).ToString() + "%", JsonRequestBehavior.AllowGet);
}
static Func<ulong> GetElapsedTimeSampler(PerformanceCounter pc) {
var scale = 1.0 / 1000;
return () => {
var sample = pc.NextSample();
return (ulong)((sample.CounterTimeStamp - sample.RawValue) / (scale * sample.CounterFrequency));
};
}
private static long WaitForNextRawValue(PerformanceCounter counter)
{
long used;
while((used = counter.NextSample().RawValue) == 0)
{
Thread.Sleep(10);
}
return used;
}
private string _name; // The name of the adapter.
#endregion
#region Private methods
/// <summary>
/// Instances of this class are supposed to be created only in an NetworkMonitorHandler.
/// </summary>
internal NetworkAdapter(string name)
{
_name = name;
// Create performance counters for the adapter.
_dlCounter = new PerformanceCounter("Network Interface", "Bytes Received/sec", this._name);
_ulCounter = new PerformanceCounter("Network Interface", "Bytes Sent/sec", this._name);
// Since dlValueOld and ulValueOld are used in method update() to calculate network speed,
// they must have be initialized.
_dlValueOld = _dlCounter.NextSample().RawValue;
_ulValueOld = _ulCounter.NextSample().RawValue;
}
public Dictionary<string, float> GetCpusUsage()
{
performanceCounter = new PerformanceCounter("Processor Information", "% Processor Time");
var counterCategory = new PerformanceCounterCategory("Processor Information");
var instances = counterCategory.GetInstanceNames();
var samples = instances.ToDictionary(x=>x,y=>new List<CounterSample>());
for (int i = 0; i < 2; i++)
{
foreach (var instanceName in instances)
{
performanceCounter.InstanceName = instanceName;
samples[instanceName].Add(performanceCounter.NextSample());
Thread.Sleep(100);
}
}
return samples.ToDictionary(x => x.Key, y => Calculate(y.Value[0], y.Value[1]));
}
public DiskActivity(int interval = 1000)
{
_performanceCounter = new PerformanceCounter("PhysicalDisk", "% Idle Time");
var performanceCounterCategory = new PerformanceCounterCategory("PhysicalDisk");
_instances = performanceCounterCategory.GetInstanceNames();
_counterSamples = new Dictionary<string, CounterSample>();
foreach (var s in _instances)
{
_performanceCounter.InstanceName = s;
_counterSamples.Add(s, _performanceCounter.NextSample());
}
_updateTimer = new Timer
{
AutoReset = true,
Interval = interval
};
_updateTimer.Elapsed += UpdateTimerOnElapsed;
_updateTimer.Start();
}
public CpuLoad(int interval = 1000)
{
_performanceCounter = new PerformanceCounter("Processor Information", "% Processor Time");
var performanceCounterCategory = new PerformanceCounterCategory("Processor Information");
_instances = performanceCounterCategory.GetInstanceNames();
_counterSamples = new Dictionary<string, CounterSample>();
foreach (var s in _instances)
{
_performanceCounter.InstanceName = s;
_counterSamples.Add(s, _performanceCounter.NextSample());
}
_updateTimer = new Timer
{
AutoReset = true,
Interval = interval
};
_updateTimer.Elapsed += UpdateTimerOnElapsed;
_updateTimer.Start();
}
public static long? SafelyGetPerformanceCounter(string categoryName, string counterName, string processName)
{
try
{
if (PerformanceCounterCategory.Exists(categoryName) == false)
return null;
var category = new PerformanceCounterCategory(categoryName);
var instances = category.GetInstanceNames();
var ravenInstance = instances.FirstOrDefault(x => x == processName);
if (ravenInstance == null || !category.CounterExists(counterName))
{
return null;
}
using (var counter = new PerformanceCounter(categoryName, counterName, ravenInstance, readOnly: true))
{
return counter.NextSample().RawValue;
}
}
catch (Exception e)
{
//Don't log anything here, it's up to the calling code to decide what to do
return null;
}
}
static void Main(string[] args)
{
// Getting Hostname.
var Hostname = System.Environment.MachineName;
// Making sure that the command is being run with Argument Values.
if (args.Length == 0)
{
Console.WriteLine("A [Processor_Instance], [Warning Percent] and a [Critical Percent] Value must be provided!");
Environment.Exit(3);
}
try
{
// Declared Argument Values for Disk, Warning Threshold and Critical Threshold.
String Arg_0 = args[0];
String Arg_1 = args[1];
String Arg_2 = args[2];
// Testing Argument Variables to determine if they are the correct type of value.
Match ProcessorInstanceCheck = Regex.Match(Arg_0, @"[A-Z]", RegexOptions.IgnoreCase);
Match WarningCheck = Regex.Match(Arg_1, @"[A-Z]", RegexOptions.IgnoreCase);
Match CriticalCheck = Regex.Match(Arg_2, @"[A-Z]", RegexOptions.IgnoreCase);
// Making sure that the Warning Percent Decimal Value is a number.
if (ProcessorInstanceCheck.Success)
{
Console.WriteLine("A [Proceesor_Instance] Numeric Value (0,1,2,5 etc...) must be provided!");
Environment.Exit(3);
}
// Making sure that the Warning Percent Decimal Value is a number.
if (WarningCheck.Success)
{
Console.WriteLine("A [Warning Percent] Decimal Value (1.00, 12.00, 90.00 etc...) must be provided!");
Environment.Exit(3);
}
// Making sure that the Critical Percent Decimal Value is a number.
if (CriticalCheck.Success)
{
Console.WriteLine("A [Critical Percent] Decimal Value (1.00, 12.00, 90.00 etc...) must be provided!");
Environment.Exit(3);
}
// Converting all Passed Arguments into a Usable State.
var Warning = (Convert.ToDouble(args[1]));
var Critical = (Convert.ToDouble(args[2]));
// Making sure that the Warning Percent and Critical Percent Values are not greater than 100%
if ((Warning > 100.00) || (Critical > 100.00))
{
Console.WriteLine("The [Warning Percent] and [Critical Percent] Values cannot be greater than 100.00!");
Environment.Exit(3);
}
// Making sure that the Warning Percent Value is Less than the Critical Percent Value.
if (Warning > Critical)
{
Console.WriteLine("The [Warning Percent] Value must be Less than the [Critical Percent] Value!");
Environment.Exit(3);
}
// Making sure that the Warning Percent Value is not equal to the Critical Percent Value.
else if (Warning == Critical)
{
Console.WriteLine("The [Warning Percent] Value cannot be Equal to the [Critical Percent] Value!");
Environment.Exit(3);
}
// Checking to see if the Processor Instance exists.
if (!System.Diagnostics.PerformanceCounterCategory.InstanceExists(args[0], "Processor"))
{
Console.WriteLine("Processor Instance [{0}] does not exist on {1}!", args[0], Hostname);
Environment.Exit(3);
}
// Processor Instance is queried.
var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", args[0], true);
// Calculating the % Processor Time of the chosen Processor Instance.
var Sample_1 = cpuCounter.NextSample(); System.Threading.Thread.Sleep(1000);
var Sample_2 = cpuCounter.NextSample();
var ProcessorTime = ((1 - ((double)(Sample_2.RawValue - Sample_1.RawValue) / (double)(Sample_2.TimeStamp100nSec - Sample_1.TimeStamp100nSec))) * 100);
// Final Results and Performance Data are Returned.
if (ProcessorTime > Critical)
{
Console.WriteLine("[{0}]: % Processor Time = {1}% - CRITICAL | '[{0}]'={1}%;{2};{3};0.00;100.00;", args[0], ProcessorTime.ToString("0.00"), Warning.ToString("0.00"), Critical.ToString("0.00"));
Environment.Exit(2);
}
else if ((ProcessorTime < Critical) && (ProcessorTime > Warning))
{
Console.WriteLine("[{0}]: % Processor Time = {1}% - WARNING | '[{0}]'={1}%;{2};{3};0.00;100.00;", args[0], ProcessorTime.ToString("0.00"), Warning.ToString("0.00"), Critical.ToString("0.00"));
Environment.Exit(1);
}
else if (ProcessorTime < Warning)
{
Console.WriteLine("[{0}]: % Processor Time = {1}% - OK | '[{0}]'={1}%;{2};{3};0.00;100.00;", args[0], ProcessorTime.ToString("0.00"), Warning.ToString("0.00"), Critical.ToString("0.00"));
Environment.Exit(0);
}
}
//// Catching Exception Errors here due to Missing Variables or Syntax Issues.
catch (Exception Error)
{
if (Error is IndexOutOfRangeException)
{
Console.WriteLine("The [Warning Percent] and [Critical Percent] Variables must BOTH be present!");
Environment.Exit(3);
}
else if (Error is FormatException)
{
Console.WriteLine("Please check the format of the values you have assigned to your variables.");
Environment.Exit(3);
}
}
}
public static CounterSample GetPerformanceCounterSample(string categoryName,
string instanceName,
string counterName)
{
using (PerformanceCounter counter = new PerformanceCounter())
{
counter.CategoryName = categoryName;
counter.CounterName = counterName;
counter.InstanceName = instanceName;
return counter.NextSample();
}
}
private void LogPerformanceCounterData(PerformanceCounter memoryMonitor, PerformanceCounter processorMonitor)
{
LogMessage(string.Format("\t\tMemory Usage:\t{0,15:N0}", memoryMonitor.NextSample().RawValue));
LogMessage(string.Format("\t\tProcessor Usage:{0,15:N0}", processorMonitor.NextSample().RawValue));
}
} // MonitorInventory(Object context, BackgroundWorker worker, int refreshMS, int singulationLimit, int readerCycleLimit)
/// <summary>
/// Read Tag memory
/// </summary>
/// <param name="context"></param>
/// <param name="worker"></param>
/// <param name="refreshMS"></param>
/// <returns></returns>
//public ReportBase TagAccess(Object context, BackgroundWorker worker, int refreshMS, int r_iTagAccessReqCount)//??把计??//Add LargeRead command
public ReportBase TagAccess(Object context, BackgroundWorker worker, int refreshMS, int r_iTagAccessReqCount, int r_iTagAccessReqCountRead)//??把计??//Add LargeRead command
{
#if DEBUG
System.Diagnostics.Debug.WriteLine( String.Format( "{0}() ThreadID = {1}", System.Reflection.MethodInfo.GetCurrentMethod( ).Name, Thread.CurrentThread.ManagedThreadId ) );
#endif
if ( IsDisposed )
throw new ObjectDisposedException( "LakeChabotReader" );
if ( Mode != rfidReader.OperationMode.BoundToReader )
return new rfidSimpleReport( context, OperationOutcome.FailByContext,
new rfidException( rfidErrorCode.ReaderIsNotBound, "Reader must be bound before tag can be read." ) );
if ( _control.State != FunctionControl.FunctionState.Idle )
return new rfidSimpleReport( context, OperationOutcome.FailByContext, new Exception( "Cannot read the tag, the prior task has not completed" ) );
if ( null == worker )
return new rfidSimpleReport( context, OperationOutcome.FailByApplicationError, new ArgumentNullException( "worker", "BackgroundWorker is required" ) );
if ( refreshMS < MIN_REFRESH_MS || refreshMS > MAX_REFRESH_MS )
return new rfidSimpleReport( context, OperationOutcome.FailByApplicationError, new ArgumentOutOfRangeException( "refreshMS", refreshMS, string.Format( "Value must be between {0} and {1}", MIN_REFRESH_MS, MAX_REFRESH_MS ) ) );
// Tag Read is never in continuous mode
rfid.Constants.RadioOperationMode priorMode = ReaderOperationMode;
if ( priorMode != rfid.Constants.RadioOperationMode.NONCONTINUOUS )
{
ReaderOperationMode = rfid.Constants.RadioOperationMode.NONCONTINUOUS;
}
_refreshRateMS = refreshMS;
_bgdWorker = worker;
_requestTagList.Clear( );
_periodTagList.Clear( );
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Exchange( ref _commonAccessCount, 0 );
#pragma warning restore 420
rfidOperationReport report = new rfidOperationReport( context,
ElapsedMilliseconds,
RequestCount,
RawAntennaCycleCount,
RawInventoryCycleCount,
BadPacketCount,
CRCErrorCount,
RawPacketCount,
RawRoundCount,
RawInventoryCount,
SessionUniqueTags,
RequestUniqueTags,
CurrentUniqueTags,
SessionDuration );
_control.StartAction( );
//_managedAccess.Callback = PacketCallBackFromReader;
PerformanceCounter processorUtilizationCounter = null;
try
{
processorUtilizationCounter = new PerformanceCounter( "Processor", "% Processor Time", "_Total", "." );
}
catch ( Exception ) { }
//ReaderInterfaceThreadClass threadClass = new ReaderInterfaceThreadClass(_managedAccess, (int)ReaderHandle, TagAccessDataSet);//??把计??//Add LargeRead command
ReaderInterfaceThreadClass threadClass = new ReaderInterfaceThreadClass(_managedAccess, (int)ReaderHandle, TagAccessDataSet, TagAccessReadSet);//??把计??//Add LargeRead command
threadClass._reader = this; // HACK
Thread runnerThread = new Thread(new ThreadStart(threadClass.AccessThreadProc));
runnerThread.Name = "AccessTag";
runnerThread.IsBackground = true;
runnerThread.Priority = ThreadPriority.BelowNormal;
runnerThread.Start( );
int notused = FileHandler.TotalPacketCount; // Make sure the file is created;
// Wait for thread to be in ready state
int counter = 500;
while ( counter-- > 0 && ( int ) ( runnerThread.ThreadState & System.Threading.ThreadState.WaitSleepJoin ) == 1 )
{
Thread.Sleep( 10 );
}
if ( !runnerThread.IsAlive )
{
return new rfidSimpleReport( context, OperationOutcome.FailByApplicationError, new ApplicationException( "BackgroundWorker thread could not be started." ) );
}
ReaderRequest readerRequest = new ReaderRequest( );
readerRequest.reader = _theReaderID.Name;
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
readerRequest.requestSequence = System.Threading.Interlocked.Increment( ref _commonRequestIndex );
#pragma warning restore 420
readerRequest.requestName = rfidReader.GetNameForRequest( rfidReader.ReaderRequestType.TagAccess );
readerRequest.startTime = GetSessionRelativeDateTime( report.StartTimeMS );
readerRequest.requestStartTime = report.StartTimeMS;
readerRequest.startingPacketCount = RawPacketCount;
readerRequest.startingTagCount = RawInventoryCount;
MemoryStream data = new MemoryStream( );
readerRequest.WriteTo( data );
PacketData.PacketWrapper pseudoPacket = new PacketData.PacketWrapper( new PacketData.CommandPsuedoPacket( readerRequest.requestName, data.ToArray( ) ), PacketData.PacketType.U_N_D_F_I_N_E_D );
pseudoPacket.IsPseudoPacket = true;
pseudoPacket.ReaderName = _theReaderID.Name;
pseudoPacket.ReaderIndex = ( int ) _theReaderID.Handle;
FileHandler.WritePacket( pseudoPacket );
//clark 2011.2.18 Record that user request data length
TagAccessReqCount = r_iTagAccessReqCount;
TagAccessReqCountRead = r_iTagAccessReqCountRead;//把计??
DateTime ReportDue = DateTime.Now.AddMilliseconds( refreshMS );
threadClass.StartEvent.Set( );
while ( runnerThread.IsAlive )
{
CounterSample sample = CounterSample.Empty;
if ( processorUtilizationCounter != null )
{
try
{
sample = processorUtilizationCounter.NextSample( );
}
catch ( Exception ) { }
}
ProcessQueuedPackets( );
QueueEvent.WaitOne( 30, true );
QueueEvent.Reset( );
DateTime now = DateTime.Now;
if ( ReportDue.Ticks <= now.Ticks )
{
//Debug.WriteLine(String.Format("Reporing Progress Now (Elapsed Milliseconds {0})", ElapsedMilliseconds));
_bgdWorker.ReportProgress(
0,
report.GetProgressReport( ElapsedMilliseconds,
RequestCount,
RawAntennaCycleCount,
RawInventoryCycleCount,
BadPacketCount,
CRCErrorCount,
RawPacketCount,
RawRoundCount,
RawInventoryCount,
SessionUniqueTags,
RequestUniqueTags,
CurrentUniqueTags,
SessionDuration ) );
_periodTagList.Clear( );
ReportDue = now.AddMilliseconds( refreshMS );
}
if ( !runnerThread.IsAlive )
break;
if ( FunctionController.GetActionRequest( ) == FunctionControl.RequestedAction.Abort )
{
threadClass.Stop = true;
Result abortError = Result.OK;
try
{
abortError = LakeChabotReader.MANAGED_ACCESS.API_ControlAbort();
}
catch ( Exception e )
{
Debug.WriteLine( String.Format( "Error attempting to abort: {0}", e.Message ) );
}
break;
}
if ( FunctionController.GetActionRequest( ) == FunctionControl.RequestedAction.Stop )
{
threadClass.Stop = true;
Result stopError = Result.OK;
try
{
stopError = LakeChabotReader.MANAGED_ACCESS.API_ControlCancel();
}
catch ( Exception e )
{
Debug.WriteLine( String.Format( "Error attempting to stop: {0}", e.Message ) );
}
if ( Result.OK != stopError )
{
// Try to abort
}
break;
}
if ( FunctionController.State == FunctionControl.FunctionState.Paused )
{
do
{
Thread.Sleep( refreshMS );
} while ( FunctionController.State == FunctionControl.FunctionState.Paused );
}
if ( !runnerThread.IsAlive )
break;
float processorUtilization = 0;
if ( processorUtilizationCounter != null && sample != CounterSample.Empty )
{
try
{
CounterSample.Calculate( sample, processorUtilizationCounter.NextSample( ) );
}
catch ( Exception ) { }
}
// Debug.WriteLine(String.Format("Processor Util: {0}", processorUtilization));
if ( processorUtilization > ( float ) TARGET_MAX_USAGE_PERCENT )
_packetSleepMS += SLEEP_ADD_SUBTRACT_MS;
else
_packetSleepMS -= _packetSleepMS <= MIN_SLEEP_TIME_MS ? 0 : SLEEP_ADD_SUBTRACT_MS;
}
runnerThread.Join( );
// Get any leftover packets
ProcessQueuedPackets( );
if ( LastCommandResult != 0 ) MacClearError( );
OperationOutcome outcome = OperationOutcome.Success;
string result = threadClass.Result;
if ( !( result == null || result == "" || result == "OK" ) )
{
switch ( _control.State )
{
case FunctionControl.FunctionState.Stopping:
outcome = OperationOutcome.SuccessWithUserCancel;
break;
case FunctionControl.FunctionState.Aborting:
outcome = OperationOutcome.FailByUserAbort;
break;
// case FunctionControl.FunctionState.Running:
// outcome = OperationOutcome.FailByReaderError;
// report.ErrorMessage = result;
// break;
case FunctionControl.FunctionState.Idle:
case FunctionControl.FunctionState.Paused:
case FunctionControl.FunctionState.Unknown:
default:
outcome = OperationOutcome.Unknown;
break;
}
}
_control.Finished( );
report.OperationCompleted( outcome,
ElapsedMilliseconds,
RequestCount,
RawAntennaCycleCount,
RawInventoryCycleCount,
BadPacketCount,
CRCErrorCount,
RawPacketCount,
RawRoundCount,
RawInventoryCount,
SessionUniqueTags,
RequestUniqueTags,
CurrentUniqueTags,
SessionDuration );
// reset the mode
ReaderOperationMode = priorMode;
if ( EnableLogging )
{
//Push data from buffer to file. And clear buffer.
PacketLogger.Flush();
}
return report;
}
private void DoLoop()
{
_conn = new UdpClient(_options.PhoneIp, _options.PhonePort);
var ramFreeCounter = new PerformanceCounter("Memory", "Available MBytes");
var computerInfo = new Microsoft.VisualBasic.Devices.ComputerInfo();
var totalRam = computerInfo.TotalPhysicalMemory / 1024 / 1024;
CreateNetworkCounters();
var pc = new PerformanceCounter("Processor", "% Processor Time");
var instances = new PerformanceCounterCategory("Processor").GetInstanceNames();
var cs = new Dictionary<string, CounterSample>();
foreach (var s in instances)
{
pc.InstanceName = s;
cs.Add(s, pc.NextSample());
}
Thread.Sleep(999);
var drives = DriveInfo.GetDrives();
var volume = new Volume();
_getIpsBw.DoWork += GetIps;
//_getIpsBw.RunWorkerAsync(true);
var myipTimer = new Timer(StartBw, null, TimeSpan.Zero, TimeSpan.FromMinutes(_options.MyipInterval));
while (_continue)
{
var startTime = DateTime.Now;
var strout = ".start.";
foreach (var s in instances)
{
pc.InstanceName = s;
var ns = pc.NextSample();
if (s.Equals("_Total")) strout += s + "|" + Math.Round(CounterSample.Calculate(cs[s], ns), 2) + "\n";
else strout += s + "|" + Math.Round(CounterSample.Calculate(cs[s], ns), 0) + "\n";
cs[s] = ns;
}
strout += "MemUsed|" + (totalRam - ramFreeCounter.NextValue()) + "\n";
strout += "MemTotal|" + totalRam + "\n";
try
{
strout += "NetIn|" + networkInCounter.NextValue() + "\n";
strout += "NetOut|" + networkOutCounter.NextValue() + "\n";
}
catch (Exception e)
{
_mainForm.LogLine("Warning: Failed to get network activity: " + e);
_mainForm.LogLine("Resetting to first adapter.");
_options.NetIndex = 0;
CreateNetworkCounters();
}
strout += "LocalIp|" + _localIp + "\n";
strout += "RemoteIp|" + _remoteIp + "\n";
if (RescanDrives)
{
_mainForm.LogLine("Drivechange detected, rescanning drives.", true);
drives = DriveInfo.GetDrives();
RescanDrives = false;
}
foreach (var drive in drives.Where(drive => drive.DriveType == DriveType.Fixed))
{
try
{
strout += "DriveInfo|" + drive.Name + "|" + drive.AvailableFreeSpace + "\n";
}
catch
{
}
}
strout += "Np|" + GetNp() + "\n";
var muteStatus = volume.GetMute();
var vol = volume.GetVol();
strout += "mute|" + (muteStatus ? "1" : "0") + "\n";
strout += "vol|" + vol + "\n";
SendInfo(strout);
var duration = DateTime.Now - startTime;
if (duration.Milliseconds > 1000)
{
_mainForm.LogLine("Warning: Iterating took " + duration.Milliseconds + "ms, should be less than 1s.");
}
else _mainForm.LogLine("Iterating took " + duration.Milliseconds + "ms", true);
Thread.Sleep(1000 - duration.Milliseconds);
}
ramFreeCounter.Close();
pc.Close();
myipTimer.Dispose();
volume.Dispose();
}
//private static float GetPerformanceCounterValueByInstanceDeux(string perfCategory, string perfCounterName, string perfInstanceName, out string PerfCounterType, int sleep = 50)
//{
// pCounter = new PerformanceCounter();
// PerfCounterType = "";
// try
// {
// pCounter.CategoryName = perfCategory;
// pCounter.CounterName = perfCounterName;
// pCounter.InstanceName = perfInstanceName;
// try
// {
// pCounter.NextValue();
// pFirstSample = pCounter.NextSample();
// Thread.Sleep(sleep);
// float nv = pCounter.NextValue();
// pSecondSample = pCounter.NextSample();
// float avg = CounterSample.Calculate(pFirstSample, pSecondSample);
// Console.WriteLine("{0}, {1}", nv, avg);
// return avg;
// }
// finally
// {
// pCounter.Dispose();
// }
// }
// catch
// {
// try
// {
// PerformanceCounter pc = new PerformanceCounter(LookupPerfNameByName(perfCategory), LookupPerfNameByName(perfCounterName), perfInstanceName);
// pc.NextValue();
// Thread.Sleep(sleep);
// try
// {
// PerfCounterType = pc.CounterType.ToString();
// return pc.NextValue();
// }
// finally
// {
// pc.Dispose();
// }
// }
// catch
// {
// // I give up, didnt manage to figure out the correct name for the PerformanceCounter.
// Console.WriteLine("ERROR: Error looking up PerformanceCounter '" + perfCategory + "\\" + perfCounterName + "' for " + perfInstanceName + "'");
// return -1;
// }
// }
//}
public static string GetPerformanceCounterValueAsString(string perfCategory, string perfCounterName, out string PerfCounterType, int sleep = 50)
{
//float badresult = -1;
try
{
PerformanceCounter pc = new PerformanceCounter(perfCategory, perfCounterName);
pc.NextValue();
Console.WriteLine(pc.NextSample());
Thread.Sleep(sleep);
try
{
PerfCounterType = pc.CounterType.ToString();
return pc.NextValue().ToString("0.0");
}
finally
{
pc.Dispose();
}
//return pc.RawValue;
}
catch
{
try
{
PerformanceCounter pc = new PerformanceCounter(LookupPerfNameByName(perfCategory), LookupPerfNameByName(perfCounterName));
pc.NextValue();
Thread.Sleep(sleep);
try {
PerfCounterType = pc.CounterType.ToString();
return pc.NextValue().ToString("0.0");
}
finally
{
pc.Dispose();
}
}
catch
{
// I give up, didnt manage to figure out the correct name for the PerformanceCounter.
Console.WriteLine("ERROR: Error looking up PerformanceCounter '" + perfCategory + "\\" + perfCounterName + "'");
PerfCounterType = "missing";
return "missing";
}
}
}
public IPerformanceCounter LoadCounter(string categoryName, string counterName, string instanceName, bool isReadOnly)
{
// See http://msdn.microsoft.com/en-us/library/356cx381.aspx for the list of exceptions
// and when they are thrown.
try
{
var counter = new PerformanceCounter(categoryName, counterName, instanceName, isReadOnly);
// Initialize the counter sample
counter.NextSample();
return new PerformanceCounterWrapper(counter);
}
#if UTILS
catch (InvalidOperationException) { return null; }
catch (UnauthorizedAccessException) { return null; }
catch (Win32Exception) { return null; }
catch (PlatformNotSupportedException) { return null; }
#else
catch (InvalidOperationException ex)
{
_trace.TraceEvent(TraceEventType.Error, 0, "Performance counter failed to load: " + ex.GetBaseException());
return null;
}
catch (UnauthorizedAccessException ex)
{
_trace.TraceEvent(TraceEventType.Error, 0, "Performance counter failed to load: " + ex.GetBaseException());
return null;
}
catch (Win32Exception ex)
{
_trace.TraceEvent(TraceEventType.Error, 0, "Performance counter failed to load: " + ex.GetBaseException());
return null;
}
catch (PlatformNotSupportedException ex)
{
_trace.TraceEvent(TraceEventType.Error, 0, "Performance counter failed to load: " + ex.GetBaseException());
return null;
}
#endif
}
internal int Run()
{
string thisProcessName = Process.GetCurrentProcess().ProcessName;
using (PerformanceCounter memoryMonitor = new PerformanceCounter("Process", "Working Set", thisProcessName))
{
memoryMonitor.NextSample();
using (PerformanceCounter processorMonitor = new PerformanceCounter("Process", "% Processor Time", thisProcessName))
{
processorMonitor.NextSample();
networkGeneratorLog = new List<string>();
LogMessage("********************************************************");
LogMessage(string.Format("{0,25}\t{1:G}", "Start Network Generation:", DateTime.Now));
LogMessage(string.Format("{0,25}\t{1:N0}\tEdges: {2:N0}", "Requested Nodes:", this.networkNodeCount, this.networkEdgeCount));
LogMessage(string.Format("{0,25}\t{1:N0}\tEdges: {2:N0}", "Start Ids - Nodes:", this.nodeIdStartValue, this.edgeIDStartValue));
ChirperGraphMLDocument graphDoc = new ChirperGraphMLDocument();
LogMessage(string.Empty);
LogMessage("Starting node generation...");
TimeSpan nodeGenerationTime = GenerateChirperUserNodes(graphDoc);
LogMessage("\tNode generation complete in " + nodeGenerationTime);
LogPerformanceCounterData(memoryMonitor, processorMonitor);
LogMessage(string.Empty);
FlushLog();
int duplicateEdgeStatistic = 0;
TimeSpan edgeGenerationTime = default(TimeSpan);
if (this.networkEdgeCount > 0)
{
LogMessage("Starting edge generation...");
edgeGenerationTime = GenerateChirperFollowerEdge(graphDoc, ref duplicateEdgeStatistic);
LogMessage("\tEdge generation complete in " + edgeGenerationTime);
LogMessage("\tDuplicates generated: " + duplicateEdgeStatistic);
LogPerformanceCounterData(memoryMonitor, processorMonitor);
LogMessage(string.Empty);
}
else
{
LogMessage("Edge generation suppressed from command line.");
LogMessage(string.Empty);
}
Stopwatch stopwatch = new Stopwatch();
FlushLog();
LogMessage("Starting GraphML File write...");
stopwatch.Restart();
graphDoc.WriteXmlWithWriter(this.graphMLFile);
stopwatch.Stop();
TimeSpan xmlWriteTime = TimeSpan.FromSeconds(stopwatch.Elapsed.TotalSeconds);
LogMessage("\tGraphML file write complete in " + xmlWriteTime);
LogPerformanceCounterData(memoryMonitor, processorMonitor);
LogMessage(string.Empty);
LogMessage(string.Format(CultureInfo.InvariantCulture, "{0,30}\t{1}", "Total Graph Generation Time:", (nodeGenerationTime + edgeGenerationTime + xmlWriteTime)));
LogMessage(string.Empty);
FlushLog();
// Get the size of the file so we can add the statistic.
FileInfo fileInfo = new FileInfo(this.graphMLFile);
fileInfo.Refresh();
long fileLength = fileInfo.Length;
string range = "bytes";
if (fileLength > Kilo)
{
fileLength = fileLength / Kilo;
range = "KB";
}
if (fileLength > Kilo)
{
fileLength = fileLength / Kilo;
range = "MB";
}
LogMessage(string.Format(CultureInfo.InvariantCulture, "{0,30}\t{1:N0} {2}", "GraphML File Size:", fileLength, range));
LogMessage(string.Empty);
FlushLog();
}
}
// Using Linq to XML here to insert the statistic comment won't adversely affect performance.
//XComment statisticsComment = new XComment(summaryMessageStringBuilder.ToString());
//XDocument generatedGraphMLDoc = XDocument.Load(graphMLFile);
//XElement graphElement = generatedGraphMLDoc.Root;
//graphElement.AddFirst(statisticsComment);
//graphElement.Document.Save(this.graphMLFile);
return 0;
}
private static PerformanceCounter LoadCounter(string category, string name, string host, string instance = null)
{
try
{
var counter = new PerformanceCounter(category, name, instance, host);
counter.NextSample();
return counter;
}
catch (Exception)
{
Console.WriteLine("Unable to load counter '{0}\\{1}' on host '{2}'", category, name, host);
return null;
}
}
private static void LoadCounter(string category, string name, string instance, string machine = "localhost")
{
try
{
var counter = new PerformanceCounter(category, name, instance, machine);
_samples[counter] = new List<CounterSample> { counter.NextSample() };
_counters.Add(counter);
}
catch (Exception)
{
Console.WriteLine("Failed to load counter '{0}\\{1}({2})' for machine '{3}'", category, name, instance, machine);
}
}
static void CollectingMemory()
{
Process currentProcess = Process.GetCurrentProcess();
var privateByteCounter = new PerformanceCounter("Process", "Working Set - Private", currentProcess.ProcessName);
var netMemoryCounter = new PerformanceCounter(".NET CLR Memory", "# Bytes in all Heaps", currentProcess.ProcessName);
while (!done)
{
maxNetMemory = Math.Max(netMemoryCounter.NextSample().RawValue / 1024, maxNetMemory);
maxPrivateWorkingSet = Math.Max(privateByteCounter.NextSample().RawValue / 1024, maxPrivateWorkingSet);
Thread.Sleep(100);
}
privateByteCounter.Dispose();
netMemoryCounter.Dispose();
}
