Linux CPU佔用率原理與精確度分析

阿新 • • 發佈：2019-02-13

1 CPU佔用率計算原理

1.1 相關概念

在Linux/Unix 下，CPU 利用率分為使用者態、系統態和空閒態，  分別表示CPU 處於

使用者態執行的時間，系統核心執行的時間，和空閒系統程序執行的時間。
下面是幾個與CPU 佔用率相關的概念

CPU利用率

CPU 的使用情況。

使用者時間(User time)

表示CPU 執行使用者程序的時間，包括nices時間。通常期望使用者空間CPU 越高

越好。

系統時間(System time)

表示CPU 在核心執行時間，包括IRQ 和softirq 時間。系統CPU 佔用率高，表明

系統某部分存在瓶頸。通常值越低越好。

等待時間(Waiting time)

CPI 在等待I/O 操作完成所花費的時間。系統部應該花費大量時間來等待I/O 操

作，否則就說明I/O 存在瓶頸。

空閒時間(Idle time)

 系統處於空閒期，等待程序執行。

Nice時間(Nice time)

 系統調整程序優先順序所花費的時間。

硬中斷處理時間(Hard Irq time)

 系統處理硬中斷所花費的時間。

軟中斷處理時間(SoftIrq time)

 系統處理軟中斷中斷所花費的時間。

丟失時間(Steal time)

 被強制等待（involuntary wait ）虛擬 CPU 的時間，此時 hypervisor 在為另一個虛擬處理器服務。

下面是我們在top 命令看到的CPU 佔用率資訊及各項值含義。
Cpu(s): 0.2%us, 0.2%sy, 0.0%ni, 99.2%id, 0.5%wa, 0.0%hi, 0.0%si,
0.0%st
us: User time
sy: System time
ni: Nice time
id: Idle time
wa: Waiting time
hi: Hard Irq time
si: SoftIrq time
st: Steal time

1.2 CPU 佔用率計算

L inux CPU 佔用率計算，都是根據/proc/stat 檔案內容計算而來，下面是stat

檔案內容樣例，核心版本不同，會稍有不同，但內容基本一致。

CPU 資訊，cpu 為總的資訊，cpu0 … cpun 為各個具體CPU 資訊
cpu 661733 468 503925 233055573 548835 14244 15849 0

 上面共有8 個值（單位：ticks），分別為： 
 User time ， 661733                  Nice time ， 468 
 System time ， 503925              Idle time ，233055573 
 Waiting time，548835               Hard   Irq time ， 14244 
 SoftIRQ time，15849                Steal time，0 

 CPU佔用率計算公式如下：     
 CPU 時間=user+system+nice+idle+iowait+irq+softirq+Stl 
 %us =(User time + Nice time)/CPU時間*100% 
 %sy=(System time + Hard Irq time +SoftIRQ time)/CPU時間*100% 
 %id=(Idle time)/CPU 時間*100%

%ni=(Nice time)/CPU 時間*100%
%wa=(Waiting time)/CPU時間*100%
%hi=(Hard Irq time)/CPU 時間*100%
%si=(SoftIRQ time)/CPU時間*100%
%st=(Steal time)/CPU時間*100%

2 CPU佔用率核心實現

下面以RHEL6 核心原始碼版本2.6.32-220.el6 x86_64 為例，來介紹核心原始碼實現。
/proc/stat 檔案的建立由函式proc_stat_init（）實現，在檔案 fs/proc/stat.c 中，在核心
初始化時呼叫。/proc/stat 檔案相關函式時間均在stat.c 檔案中。
對/proc/stat 檔案的讀寫方法為proc_stat_operations。

static const struct file_operations  proc_stat_operations = { 
  .open =  stat_open,  
  .read =  seq_read ,  
  .llseek =  seq_lseek ,  
  .release =  single_release,  
};

開啟檔案函式stat_open（），函式首先申請大小為size 的記憶體，來存放臨時資料
（也是我們看到的stat 裡的最終資料）。

 static int s t at_ ope n( struct inode *inode ,  struct file  *file )  
 { 
  unsigned size = 4096  *  ( 1 + num_possible_cpus () /  32) ;  
  char * buf ;  
  struct seq_file *m ;  
  int  res ;  

  / * don't ask for more than the kma lloc() max size, currently 128 KB */ 
  if  ( size  > 128 *  1024)  
  size  = 128 *  1024;  
  buf  = kmalloc ( size ,  GFP_KERNEL );  
  if  ( !  buf)  
  return  -  ENOMEM;  

  res  = single_open( file ,  show_stat,  NULL);  
  if  ( !  res) { 
  m = file - >private_data ;  
  m- >buf  = buf;  
  m- >size  = size ;  
  }  else 
  kfree (buf);  
  return  res;  
 }  ?  end stat_open ?

/proc/stat 檔案的資料由show_stat（）函式填充。注意42行for_each_possible_cpu(i)
迴圈，是累加計算所有 CPU 的資料，如我們前面的示例看到的/proc/stat 檔案中第一行
cpu 值。
cpu 661733 468 503925 233055573 548835 14244 15849 0

 static int show_st a t( struct seq_file *p,  void * v)  
 { 
  int  i,  j ;  
  unsigned long jif;  
  cputime64_t  user,  nice,  system ,  idle ,  iowait,  irq ,  softirq, 
steal;  
  cputime64_t  guest ;  
  u64  sum = 0;  
  u64  sum_softirq = 0;  
  unsigned int  per_softirq_sums [ NR_SOFTIRQS]  = {0};  
  struct timespec boottime;  

  user = nice = system = idle  = iowait  =  
  irq  = softirq = steal = cputime64_zero;  
  guest  = cputime64_zero;  
  getboottime( &boottime );  
  jif = boottime .tv_sec;  

  for_each_possible_cpu ( i ) { 
  user = cputime64_add (user ,  kstat_cpu ( i ) .cpustat.user ) ;  
  nice = cputime64_add (nice ,  kstat_cpu ( i ) .cpustat.nice ) ;  
  system = cputime64_add (system,     
      kstat_cpu ( i ).cpustat.system ) ;  
  idle  = cputime64_add (idle ,  kstat_cpu ( i ) .cpustat.idle ) ;  
  idle  = cputime64_add (idle ,  arch_idle_time( i) ) ;  
  iowait  = cputime64_add (iowait ,     
       kstat_cpu ( i ).cpustat.iowait ) ;  
  irq  = cputime64_add (irq,  kstat_cpu ( i ) .cpustat.irq ); 
  softirq = cputime64_add (softirq ,  
       kstat_cpu ( i ).cpustat.softirq ) ;  
  steal = cputime64_add (steal,  kstat_cpu ( i ).cpustat.steal ) ;  
  guest  = cputime64_add (guest,     
       kstat_cpu ( i ).cpustat.guest) ;  
  sum +=  kstat_cpu_irqs_sum( i);  
  sum +=  arch_irq_stat_cpu( i );  

  for  ( j  = 0;  j  < NR_SOFTIRQS;  j++) { 
  unsigned int  softirq_stat = kstat_softirqs_cpu( j,  i );  

  per_softirq_sums [ j]  +=  softirq_stat ;  
  sum_softirq  +=  softirq_stat ;  
  } 
  } 
  sum +=  arch_irq_stat (); 

  seq_printf(p ,    
   "cpu    %llu %llu %llu %llu %l lu %llu %llu %llu %llun" ,  
  ( unsigned long long) cputime64_to_clock_t( user ),  
  ( unsigned long long) cputime64_to_clock_t( nice ),  
  ( unsigned long long) cputime64_to_clock_t( system),  
  ( unsigned long long) cputime64_to_clock_t( idle ),  
  ( unsigned long long) cputime64_to_clock_t( iowait ),  
  ( unsigned long long) cputime64_to_clock_t( irq),  
  ( unsigned long long) cputime64_to_clock_t( softirq ),  
  ( unsigned long long) cputime64_to_clock_t( steal),  
  ( unsigned long long) cputime64_to_clock_t( guest) ) ;

計算總的CPU 各個值user 、nice 、system、idle 、iowait 、irq、softirq 、steal後，
就分別計算各個CPU 的使用情況（75~100行）。

 for_each_online_cpu ( i ) { 

  / * Copy values here to work around gcc- 2.95.3, gcc- 2.96 */ 
  user = kstat_cpu ( i ) .cpustat.user ;  
  nice = kstat_cpu ( i ) .cpustat.nice ;  
  system = kstat_cpu ( i ) .cpustat.system ;  
  idle  = kstat_cpu ( i ) .cpustat.idle ; 
  idle  = cputime64_add (idle ,  arch_idle_time( i) ) ;  
  iowait  = kstat_cpu ( i ).cpustat.iowait ;  
  irq  = kstat_cpu ( i ) .cpustat.irq ;  
  softirq = kstat_cpu ( i ) .cpustat.softirq ;  
  steal = kstat_cpu ( i ) .cpustat.steal ;  
  guest  = kstat_cpu ( i ).cpustat.guest;  
  seq_printf( p ,  
              "cpu%d %llu %llu %llu %llu % llu %llu %llu %llu %llun" , 
  i ,  
  ( unsigned long long) cputime64_to_clock_t( user ),  
  ( unsigned long long) cputime64_to_clock_t( nice ),  
  ( unsigned long long) cputime64_to_clock_t( system),  
  ( unsigned long long) cputime64_to_clock_t( idle ),  
  ( unsigned long long) cputime64_to_clock_t( iowait ),  
  ( unsigned long long) cputime64_to_clock_t( irq),  
  ( unsigned long long) cputime64_to_clock_t( softirq ),  
  ( unsigned long long) cputime64_to_clock_t( steal),  
  ( unsigned long long) cputime64_to_clock_t( guest) ) ; 
  }

104 行計算所有CPU 上中斷次數，104~105行計算CPU 上每個中斷向量的
中斷次數。注意：/proc/stat 檔案中，將所有可能的 NR_IRQS箇中斷向量計數
都記錄下來，但我們的機器上通過只是用少量的中斷向量，這就是看到/proc/stat
檔案中，intr 一行後面很多值為0 的原因。
show_stat （）函式最後獲取程序切換次數nctxt、核心啟動的時間btime、
所有建立的程序processes、正在執行程序的數量 procs_running、阻塞的程序數
量procs_blocked和所有 io 等待的程序數量。

  seq_printf(p ,  "intr %llu" , (unsigned long long) sum ); 

  / * sum again ? it could be updated? */ 
  for_each_irq_nr( j)  
  seq_printf(p ,  " %u" ,  kstat_irqs( j) ) ;  

  seq_printf( p ,  
  "nctxt %llun" 
  "btime %lun" 
  "processes %lun" 
  "procs_running %lun" 
  "procs_blocked %lun",  
  nr_context_switches(), 
  ( unsigned long) jif ,  
  total_forks  ,  
  nr_running(), 
  nr_iowait () ) ;  

  seq_printf(p ,  "softirq %llu" , (unsigned long long) sum_softirq);  

  for  ( i  = 0;  i  < NR_SOFTIRQS;  i++)  
  seq_printf( p ,  " %u" ,  per_softirq_sums [ i ]); 
  seq_printf( p ,  "n" );  

  return  0; 
 }  ?  end show_stat ?

3 Linux CPU佔用率精確性分析

在使用類似top 命令，觀察系統及各程序CPU 佔用率時，可以指定重新整理時間間隔，
以及時重新整理和實時觀察CPU 佔用率。
top 命令預設情況下，是每 3 秒重新整理一次。也可以通過 top -d <重新整理時間間隔> 來
指定重新整理頻率，如top -d 0.1 或top -d 0.01 等。top 執行時，也可以按“s ”鍵，修改
時間間隔。
我們可以將CPU 佔用率重新整理間隔設定很低，如0.01 秒。但過低的重新整理頻率是否能
夠更準確觀察到CPU 佔用率？Linux 系統提供的CPU 佔用率資訊是否足夠精確？
根據前面分析，我們已知 Linux 是根據/proc/stat 檔案的內容來計算CPU 佔用率，也
就是精確度和/proc/stat 提供的資料精確度有關。那麼
（1）/proc/stat 檔案中的內容單位是什麼？
（2）多久會重新整理/proc/stat 中的資料？
cpu 926 0 4160 5894903 2028 0 7 0 0
cpu0 80 0 473 367723 658 0 3 0 0

3.1 /proc/stat中的資料單位精度

/proc/stat 中CPU 資料資訊，單位是ticks。核心中有個全域性變數jiffies ，來記錄系
統啟動以來，經歷的ticks 數量。
cpu1 13 0 200 368639 63 0 0 0 0

ticks（滴答）就是系統時鐘中斷的時間間隔，該值與核心中HZ值有關，即ticks =
1/HZ。HZ值的大小，在核心編譯時可配置的。某臺機器上是RHEL6.1 核心，配置的
HZ值為1000。
[[email protected] boot]# uname -a
Linux ssd 2.6.32-131.0.15.el6.x86_64 #1 SMP Tue May 10 15:42:40 EDT 2011 x86_64 x86_64 x86_64
GNU/Linux
[[email protected] boot]# cat config-2.6.32-131.0.15.el6.x86_64 |grep CONFIG_HZ

CONFIG_HZ_100 is not set

CONFIG_HZ_250 is not set

CONFIG_HZ_300 is not set

CONFIG_HZ_1000=y
CONFIG_HZ=1000
[[email protected] boot]#

HZ 的值，就是每秒的時鐘中斷數量。可以觀察/proc/interrupts 中時鐘中斷值變化，
來計算HZ的值。當HZ的值為1000時，ticks 的單位即為1/1000秒，即1ms 。
E very 5.0s: cat /proc/interrupts |grep LOC
Tue May 15 15:54:22 2012
LOC: 1621246 308599 28013 16995 37126 95699
1159285 2399641 552961 63923 58053
20580 17037 49626 1004223 48133 Local timer interrupts

3.2 CPU利用率統計資訊更新

 在時鐘中斷程式中，更新CPU 利用資訊，即每個ticks 更新一次。

include/linux/kernel_stat.h 中，有相應函式介面，專門用來更新CPU 利用率資訊。如
account_user_time（）是更新使用者態CPU 資訊。

 / * 
 * Lock/ unlock the current runqueue -  to extract task statistics:  
 */  
 extern unsigned long long  t a s k _ de lt a _ e xe c( struct  
task_struct   *);  

 extern void acc ount _ us e r _ t im e( struct  task_struct   *,   
cputime_t,   cputime_t);  
 extern void acc ount _ s y s t em _ t im e( struct  task_struct  *,   
int ,   cputime_t,  
  cputime_t);  
 extern void acc ount _ s t e a l_ tim e(cputime_t);  
 extern void acc ount _ idle _ t i m e(cputime_t);  

 extern void acc ount _ pr oc e s s _ t ic k(struct  task_struct   *, 
int   user);  
 extern void acc ount _ s t e a l_ tic k s( unsigned long ticks);  
 extern void acc ount _ idle _ t i c k s( unsigned long ticks);  

   在核心中有一個per CPU 變數kernel_stat ，專門用來記錄 CPU 利用資訊。其定義在
include/linux/kernel_stat.h 中。 
  DEC LA R E_ PER _ C PU( struct  kernel_stat ,   kstat);  

 #define  kstat_cpu ( cpu )  per_cpu( kstat,  cpu )

每次時鐘中斷時（ticks ），就會更新kernel_stat 變數中各個成員變數的值。/proc/stat
檔案中的值，都是在程式讀取時更新，核心並不會主動更新/proc/stat 中的資料。
/proc/stat 中的CPU 資訊是通過kernel_stat 各個成員變數的值計算而來。

3.3 CPU利用率精確性分析

 通過前面分析，我們可以得出以下結論：

（1）Linux CPU 佔用率是根據/proc/stat 檔案中的資料計算而來；
（2）/proc/stat 中的資料精度為ticks ，即1/HZ秒；
（3）核心每個ticks 會更新一次CPU 使用資訊；
（4）CPU 佔用率的精度為1/HZ秒。

4 Linux CPU佔用率是否準確？

有時偶爾會遇到類似問題：在穩定計算壓力下，程序CPU 佔用率不穩定；或者特性
程序CPU 佔用率明顯不準。即在系統切換次數很高時，Linux 的CPU 利用率計算機制可
能不準確。
那麼Linux 的CPU 利用率計算到底是否準確？若可能不準確，則什麼情況下出現這
種情況？

4.1 Linux CPU 佔用率不準確情形

在前面分析中，Linux 核心是在每次時鐘中斷時更新CPU 使用情況，即 1/HZ秒更新
一次。時鐘中斷時，只會看到當前正在執行的程序資訊。以下圖為例，紅色箭頭表示時
鍾中斷（Timer Interrupt ）。
第一次中斷時，看到程序A 在執行。但程序 A 執行時間短，程序 B 執行。第二次中
斷時，程序 C 執行；在第三次中斷到來時，再次排程程序 A 執行。第三次此中斷時，進
程C 執行。
按照Linux 核心CPU 佔用率統計方法，在第1 次和第2 次中斷期間，核心並沒有看
到程序B 在執行；於是就漏掉了程序B 使用CPU 的資訊。同樣道理，在第2 次和第3
次中斷期間，漏掉了程序B 使用CPU 的情況。這樣，就導致了Linux 核心CPU 佔用率
統計不準確。
發生CPU佔用率不準確的原因是：在一個時鐘中斷週期內，發生了多次程序排程。
時鐘中斷的精度是1/HZ秒。

4.2 top 命令CPU使用率準確嗎？

只有在一個時鐘中斷週期內發生多次程序排程，才會出現CPU 佔用率不準的情況。
那麼top 命令中CPU 使用率是否準確與程序排程頻率有關。
若HZ的值為250 ，則 ticks 值為4ms ；若 HZ值為1000，則 ticks 值為1ms 。在 HZ
為250 時，只要程序的排程間隔大於4ms ，CPU 佔用率就準確。HZ為1000時，排程
間隔大於1ms ，CPU 佔用率計算就準確。
程序排程次數少，CPU佔用率就準確；排程時間間隔小於時鐘中斷，就可能不準確。
那麼程序排程的時機是怎樣的？如何觀察程序排程次數？

4.2.1 程序排程時機

? 程序狀態轉換的時刻：程序終止、程序睡眠
程序要呼叫sleep（）或 exit （）等函式進行狀態轉換，這些函式會主動呼叫排程程
序進行程序排程；
? 當前程序的時間片用完時（current->counter=0 ）
由於程序的時間片是由時鐘中斷來更新的
? 裝置驅動程式
當裝置驅動程式執行長而重複的任務時，直接呼叫排程程式。在每次反覆迴圈中，
驅動程式都檢查need_resched的值，如果必要，則呼叫排程程式schedule() 主動放棄
CPU 。
? 程序從中斷、異常及系統呼叫返回到使用者態時
不管是從中斷、異常還是系統呼叫返回，最終都呼叫ret_from_sys_call （），由這
個函式進行排程標誌的檢測，如果必要，則呼叫排程程式。那麼，為什麼從系統呼叫返
回時要呼叫排程程式呢？這當然是從效率考慮。從系統呼叫返回意味著要離開核心態而
返回到使用者態，而狀態的轉換要花費一定的時間，因此，在返回到使用者態前，系統把在
核心態該處理的事全部做完。

4.2.2 程序排程次數觀察

可以通過vmstat 命令，來觀察系統中程序切換次數，cs 域的值就是切換次數。HZ
的值，可以通過核心配置檔案來確定，若/proc/config.gz 存在，匯出這個檔案檢視即可。

也可以通過檢視/proc/sched_debug 檔案內容，來觀察切換次數（nr_switches）。
[[email protected] proc]# watch -d -n 1 ‘cat /proc/sched_debug |grep nr_switches’

 我們系統中的程序排程真的那麼頻繁嗎？大多數情況下，Linux 中的CPU 佔用率計

算機制是準確的。

Linux CPU佔用率原理與 精確度分析