Apabila melihat status berjalan perkhidmatan dalam talian pada pelayan dalam talian, kebanyakan orang suka menggunakan arahan teratas terlebih dahulu untuk melihat penggunaan CPU keseluruhan sistem semasa. Sebagai contoh, untuk mesin rawak, maklumat penggunaan yang dipaparkan oleh arahan atas adalah seperti berikut:

Hasil keluaran ini adalah mudah untuk dikatakan, tetapi tidak begitu mudah untuk memahami segala-galanya walaupun rumit. Contohnya:

Soalan 1: Bagaimanakah output maklumat penggunaan mengikut bahagian atas dikira Adakah ia tepat?
Soalan 2: Lajur ni bagus Ia mengeluarkan overhed CPU semasa memproses?
Soalan 3: wa mewakili io wait, jadi adakah CPU sibuk atau melahu dalam tempoh ini?

Hari ini kami mempunyai kajian mendalam tentang statistik penggunaan cpu. Melalui kajian hari ini, anda bukan sahaja akan memahami butiran pelaksanaan statistik penggunaan CPU, tetapi juga mempunyai pemahaman yang lebih mendalam tentang penunjuk seperti tunggu bagus dan io.

Hari ini kita mulakan dengan pemikiran kita sendiri!

1. Fikirkan dulu

Mengetepikan pelaksanaan Linux, jika anda mempunyai keperluan berikut, anda mempunyai pelayan empat teras dengan empat proses berjalan padanya.

Membolehkan anda mereka bentuk dan mengira penggunaan CPU keseluruhan sistem Ia menyokong output seperti arahan teratas dan memenuhi keperluan berikut:

• Penggunaan CPU hendaklah setepat mungkin
• Ia adalah perlu untuk mencerminkan status CPU serta-merta pada tahap kedua sebanyak mungkin.

Anda boleh berhenti dan berfikir selama beberapa minit.

Okey, tamatkan pemikiran. Selepas memikirkannya, anda akan mendapati bahawa keperluan yang kelihatan mudah ini sebenarnya agak rumit.

Satu idea ialah menjumlahkan masa pelaksanaan semua proses dan kemudian membahagikannya dengan jumlah masa pelaksanaan sistem * 4.

Tiada masalah dengan idea ini Anda boleh menggunakan kaedah ini untuk mengira penggunaan CPU dalam jangka masa yang panjang, dan statistiknya cukup tepat.

Tetapi selagi anda telah menggunakan bahagian atas, anda akan tahu bahawa output penggunaan CPU oleh bahagian atas tidak tetap untuk masa yang lama, tetapi akan dikemas kini secara dinamik dalam unit 3 saat secara lalai (selang masa ini boleh ditetapkan menggunakan -d ). Penyelesaian kami boleh mencerminkan jumlah penggunaan, tetapi sukar untuk mencerminkan keadaan serta-merta ini. Anda mungkin fikir saya boleh mengiranya sebagai satu setiap 3 saat, bukan? Tetapi pada titik manakah tempoh 3 saat ini bermula. Butirannya sukar dikawal.

Inti kepada persoalan pemikiran sebelum ini ialah bagaimana menyelesaikan masalah serta-merta. Apabila ia datang kepada keadaan sementara, anda mungkin mempunyai idea lain. Kemudian saya akan menggunakan pensampelan segera untuk melihat berapa banyak teras yang sedang sibuk. Jika dua daripada empat teras sibuk, penggunaannya ialah 50%.

Jalur pemikiran ini juga ke arah yang betul, tetapi terdapat dua masalah:

• Nombor yang anda kira semuanya adalah gandaan 25%;
• Nilai serta-merta ini boleh menyebabkan perubahan liar dalam paparan penggunaan CPU.

Sebagai contoh, gambar di bawah:

Daripada keadaan serta-merta t1, penggunaan CPU sistem sudah pasti 100%, tetapi dari perspektif t2, penggunaan telah menjadi 0%. Idea ini berada dalam arah yang betul, tetapi jelas pengiraan kasar ini tidak dapat berfungsi dengan elegan seperti arahan teratas.

Mari kita perbaiki dan gabungkan dua idea di atas, mungkin kita boleh selesaikan masalah kita. Dari segi persampelan, kita tetapkan tempoh lebih halus, tetapi dari segi pengiraan, kita tetapkan tempoh itu lebih kasar.

Kami memperkenalkan konsep tempoh pakai, masa, seperti pensampelan setiap 1 milisaat. Jika CPU sedang berjalan pada saat pensampelan, 1 ms ini direkodkan seperti yang digunakan. Pada masa ini, penggunaan CPU serta-merta akan diperoleh dan disimpan.

Apabila mengira penggunaan CPU dalam masa 3 saat, seperti julat masa t1 dan t2 dalam gambar di atas. Kemudian tambah semua nilai serta-merta dalam tempoh ini dan ambil purata. Ini boleh menyelesaikan masalah di atas, statistiknya agak tepat, dan masalah nilai serta-merta berayun dengan kuat dan terlalu kasar (hanya boleh berubah dalam unit 25%) dapat dielakkan.

Sesetengah pelajar mungkin bertanya, bagaimana jika CPU bertukar antara dua persampelan, seperti yang ditunjukkan dalam gambar di bawah.

Apabila titik pensampelan semasa tiba, proses A baru sahaja selesai dilaksanakan Untuk masa yang singkat, ia tidak dikira oleh titik pensampelan sebelumnya, dan tidak boleh dikira kali ini. Untuk proses B, ia sebenarnya hanya bermula untuk tempoh yang singkat Nampaknya terlalu banyak untuk merekodkan semua 1 ms.

Masalah ini memang wujud, tetapi kerana pensampelan kami sekali 1 ms, dan apabila kami benar-benar menyemak dan menggunakannya, ia sekurang-kurangnya pada tahap kedua, yang akan merangkumi maklumat daripada beribu-ribu titik pensampelan, jadi ralat ini tidak Ia akan mempengaruhi pemahaman kita tentang keadaan keseluruhan.

Malah, inilah cara Linux mengira penggunaan CPU sistem. Walaupun mungkin terdapat ralat, ia sudah cukup untuk digunakan sebagai data statistik. Dari segi pelaksanaan, Linux mengumpul semua nilai serta-merta ke dalam data tertentu, dan bukannya menyimpan banyak salinan data serta-merta.

Seterusnya, mari kita masuk ke Linux untuk melihat pelaksanaan spesifiknya bagi statistik penggunaan CPU sistem.

2. Di manakah data penggunaan arahan atas

Pelaksanaan Linux yang kami nyatakan dalam bahagian sebelumnya adalah untuk mengumpul nilai segera???kepada data tertentu Nilai ini didedahkan kepada keadaan pengguna oleh kernel melalui fail pseudo /proc/stat. Linux menggunakannya semasa mengira penggunaan CPU sistem.

Secara keseluruhan, butiran dalaman bagi kerja arahan teratas ditunjukkan dalam rajah di bawah.

arahan atas mengakses /proc/stat untuk mendapatkan pelbagai nilai penggunaan CPU

• Inti memanggil fungsi stat_open untuk mengendalikan akses kepada /proc/stat;

• Data yang diakses oleh kernel berasal dari tatasusunan kernel_cpustat dan diringkaskan

• Cetak output ke mod pengguna.

Seterusnya, mari kembangkan setiap langkah dan lihat dengan lebih dekat.

Dengan menggunakan strace untuk mengesan pelbagai panggilan sistem bagi arahan atas, anda boleh melihat panggilannya ke fail.

#?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
...

“

Selain /proc/stat, terdapat juga /proc/{pid}/stat yang dipecahkan mengikut setiap proses, yang digunakan untuk mengira penggunaan cpu bagi setiap proses.

”

Inti mentakrifkan fungsi pemprosesan untuk setiap fail pseudo Kaedah pemprosesan fail /proc/stat ialah 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 mengandungi kaedah operasi yang sepadan dengan fail ini. Apabila fail /proc/stat dibuka, stat_open akan dipanggil. stat_open memanggil single_open_size dan show_stat dalam urutan untuk mengeluarkan kandungan data. Mari lihat kodnya:

//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));
?...
}

Dalam kod di atas, for_each_possible_cpu sedang merentasi pembolehubah kcpustat_cpu yang menyimpan data penggunaan cpu. Pembolehubah ini ialah pembolehubah percpu, yang menyediakan elemen tatasusunan untuk setiap teras logik. Ia menyimpan pelbagai acara yang sepadan dengan teras semasa, termasuk pengguna, bagus, sistem, idel, iowait, irq, softirq, dll.

Dalam gelung ini, tambahkan setiap penggunaan setiap teras. Akhirnya, data dikeluarkan melalui seq_put_decimal_ull.

Perhatikan bahawa dalam kernel, setiap kali sebenarnya direkodkan dalam nanosaat, tetapi semuanya ditukar kepada unit rentak apabila dikeluarkan. Bagi panjang unit rentak, kami akan memperkenalkannya dalam bahagian seterusnya. Ringkasnya, output /proc/stat dibaca daripada pembolehubah percpu kernel_cpustat.

Mari kita lihat apabila data dalam pembolehubah ini ditambah.

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

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

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

一個(gè)節(jié)拍的長度是多長時(shí)間，是通過 CONFIG_HZ 來定義的。它定義的方式是每一秒有幾次 timer interrupts。不同的系統(tǒng)中這個(gè)節(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)時(shí)間中斷到來的時(shí)候，都會(huì)調(diào)用 update_process_times 來更新系統(tǒng)時(shí)間。更新后的時(shí)間都存儲(chǔ)在我們前面提到的 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)行時(shí)間累積處理
?account_process_tick(p,?user_tick);
?...
}

這個(gè)函數(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)計(jì)用戶態(tài)時(shí)間
??account_user_time(p,?cputime);
?else?if?((p?!=?rq->idle)?||?(irq_count()?!=?HARDIRQ_OFFSET))
??//3.2?統(tǒng)計(jì)內(nèi)核態(tài)時(shí)間
??account_system_time(p,?HARDIRQ_OFFSET,?cputime);
?else
??//3.3?統(tǒng)計(jì)空閑時(shí)間
??account_idle_time(cputime);
}

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

3.1 用戶態(tài)時(shí)間統(tǒng)計(jì)

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

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

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

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

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

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

接著調(diào)用 task_group_account_field 來把時(shí)間加到前面我們用到的 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)時(shí)間統(tǒng)計(jì)

我們再來看內(nèi)核態(tài)時(shí)間是如何統(tǒng)計(jì)的，找到 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)的時(shí)間主要分 3 種情況進(jìn)行統(tǒng)計(jì)。

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

判斷好要加到哪個(gè)統(tǒng)計(jì)項(xiàng)中后，依次調(diào)用 account_system_index_time、task_group_account_field 來將這段時(shí)間加到內(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 空閑時(shí)間的累積

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

如果在采樣的瞬間，cpu 既不在內(nèi)核態(tài)也不在用戶態(tài)的話，就將當(dāng)前節(jié)拍的時(shí)間都累加到 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），如果是的話這段空閑時(shí)間會(huì)加到 iowait 中，否則就加到 idle 中。從這里，我們可以看到 iowait 其實(shí)是 cpu 的空閑時(shí)間，只不過是在等待 IO 完成而已。

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

四、總結(jié)

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

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

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

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

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

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

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

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

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

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

Atas ialah kandungan terperinci Bagaimanakah penggunaan CPU dikira dalam Linux?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!