Beim Beobachten des Betriebsstatus von Online-Diensten auf einem Online-Server verwenden die meisten Leute gerne zuerst den oberen Befehl, um die Gesamt-CPU-Auslastung des aktuellen Systems zu sehen. Für eine Zufallsmaschine lauten die vom Befehl top angezeigten Auslastungsinformationen beispielsweise wie folgt:

Dieses Ausgabeergebnis ist gelinde gesagt einfach, aber es ist nicht so einfach, alles zu verstehen, auch wenn es komplex ist. Zum Beispiel:

Frage 1: Wie werden die von top ausgegebenen Nutzungsinformationen berechnet?
Frage 2: Die ni-Spalte gibt den CPU-Overhead bei der Verarbeitung aus?
Frage 3: wa steht für io wait. Ist die CPU also w?hrend dieser Zeit besch?ftigt oder im Leerlauf?

Heute haben wir eine ausführliche Studie zur CPU-Auslastungsstatistik. Durch die heutige Studie werden Sie nicht nur die Implementierungsdetails der CPU-Auslastungsstatistik verstehen, sondern auch ein tieferes Verst?ndnis für Indikatoren wie ?nice“ und ?io wait“ erhalten.

Heute beginnen wir mit unseren eigenen Gedanken!

1. Denken Sie zuerst darüber nach

Wenn Sie die Linux-Implementierung einmal au?er Acht lassen, verfügen Sie, wenn Sie die folgenden Anforderungen haben, über einen Quad-Core-Server, auf dem vier Prozesse laufen.

Erm?glicht das Entwerfen und Berechnen der CPU-Auslastung des gesamten Systems. Es unterstützt die Ausgabe wie der Top-Befehl und erfüllt die folgenden Anforderungen:

• Die CPU-Auslastung sollte so genau wie m?glich sein
• Es ist notwendig, den aktuellen CPU-Status so weit wie m?glich auf der zweiten Ebene widerzuspiegeln.

Du kannst ein paar Minuten innehalten und nachdenken.

Okay, Schluss mit dem Nachdenken. Wenn Sie darüber nachdenken, werden Sie feststellen, dass diese scheinbar einfache Anforderung tats?chlich etwas kompliziert ist.

Eine Idee besteht darin, die Ausführungszeit aller Prozesse zu addieren und sie dann durch die gesamte Systemausführungszeit * 4 zu dividieren.

Mit dieser Idee ist es kein Problem, mit dieser Methode die CPU-Auslastung über einen l?ngeren Zeitraum zu z?hlen, und die Statistiken sind genau genug.

Aber solange Sie top verwendet haben, wissen Sie, dass die von top ausgegebene CPU-Auslastung nicht über einen l?ngeren Zeitraum konstant ist, sondern standardm??ig in Einheiten von 3 Sekunden dynamisch aktualisiert wird (dieses Zeitintervall kann mit -d eingestellt werden). ). Unsere L?sung kann die Gesamtauslastung widerspiegeln, es ist jedoch schwierig, diesen momentanen Zustand abzubilden. Du denkst vielleicht, dass ich es alle 3 Sekunden als eins z?hlen kann, oder? Aber ab wann beginnt dieser 3-Sekunden-Zeitraum? Die Granularit?t ist schwer zu kontrollieren.

Der Kern der vorherigen Denkfrage besteht darin, wie man unmittelbare Probleme l?st. Wenn es um den übergangszustand geht, haben Sie vielleicht eine andere Idee. Dann nutze ich das Instant Sampling, um zu sehen, wie viele Kerne gerade ausgelastet sind. Sind zwei der vier Kerne ausgelastet, liegt die Auslastung bei 50 %.

Diese Denkweise geht auch in die richtige Richtung, aber es gibt zwei Probleme:

• Die von Ihnen berechneten Zahlen sind alle Vielfache von 25 %;
• Dieser Momentanwert kann zu starken Schwankungen in der CPU-Auslastungsanzeige führen.

Zum Beispiel das Bild unten:

Aus dem momentanen Zustand von t1 betr?gt die CPU-Auslastung des Systems zweifellos 100 %, aber aus der Perspektive von t2 betr?gt die Auslastung 0 %. Die Idee geht in die richtige Richtung, aber offensichtlich kann diese grobe Rechnung nicht so elegant funktionieren wie das Oberkommando.

Lassen Sie es uns verbessern und die beiden oben genannten Ideen kombinieren, vielleicht k?nnen wir unser Problem l?sen. In Bezug auf die Stichprobe legen wir den Zeitraum feiner fest, in Bezug auf die Berechnung legen wir den Zeitraum jedoch gr?ber fest.

Wir führen das Konzept des Einführungszeitraums und des Timings ein, z. B. die Probenahme alle 1 Millisekunde. Wenn die CPU zum Zeitpunkt der Abtastung l?uft, wird diese 1 ms als verbraucht erfasst. Zu diesem Zeitpunkt wird eine momentane CPU-Auslastung ermittelt und gespeichert.

Beim Z?hlen der CPU-Auslastung innerhalb von 3 Sekunden, z. B. im Zeitbereich t1 und t2 im Bild oben. Addieren Sie dann alle Momentanwerte w?hrend dieses Zeitraums und bilden Sie einen Durchschnitt. Dadurch kann das obige Problem gel?st werden, die Statistik ist relativ genau und das Problem, dass der Momentanwert stark schwankt und zu grobk?rnig ist (kann sich nur in Einheiten von 25 % ?ndern), wird vermieden.

Einige Schüler fragen sich vielleicht, was passiert, wenn sich die CPU zwischen zwei Stichproben ?ndert, wie im Bild unten gezeigt.

Wenn der aktuelle Abtastpunkt eintrifft, wurde die Ausführung von Prozess A gerade erst abgeschlossen. Er wurde vom vorherigen Abtastpunkt nicht gez?hlt und kann dieses Mal auch nicht gez?hlt werden. Bei Prozess B wurde er tats?chlich nur für kurze Zeit gestartet. Es scheint etwas zu viel zu sein, alle 1 ms aufzuzeichnen.

Dieses Problem besteht zwar, aber da unsere Abtastung einmal 1 ms betr?gt und wir sie tats?chlich überprüfen und verwenden, befindet sie sich mindestens auf der zweiten Ebene, die Informationen von Tausenden von Abtastpunkten enth?lt, sodass dieser Fehler nicht auftritt beeinflussen unser Verst?ndnis der Gesamtsituation.

Tats?chlich z?hlt Linux auf diese Weise die CPU-Auslastung des Systems. Obwohl es Fehler geben kann, reicht es aus, als statistische Daten verwendet zu werden. In Bezug auf die Implementierung akkumuliert Linux alle Momentanwerte in bestimmten Daten, anstatt tats?chlich viele Kopien der Momentandaten zu speichern.

Als n?chstes betreten wir Linux, um die spezifische Implementierung der System-CPU-Auslastungsstatistiken zu sehen.

2. Wo sind die Nutzungsdaten von Top Command? Die im vorherigen Abschnitt erw?hnte Implementierung von Linux besteht darin, Momentanwerte zu bestimmten Daten zu akkumulieren. Dieser Wert wird vom Kernel über die Pseudodatei /proc/stat dem Benutzerstatus ausgesetzt. Linux verwendet es bei der Berechnung der CPU-Auslastung des Systems.

Insgesamt sind die internen Details der Top-Befehlsarbeit in der folgenden Abbildung dargestellt.

• top-Befehl greift auf /proc/stat zu, um verschiedene CPU-Auslastungswerte zu erhalten

Der Kernel ruft die Funktion stat_open auf, um den Zugriff auf /proc/stat;
• zu verwalten

Die Daten, auf die der Kernel zugreift, stammen aus dem Array kernel_cpustat und werden zusammengefasst
Ausgabe im Benutzermodus drucken.
Als n?chstes wollen wir jeden Schritt n?her erl?utern und einen genaueren Blick darauf werfen.

Indem Sie strace verwenden, um die verschiedenen Systemaufrufe des Top-Befehls zu verfolgen, k?nnen Sie dessen Aufrufe an die Datei sehen.

#?strace?top
...
openat(AT_FDCWD,?"/proc/stat",?O_RDONLY)?=?4
openat(AT_FDCWD,?"/proc/2351514/stat",?O_RDONLY)?=?8
openat(AT_FDCWD,?"/proc/2393539/stat",?O_RDONLY)?=?8
...

“

Zus?tzlich zu /proc/stat gibt es auch /proc/{pid}/stat, aufgeschlüsselt nach jedem Prozess, der zur Berechnung der CPU-Auslastung jedes Prozesses verwendet wird.

“

Der Kernel definiert Verarbeitungsfunktionen für jede Pseudodatei. Die Verarbeitungsmethode der Datei /proc/stat ist proc_stat_operations.

//file:fs/proc/stat.c
static?int?__init?proc_stat_init(void)
{
?proc_create("stat",?0,?NULL,?&proc_stat_operations);
?return?0;
}

static?const?struct?file_operations?proc_stat_operations?=?{
?.open??=?stat_open,
?...
};

proc_stat_operations enth?lt die dieser Datei entsprechenden Operationsmethoden. Wenn die Datei /proc/stat ge?ffnet wird, wird stat_open aufgerufen. stat_open ruft nacheinander single_open_size und show_stat auf, um den Dateninhalt auszugeben. Werfen wir einen Blick auf den Code:

//file:fs/proc/stat.c
static?int?show_stat(struct?seq_file?*p,?void?*v)
{
?u64?user,?nice,?system,?idle,?iowait,?irq,?softirq,?steal;

?for_each_possible_cpu(i)?{
??struct?kernel_cpustat?*kcs?=?&kcpustat_cpu(i);

??user?+=?kcs->cpustat[CPUTIME_USER];
??nice?+=?kcs->cpustat[CPUTIME_NICE];
??system?+=?kcs->cpustat[CPUTIME_SYSTEM];
??idle?+=?get_idle_time(kcs,?i);
??iowait?+=?get_iowait_time(kcs,?i);
??irq?+=?kcs->cpustat[CPUTIME_IRQ];
??softirq?+=?kcs->cpustat[CPUTIME_SOFTIRQ];
??...
?}

?//轉(zhuǎn)換成節(jié)拍數(shù)并打印出來
?seq_put_decimal_ull(p,?"cpu??",?nsec_to_clock_t(user));
?seq_put_decimal_ull(p,?"?",?nsec_to_clock_t(nice));
?seq_put_decimal_ull(p,?"?",?nsec_to_clock_t(system));
?seq_put_decimal_ull(p,?"?",?nsec_to_clock_t(idle));
?seq_put_decimal_ull(p,?"?",?nsec_to_clock_t(iowait));
?seq_put_decimal_ull(p,?"?",?nsec_to_clock_t(irq));
?seq_put_decimal_ull(p,?"?",?nsec_to_clock_t(softirq));
?...
}

Im obigen Code durchl?uft for_each_possible_cpu die Variable kcpustat_cpu, die CPU-Nutzungsdaten speichert. Bei dieser Variablen handelt es sich um eine Percpu-Variable, die für jeden logischen Kern ein Array-Element vorbereitet. Es speichert verschiedene Ereignisse, die dem aktuellen Kern entsprechen, einschlie?lich Benutzer, Nice, System, Idel, Iowait, IRQ, Softirq usw.

In dieser Schleife addieren Sie jede Nutzung jedes Kerns. Schlie?lich werden die Daten über seq_put_decimal_ull ausgegeben.

Beachten Sie, dass im Kernel jede Zeit tats?chlich in Nanosekunden aufgezeichnet wird, bei der Ausgabe jedoch alle in Beat-Einheiten umgewandelt werden. Was die L?nge der Beat-Einheit betrifft, werden wir sie im n?chsten Abschnitt vorstellen. Kurz gesagt, die Ausgabe von /proc/stat wird aus der Percpu-Variablen kernel_cpustat gelesen.

Sehen wir uns an, wann die Daten in dieser Variablen hinzugefügt werden.

三、統(tǒng)計數(shù)據(jù)怎么來的

前面我們提到內(nèi)核是以采樣的方式來統(tǒng)計 cpu 使用率的。這個采樣周期依賴的是 Linux 時間子系統(tǒng)中的定時器。

Linux 內(nèi)核每隔固定周期會發(fā)出 timer interrupt (IRQ 0)，這有點(diǎn)像樂譜中的節(jié)拍的概念。每隔一段時間，就打出一個拍子，Linux 就響應(yīng)之并處理一些事情。

一個節(jié)拍的長度是多長時間，是通過 CONFIG_HZ 來定義的。它定義的方式是每一秒有幾次 timer interrupts。不同的系統(tǒng)中這個節(jié)拍的大小可能不同，通常在 1 ms 到 10 ms 之間?？梢栽谧约旱?Linux config 文件中找到它的配置。

#?grep?^CONFIG_HZ?/boot/config-5.4.56.bsk.10-amd64
CONFIG_HZ=1000

從上述結(jié)果中可以看出，我的機(jī)器每秒要打出 1000 次節(jié)拍。也就是每 1 ms 一次。

每次當(dāng)時間中斷到來的時候，都會調(diào)用 update_process_times 來更新系統(tǒng)時間。更新后的時間都存儲在我們前面提到的 percpu 變量 kcpustat_cpu 中。

我們來詳細(xì)看下匯總過程 update_process_times 的源碼，它位于 kernel/time/timer.c 文件中。

//file:kernel/time/timer.c
void?update_process_times(int?user_tick)
{
?struct?task_struct?*p?=?current;

?//進(jìn)行時間累積處理
?account_process_tick(p,?user_tick);
?...
}

這個函數(shù)的參數(shù) user_tick 指的是采樣的瞬間是處于內(nèi)核態(tài)還是用戶態(tài)。接下來調(diào)用 account_process_tick。

//file:kernel/sched/cputime.c
void?account_process_tick(struct?task_struct?*p,?int?user_tick)
{
?cputime?=?TICK_NSEC;
?...

?if?(user_tick)
??//3.1?統(tǒng)計用戶態(tài)時間
??account_user_time(p,?cputime);
?else?if?((p?!=?rq->idle)?||?(irq_count()?!=?HARDIRQ_OFFSET))
??//3.2?統(tǒng)計內(nèi)核態(tài)時間
??account_system_time(p,?HARDIRQ_OFFSET,?cputime);
?else
??//3.3?統(tǒng)計空閑時間
??account_idle_time(cputime);
}

在這個函數(shù)中，首先設(shè)置 cputime = TICK_NSEC, 一個 TICK_NSEC 的定義是一個節(jié)拍所占的納秒數(shù)。接下來根據(jù)判斷結(jié)果分別執(zhí)行 account_user_time、account_system_time 和 account_idle_time 來統(tǒng)計用戶態(tài)、內(nèi)核態(tài)和空閑時間。

3.1 用戶態(tài)時間統(tǒng)計

//file:kernel/sched/cputime.c
void?account_user_time(struct?task_struct?*p,?u64?cputime)
{
?//分兩種種情況統(tǒng)計用戶態(tài)?CPU?的使用情況
?int?index;
?index?=?(task_nice(p)?>?0)???CPUTIME_NICE?:?CPUTIME_USER;

?//將時間累積到?/proc/stat?中
?task_group_account_field(p,?index,?cputime);
?......
}

account_user_time 函數(shù)主要分兩種情況統(tǒng)計：

• 如果進(jìn)程的 nice 值大于 0，那么將會增加到 CPU 統(tǒng)計結(jié)構(gòu)的 nice 字段中。
• 如果進(jìn)程的 nice 值小于等于 0，那么增加到 CPU 統(tǒng)計結(jié)構(gòu)的 user 字段中。

看到這里，開篇的問題 2 就有答案了，其實用戶態(tài)的時間不只是 user 字段，nice 也是。之所以要把 nice 分出來，是為了讓 Linux 用戶更一目了然地看到調(diào)過 nice 的進(jìn)程所占的 cpu 周期有多少。

我們平時如果想要觀察系統(tǒng)的用戶態(tài)消耗的時間的話，應(yīng)該是將 top 中輸出的 user 和 nice 加起來一并考慮，而不是只看 user！

接著調(diào)用 task_group_account_field 來把時間加到前面我們用到的 kernel_cpustat 內(nèi)核變量中。

//file:kernel/sched/cputime.c
static?inline?void?task_group_account_field(struct?task_struct?*p,?int?index,
??????u64?tmp)
{
?__this_cpu_add(kernel_cpustat.cpustat[index],?tmp);
?...
}

3.2 內(nèi)核態(tài)時間統(tǒng)計

我們再來看內(nèi)核態(tài)時間是如何統(tǒng)計的，找到 account_system_time 的代碼。

//file:kernel/sched/cputime.c
void?account_system_time(struct?task_struct?*p,?int?hardirq_offset,?u64?cputime)
{
?if?(hardirq_count()?-?hardirq_offset)
??index?=?CPUTIME_IRQ;
?else?if?(in_serving_softirq())
??index?=?CPUTIME_SOFTIRQ;
?else
??index?=?CPUTIME_SYSTEM;

?account_system_index_time(p,?cputime,?index);
}

內(nèi)核態(tài)的時間主要分 3 種情況進(jìn)行統(tǒng)計。

• 如果當(dāng)前處于硬中斷執(zhí)行上下文, 那么統(tǒng)計到 irq 字段中；
• 如果當(dāng)前處于軟中斷執(zhí)行上下文, 那么統(tǒng)計到 softirq 字段中；
• 否則統(tǒng)計到 system 字段中。

判斷好要加到哪個統(tǒng)計項中后，依次調(diào)用 account_system_index_time、task_group_account_field 來將這段時間加到內(nèi)核變量 kernel_cpustat 中。

//file:kernel/sched/cputime.c
static?inline?void?task_group_account_field(struct?task_struct?*p,?int?index,
??????u64?tmp)
{?
?__this_cpu_add(kernel_cpustat.cpustat[index],?tmp);
}

3.3 空閑時間的累積

沒錯，在內(nèi)核變量 kernel_cpustat 中不僅僅是統(tǒng)計了各種用戶態(tài)、內(nèi)核態(tài)的使用時間，空閑也一并統(tǒng)計起來了。

如果在采樣的瞬間，cpu 既不在內(nèi)核態(tài)也不在用戶態(tài)的話，就將當(dāng)前節(jié)拍的時間都累加到 idle 中。

//file:kernel/sched/cputime.c
void?account_idle_time(u64?cputime)
{
?u64?*cpustat?=?kcpustat_this_cpu->cpustat;
?struct?rq?*rq?=?this_rq();

?if?(atomic_read(&rq->nr_iowait)?>?0)
??cpustat[CPUTIME_IOWAIT]?+=?cputime;
?else
??cpustat[CPUTIME_IDLE]?+=?cputime;
}

在 cpu 空閑的情況下，進(jìn)一步判斷當(dāng)前是不是在等待 IO（例如磁盤 IO），如果是的話這段空閑時間會加到 iowait 中，否則就加到 idle 中。從這里，我們可以看到 iowait 其實是 cpu 的空閑時間，只不過是在等待 IO 完成而已。

看到這里，開篇問題 3 也有非常明確的答案了，io wait 其實是 cpu 在空閑狀態(tài)的一項統(tǒng)計，只不過這種狀態(tài)和 idle 的區(qū)別是 cpu 是因為等待 io 而空閑。

四、總結(jié)

本文深入分析了 Linux 統(tǒng)計系統(tǒng) CPU 利用率的內(nèi)部原理。全文的內(nèi)容可以用如下一張圖來匯總：

Linux 中的定時器會以某個固定節(jié)拍，比如 1 ms 一次采樣各個 cpu 核的使用情況，然后將當(dāng)前節(jié)拍的所有時間都累加到 user/nice/system/irq/softirq/io_wait/idle 中的某一項上。

top 命令是讀取的 /proc/stat 中輸出的 cpu 各項利用率數(shù)據(jù)，而這個數(shù)據(jù)在內(nèi)核中是根據(jù) kernel_cpustat 來匯總并輸出的。

回到開篇問題 1，top 輸出的利用率信息是如何計算出來的，它精確嗎？

/proc/stat 文件輸出的是某個時間點(diǎn)的各個指標(biāo)所占用的節(jié)拍數(shù)。如果想像 top 那樣輸出一個百分比，計算過程是分兩個時間點(diǎn) t1, t2 分別獲取一下 stat 文件中的相關(guān)輸出，然后經(jīng)過個簡單的算術(shù)運(yùn)算便可以算出當(dāng)前的 cpu 利用率。

再說是否精確。這個統(tǒng)計方法是采樣的，只要是采樣，肯定就不是百分之百精確。但由于我們查看 cpu 使用率的時候往往都是計算 1 秒甚至更長一段時間的使用情況，這其中會包含很多采樣點(diǎn)，所以查看整體情況是問題不大的。

另外從本文，我們也學(xué)到了 top 中輸出的 cpu 時間項目其實大致可以分為三類：

第****一類：用戶態(tài)消耗時間，包括 user 和 nice。如果想看用戶態(tài)的消耗，要將 user 和 nice 加起來看才對。

第二類：內(nèi)核態(tài)消耗時間，包括 irq、softirq 和 system。

第三類：空閑時間，包括 io_wait 和 idle。其中 io_wait 也是 cpu 的空閑狀態(tài)，只不過是在等 io 完成而已。如果只是想看 cpu 到底有多閑，應(yīng)該把 io_wait 和 idle 加起來才對。

---

Das obige ist der detaillierte Inhalt vonWie wird die CPU-Auslastung unter Linux berechnet?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!