Genaue Berechnung der CPU-Auslastung in Prozent angegeben, die in Linux?

Es ist eine Frage, die schon viele Male gefragt, aber es gibt keine gut unterstützt Antwort, die ich finden konnte.

Viele Leute empfehlen die Verwendung von top-Befehl, aber wenn du oben einmal (weil Sie ein script zum Beispiel das sammeln von Cpu-Auslastung alle 1 Sekunde), es wird immer das gleiche Cpu-Auslastung resultieren (Beispiel 1 Beispiel 2).

Eine genauere Möglichkeit zur Berechnung der CPU-Auslastung, durch das Lesen der Werte aus /proc/stataber die meisten Antworten verwenden, werden nur die ersten 4 Felder aus /proc/stat zu berechnen (ein Beispiel hier).

/proc/stat/ hat 10 Felder pro CPU-core als Linux-kernel 2.6.33!

Ich fand auch diese Präzise Berechnung der CPU-Auslastung in Linux mittels /proc/stat Frage, die zeigt sich das gleiche Problem, -dass die meisten anderen Fragen erst berücksichtigen, 4 aus den vielen Bereichen, aber immer noch die Antwort, die hier gegeben werden, beginnt mit "ich glaube" (nicht sicher), und außer, dass, es ist nur darum besorgt, dass die ersten 7 Felder (von 10 in /proc/stat/)

Diese perl-Skript verwendet, alle Felder zu berechnen, die CPU-Auslastung, die ich nicht wieder denke, dass ist richtig, nach einigen weiteren Untersuchung.

Nachdem er einen kurzen Blick in den kernel-code hierwie es aussieht, zum Beispiel guest_nice und guest fields sind immer zusammen mit nice und user (Sie sollten also nicht in der cpu-Auslastung Berechnung, da Sie in nice und user bereits Felder)

/*
 * Account guest cpu time to a process.
 * @p: the process that the cpu time gets accounted to
 * @cputime: the cpu time spent in virtual machine since the last update
 * @cputime_scaled: cputime scaled by cpu frequency
 */
static void account_guest_time(struct task_struct *p, cputime_t cputime,
                   cputime_t cputime_scaled)
{
    u64 *cpustat = kcpustat_this_cpu->cpustat;

    /* Add guest time to process. */
    p->utime += cputime;
    p->utimescaled += cputime_scaled;
    account_group_user_time(p, cputime);
    p->gtime += cputime;

    /* Add guest time to cpustat. */
    if (task_nice(p) > 0) {
        cpustat[CPUTIME_NICE] += (__force u64) cputime;
        cpustat[CPUTIME_GUEST_NICE] += (__force u64) cputime;
    } else {
        cpustat[CPUTIME_USER] += (__force u64) cputime;
        cpustat[CPUTIME_GUEST] += (__force u64) cputime;
    }
}

Also zu summieren, was eine präzise Methode zur Berechnung der CPU-Auslastung in Linux und die Felder werden in den Berechnungen berücksichtigt und wie (welche Felder sind zurückzuführen auf die idle-Zeit und der Felder, die nicht-Leerlauf)?

InformationsquelleAutor der Frage Vangelis Tasoulas | 2014-04-29

Gemäß der htop source-code zu der Zeit des Schreibens, meine Annahmen sieht, wie Sie sind gültig:

(siehe void ProcessList_scan(ProcessList* this) Funktion bei ProcessList.c)

//Guest time is already accounted in usertime
usertime = usertime - guest;                     # As you see here, it subtracts guest from user time
nicetime = nicetime - guestnice;                 # and guest_nice from nice time
//Fields existing on kernels >= 2.6
//(and RHEL's patched kernel 2.4...)
idlealltime = idletime + ioWait;                 # ioWait is added in the idleTime
systemalltime = systemtime + irq + softIrq;
virtalltime = guest + guestnice;
totaltime = usertime + nicetime + systemalltime + idlealltime + steal + virtalltime;

Und so, von der Felder in der ersten Zeile der /proc/stat: (siehe Abschnitt 1.8 auf Dokumentation)

     user    nice   system  idle      iowait irq   softirq  steal  guest  guest_nice
cpu  74608   2520   24433   1117073   6176   4054  0        0      0      0

Algorithmisch, können wir berechnen, die CPU-Auslastung Prozentsatz wie:

PrevIdle = previdle + previowait
Idle = idle + iowait

PrevNonIdle = prevuser + prevnice + prevsystem + previrq + prevsoftirq + prevsteal
NonIdle = user + nice + system + irq + softirq + steal

PrevTotal = PrevIdle + PrevNonIdle
Total = Idle + NonIdle

# differentiate: actual value minus the previous one
totald = Total - PrevTotal
idled = Idle - PrevIdle

CPU_Percentage = (totald - idled)/totald

InformationsquelleAutor der Antwort Vangelis Tasoulas

Folgende ist ein bash-Skript, basierend auf Vangelis ' s Antwort. Es erzeugt eine Ausgabe wie diese:

total 49.1803
cpu0 14.2857
cpu1 100
cpu2 28.5714
cpu3 100
cpu4 30
cpu5 25

Erstellen Sie eine Datei namens get_cpu_usage.sh

Führen Sie es mithilfe des folgenden Befehls: bash get_cpu_usage.sh 0.2

Argument ist die Anzahl von Sekunden zu Messen. In diesem Fall sind es 200 Millisekunden.

Den Inhalt:

#!/bin/sh

sleepDurationSeconds=$1

previousDate=$(date +%s%N | cut -b1-13)
previousStats=$(cat /proc/stat)

sleep $sleepDurationSeconds

currentDate=$(date +%s%N | cut -b1-13)
currentStats=$(cat /proc/stat)    

cpus=$(echo "$currentStats" | grep -P 'cpu' | awk -F " " '{print $1}')

for cpu in $cpus
do
    currentLine=$(echo "$currentStats" | grep "$cpu ")
    user=$(echo "$currentLine" | awk -F " " '{print $2}')
    nice=$(echo "$currentLine" | awk -F " " '{print $3}')
    system=$(echo "$currentLine" | awk -F " " '{print $4}')
    idle=$(echo "$currentLine" | awk -F " " '{print $5}')
    iowait=$(echo "$currentLine" | awk -F " " '{print $6}')
    irq=$(echo "$currentLine" | awk -F " " '{print $7}')
    softirq=$(echo "$currentLine" | awk -F " " '{print $8}')
    steal=$(echo "$currentLine" | awk -F " " '{print $9}')
    guest=$(echo "$currentLine" | awk -F " " '{print $10}')
    guest_nice=$(echo "$currentLine" | awk -F " " '{print $11}')

    previousLine=$(echo "$previousStats" | grep "$cpu ")
    prevuser=$(echo "$previousLine" | awk -F " " '{print $2}')
    prevnice=$(echo "$previousLine" | awk -F " " '{print $3}')
    prevsystem=$(echo "$previousLine" | awk -F " " '{print $4}')
    previdle=$(echo "$previousLine" | awk -F " " '{print $5}')
    previowait=$(echo "$previousLine" | awk -F " " '{print $6}')
    previrq=$(echo "$previousLine" | awk -F " " '{print $7}')
    prevsoftirq=$(echo "$previousLine" | awk -F " " '{print $8}')
    prevsteal=$(echo "$previousLine" | awk -F " " '{print $9}')
    prevguest=$(echo "$previousLine" | awk -F " " '{print $10}')
    prevguest_nice=$(echo "$previousLine" | awk -F " " '{print $11}')    

    PrevIdle=$((previdle + previowait))
    Idle=$((idle + iowait))

    PrevNonIdle=$((prevuser + prevnice + prevsystem + previrq + prevsoftirq + prevsteal))
    NonIdle=$((user + nice + system + irq + softirq + steal))

    PrevTotal=$((PrevIdle + PrevNonIdle))
    Total=$((Idle + NonIdle))

    totald=$((Total - PrevTotal))
    idled=$((Idle - PrevIdle))

    CPU_Percentage=$(awk "BEGIN {print ($totald - $idled)/$totald*100}")

    if [[ "$cpu" == "cpu" ]]; then
        echo "total "$CPU_Percentage
    else
        echo $cpu" "$CPU_Percentage
    fi
done

InformationsquelleAutor der Antwort Fidel

Hey, ich war auch der recherche für das Thema und fand diesen thread sehr hilfreich. Ich verwendet Vangelis Tasoulas Formel schreiben Sie eine kleine python-Skript für diese. Befestigt ist mein Python-code für die Ausgabe. Es lädt die cpu-Auslastung pro cpu_id jede Sekunde. Vielleicht hilft das anderen auch. Auch Kommentare/Vorschläge sind willkommen 🙂

#!/usr/bin/python 
# -*- coding: utf-8 -*-

'''
Created on 04.12.2014

@author: plagtag
'''
from time import sleep
import sys

class GetCpuLoad(object):
    '''
    classdocs
    '''


    def __init__(self, percentage=True, sleeptime = 1):
        '''
        @parent class: GetCpuLoad
        @date: 04.12.2014
        @author: plagtag
        @info: 
        @param:
        @return: CPU load in percentage
        '''
        self.percentage = percentage
        self.cpustat = '/proc/stat'
        self.sep = ' ' 
        self.sleeptime = sleeptime

    def getcputime(self):
        '''
        http://stackoverflow.com/questions/23367857/accurate-calculation-of-cpu-usage-given-in-percentage-in-linux
        read in cpu information from file
        The meanings of the columns are as follows, from left to right:
            0cpuid: number of cpu
            1user: normal processes executing in user mode
            2nice: niced processes executing in user mode
            3system: processes executing in kernel mode
            4idle: twiddling thumbs
            5iowait: waiting for I/O to complete
            6irq: servicing interrupts
            7softirq: servicing softirqs

        #the formulas from htop 
             user    nice   system  idle      iowait irq   softirq  steal  guest  guest_nice
        cpu  74608   2520   24433   1117073   6176   4054  0        0      0      0


        Idle=idle+iowait
        NonIdle=user+nice+system+irq+softirq+steal
        Total=Idle+NonIdle # first line of file for all cpus

        CPU_Percentage=((Total-PrevTotal)-(Idle-PrevIdle))/(Total-PrevTotal)
        '''
        cpu_infos = {} #collect here the information
        with open(self.cpustat,'r') as f_stat:
            lines = [line.split(self.sep) for content in f_stat.readlines() for line in content.split('\n') if line.startswith('cpu')]

            #compute for every cpu
            for cpu_line in lines:
                if '' in cpu_line: cpu_line.remove('')#remove empty elements
                cpu_line = [cpu_line[0]]+[float(i) for i in cpu_line[1:]]#type casting
                cpu_id,user,nice,system,idle,iowait,irq,softrig,steal,guest,guest_nice = cpu_line

                Idle=idle+iowait
                NonIdle=user+nice+system+irq+softrig+steal

                Total=Idle+NonIdle
                #update dictionionary
                cpu_infos.update({cpu_id:{'total':Total,'idle':Idle}})
            return cpu_infos

    def getcpuload(self):
        '''
        CPU_Percentage=((Total-PrevTotal)-(Idle-PrevIdle))/(Total-PrevTotal)

        '''
        start = self.getcputime()
        #wait a second
        sleep(self.sleeptime)
        stop = self.getcputime()

        cpu_load = {}

        for cpu in start:
            Total = stop[cpu]['total']
            PrevTotal = start[cpu]['total']

            Idle = stop[cpu]['idle']
            PrevIdle = start[cpu]['idle']
            CPU_Percentage=((Total-PrevTotal)-(Idle-PrevIdle))/(Total-PrevTotal)*100
            cpu_load.update({cpu: CPU_Percentage})
        return cpu_load


if __name__=='__main__':
    x = GetCpuLoad()
    while True:
        try:
            data = x.getcpuload()
            print data
        except KeyboardInterrupt:

            sys.exit("Finished")

InformationsquelleAutor der Antwort PlagTag

1

idnt.net hat eine gute Beschreibung zur Verwendung der /proc/stat cpu-Daten umfassen ein bash-Skript zum extrahieren von cpu und Beschreibung der Zeilen. Ich wollte nur den link hier, da fand ich es wertvoll.

InformationsquelleAutor der Antwort arberg

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.