Erhalten Sie die Durchschnittliche CPU-Auslastung des Computers in den letzten x Minuten

Diese Frage "Wie man die CPU-Auslastung in C#?" zeigt einige der Möglichkeiten, um die aktuelle CPU-Auslastung (%) von einem computer .NET.

Da die CPU-Auslastung schwankt Recht Häufig, ich denke, die aktuelle CPU-Auslastung ist oft kein guter Indikator für damit beschäftigt, wie ein computer (z.B. für die Terminierung oder load-balancing-Zwecke). Gibt es eine effiziente Möglichkeit, um die Durchschnittliche CPU-Auslastung in den letzten x Minuten, z.B. Letzte 5 Minuten?

Ich denke an so etwas wie eine Methode GetAverageCpuUsage(int Periode), die aufgerufen werden können durch ein load-balancing und scheduling-Modul.

InformationsquelleAutor Louis Rhys | 2013-02-05
  1. 5

    Tatsächlich, das ist genau das, was PerformanceCounter von der 2. die meisten von Ihnen positiv bewertet werden Antwort in der anderen Frage hat sich erledigt, Sie sind nur die Messung über 1 Sekunde.

    Den % es gibt Sie ist der Durchschnitt der cpu-seance der letzten NextValue() gemacht wurde, auf den Tresen. Also, wenn Sie möchten, dass die Durchschnittliche cpu in den letzten 5 min haben, rufen Sie einfach NextValue() nur einmal alle 5 min.

    Hier ist ein guter Artikel welche erklären, wie der Leistungsindikatoren.

    • In diesem Ansatz, müssen Sie wissen, Wann NextValue() das erste mal. In meinem Fall ist das das problem, weil ich will GetAverageCpuUsage werden auf Anfrage zur Verfügung und können angerufen werden.
    • Das problem ist, es hält nicht historische Belege für Sie. Sie könnten NextSample anstelle von NextValue regelmäßig dann tun die Mathematik selbst (end value - start value)/(end time - start time) vor, es wäre deine Programme Verantwortung zum speichern dieser Wert so einige andere user könnten query es und könnte es nachschlagen in der Datenbank und berechnen Sie den Wert..
    • Eine weitere option ist ein Zähler eingerichtet in windows, um ein rolling log-Datei und der Abfrage der Datei, für die letzten 5 min der Daten.
    • der Unterschied zwischen NextSample und NextValue? Übrigens, danke für die Antwort +1
    • NextSample gibt Ihnen die raw-Daten als struct. Sie können dann die Eigenschaften des struct (Zeitstempel der Probe und der numerische Wert zugeordnet ist, der Zähler), dann die "start - Ende" value Methode, die ich bereits in meinem ersten Kommentar.
    • Siehe Beispiel-code in dieser MSDN-Seite, um es zu sehen im Einsatz.

    InformationsquelleAutor Scott Chamberlain
  2. 1

    Den oben genannten Antworten geben ein gutes Beispiel für eine Möglichkeit zum berechnen der CPU-Auslastung.Aber ich möchte darauf hinweisen, dass etwas falsch ist und in die Irre geführt wurde. Die SubtractTimes Funktion muss etwas anders sein.

    private UInt64 SubtractTimes(ComTypes.FILETIME a, ComTypes.FILETIME b)
    {
        UInt64 aInt = ((UInt64)(a.dwHighDateTime << 32)) | (UInt32)a.dwLowDateTime;
        UInt64 bInt = ((UInt64)(b.dwHighDateTime << 32)) | (UInt32)b.dwLowDateTime;

        return aInt - bInt;
    }

    BEMERKEN UINT32 für die lowDateTime. Dies ist, weil, wenigstens in C#, die comtype.FILETIME-Struktur wirft den DWORD-Wert in ein int32-Wert, so dass, wenn der Wert mehr als MAX signed Int Sie finden einen negativen Wert, das sollte nie der Fall sein. Wenn Sie werfen diese direkt zu "UINT64" - Typ, der intern für die Erhaltung dieses Zeichen umgewandelt, Int64 ersten und dann in UInt64 Sie sehen also einen falschen Wert. Stattdessen wollen Sie warf die lowDateTime zu einem Uint32-Typ, um loszuwerden, die negativen Zeichen, und dann gegossen, um UInt64 (dies würde automatisch passieren, da es Teil von | Betrieb). Dasselbe sollte für die dwHighDateTime conponent, aber das ist in Ordnung, da sollten es nicht mehr als MaxInt in der Regel (gut, das hängt wieder von deinen Anwendungsfall).

    InformationsquelleAutor dharu
  3. 0

    probieren Sie etwas wie:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using ComTypes = System.Runtime.InteropServices.ComTypes;
using System.Threading;
using System.Diagnostics;

namespace example1
{
    public class CpuUsage
    {
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool GetSystemTimes(
                    out ComTypes.FILETIME lpIdleTime,
                    out ComTypes.FILETIME lpKernelTime,
                    out ComTypes.FILETIME lpUserTime
                    );

        ComTypes.FILETIME _prevSysKernel;
        ComTypes.FILETIME _prevSysUser;

        TimeSpan _prevProcTotal;

        Int16 _cpuUsage;
        DateTime _lastRun;
        long _runCount;

        public CpuUsage()
        {
            _cpuUsage = -1;
            _lastRun = DateTime.MinValue;
            _prevSysUser.dwHighDateTime = _prevSysUser.dwLowDateTime = 0;
            _prevSysKernel.dwHighDateTime = _prevSysKernel.dwLowDateTime = 0;
            _prevProcTotal = TimeSpan.MinValue;
            _runCount = 0;
        }

        public short GetUsage()
        {
            short cpuCopy = _cpuUsage;
            if (Interlocked.Increment(ref _runCount) == 1)
            {
                if (!EnoughTimePassed)
                {
                    Interlocked.Decrement(ref _runCount);
                    return cpuCopy;
                }

                ComTypes.FILETIME sysIdle, sysKernel, sysUser;
                TimeSpan procTime;

                Process process = Process.GetCurrentProcess();
                procTime = process.TotalProcessorTime;

                if (!GetSystemTimes(out sysIdle, out sysKernel, out sysUser))
                {
                    Interlocked.Decrement(ref _runCount);
                    return cpuCopy;
                }

                if (!IsFirstRun)
                {
                    UInt64 sysKernelDiff = SubtractTimes(sysKernel, _prevSysKernel);
                    UInt64 sysUserDiff = SubtractTimes(sysUser, _prevSysUser);

                    UInt64 sysTotal = sysKernelDiff + sysUserDiff;

                    Int64 procTotal = procTime.Ticks - _prevProcTotal.Ticks;

                    if (sysTotal > 0)
                    {
                        _cpuUsage = (short)((100.0 * procTotal) / sysTotal);
                    }
                }

                _prevProcTotal = procTime;
                _prevSysKernel = sysKernel;
                _prevSysUser = sysUser;

                _lastRun = DateTime.Now;

                cpuCopy = _cpuUsage;
            }
            Interlocked.Decrement(ref _runCount);

            return cpuCopy;

        }

        private UInt64 SubtractTimes(ComTypes.FILETIME a, ComTypes.FILETIME b)
        {
            UInt64 aInt = ((UInt64)(a.dwHighDateTime << 32)) | (UInt64)a.dwLowDateTime;
            UInt64 bInt = ((UInt64)(b.dwHighDateTime << 32)) | (UInt64)b.dwLowDateTime;

            return aInt - bInt;
        }

        private bool EnoughTimePassed
        {
            get
            {
                const int minimumElapsedMS = 250;
                TimeSpan sinceLast = DateTime.Now - _lastRun;
                return sinceLast.TotalMilliseconds > minimumElapsedMS;
            }
        }

        private bool IsFirstRun
        {
            get
            {
                return (_lastRun == DateTime.MinValue);
            }
        }
    }
}

    nachdem Sie es so gut in der ur-code:

       CpuUsage _cu = new CpuUsage();
   string cpuUsage = _cu.GetUsage();

    geholfen haben, auf etwas

    • Ich weiß nicht, warum Process process = Process.GetCurrentProcess(); procTime = Prozess.TotalProcessorTime; hier beteiligt ist. Ein anderes Beispiel nicht, verwenden Sie diese und anstatt: var thisTotal = thisKernel + thisUser; var totalSinceLast = thisTotal - pPrevTotal; var idleSinceLast = thisIdle - pPrevIdle; doppelte Bauhöhe = (double)idleSinceLast / (double)totalSinceLast; double Ladung = 1.0 - headroom; ich stellen Sie sich Ihr Beispiel berechnen, die cpu-Belastung des aktuellen Prozesses und nicht das system?
    InformationsquelleAutor Rafael Souza
Schreibe einen Kommentar