碼上歡樂
相關內容    簡體    繁體

從Java視角理解CPU上下文切換(Context Switch)

本文轉載自   查看原文   2016-09-14 19:24   3300    Java CPU 上下文切換 Context Switch

 

從Java視角理解系統結構連載, 關注我的微博(鏈接)了解最新動態 

在高性能編程時,經常接觸到多線程. 起初我們的理解是, 多個線程並行地執行總比單個線程要快, 就像多個人一起干活總比一個人干要快. 然而實際情況是, 多線程之間需要競爭IO設備, 或者競爭鎖資源，導致往往執行速度還不如單個線程. 在這里有一個經常提及的概念就是: 上下文切換(Context Switch). 

上下文切換的精確定義可以參考: http://www.linfo.org/context_switch.html. 下面做個簡單的介紹. 多任務系統往往需要同時執行多道作業.作業數往往大於機器的CPU數, 然而一顆CPU同時只能執行一項任務, 如何讓用戶感覺這些任務正在同時進行呢? 操作系統的設計者巧妙地利用了時間片輪轉的方式, CPU給每個任務都服務一定的時間, 然后把當前任務的狀態保存下來, 在加載下一任務的狀態后, 繼續服務下一任務. 任務的狀態保存及再加載, 這段過程就叫做上下文切換. 時間片輪轉的方式使多個任務在同一顆CPU上執行變成了可能, 但同時也帶來了保存現場和加載現場的直接消耗. 
(Note. 更精確地說, 上下文切換會帶來直接和間接兩種因素影響程序性能的消耗. 直接消耗包括: CPU寄存器需要保存和加載, 系統調度器的代碼需要執行, TLB實例需要重新加載, CPU 的pipeline需要刷掉; 間接消耗指的是多核的cache之間得共享數據, 間接消耗對於程序的影響要看線程工作區操作數據的大小). 


在linux中可以使用vmstat觀察上下文切換的次數. 執行命令如下: 

Shell代碼   收藏代碼
  1. $ vmstat 1  
  2. procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----  
  3.  r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa  
  4.  1  0      0 4593944 453560 1118192    0    0    14    12  238   30  6  1 92  1  
  5.  0  0      0 4593212 453568 1118816    0    0     0    96  958 1108  4  1 94  2  
  6.  0  0      0 4593360 453568 1118456    0    0     0     0  895 1044  3  1 95  0  
  7.  1  0      0 4593408 453568 1118456    0    0     0     0  929 1073  4  1 95  0  
  8.  0  0      0 4593496 453568 1118456    0    0     0     0 1133 1363  6  1 93  0  
  9.  0  0      0 4593568 453568 1118476    0    0     0     0  992 1190  4  1 95  0  


vmstat 1指每秒統計一次, 其中cs列就是指上下文切換的數目. 一般情況下, 空閑系統的上下文切換每秒大概在1500以下. 

對於我們經常使用的搶占式操作系統來說, 引起上下文切換的原因大概有以下幾種: 1. 當前執行任務的時間片用完之后, 系統CPU正常調度下一個任務 2. 當前執行任務碰到IO阻塞, 調度器將掛起此任務, 繼續下一任務 3. 多個任務搶占鎖資源, 當前任務沒有搶到,被調度器掛起, 繼續下一任務 4. 用戶代碼掛起當前任務, 讓出CPU時間 5. 硬件中斷. 前段時間發現有人在使用futex的WAIT和WAKE來測試context switch的直接消耗(鏈接), 也有人使用阻塞IO來測試context switch的消耗(鏈接).那么Java程序怎么測試和觀察上下文切換的消耗呢? 

我做了一個小實驗, 代碼很簡單, 有兩個工作線程. 開始時，第一個線程掛起自己; 第二個線程喚醒第一個線程，再掛起自己; 第一個線程醒來之后喚醒第二個線程, 再掛起自己. 就這樣一來一往,互相喚醒對方, 掛起自己. 代碼如下: 

Java代碼   收藏代碼
  1. import java.util.concurrent.atomic.AtomicReference;  
  2. import java.util.concurrent.locks.LockSupport;  
  3.   
  4. public final class ContextSwitchTest {  
  5.     static final int RUNS = 3;  
  6.     static final int ITERATES = 1000000;  
  7.     static AtomicReference turn = new AtomicReference();  
  8.   
  9.     static final class WorkerThread extends Thread {  
  10.         volatile Thread other;  
  11.         volatile int nparks;  
  12.   
  13.         public void run() {  
  14.             final AtomicReference t = turn;  
  15.             final Thread other = this.other;  
  16.             if (turn == null || other == null)  
  17.                 throw new NullPointerException();  
  18.             int p = 0;  
  19.             for (int i = 0; i < ITERATES; ++i) {  
  20.                 while (!t.compareAndSet(other, this)) {  
  21.                     LockSupport.park();  
  22.                     ++p;  
  23.                 }  
  24.                 LockSupport.unpark(other);  
  25.             }  
  26.             LockSupport.unpark(other);  
  27.             nparks = p;  
  28.             System.out.println("parks: " + p);  
  29.   
  30.         }  
  31.     }  
  32.   
  33.     static void test() throws Exception {  
  34.         WorkerThread a = new WorkerThread();  
  35.         WorkerThread b = new WorkerThread();  
  36.         a.other = b;  
  37.         b.other = a;  
  38.         turn.set(a);  
  39.         long startTime = System.nanoTime();  
  40.         a.start();  
  41.         b.start();  
  42.         a.join();  
  43.         b.join();  
  44.         long endTime = System.nanoTime();  
  45.         int parkNum = a.nparks + b.nparks;  
  46.         System.out.println("Average time: " + ((endTime - startTime) / parkNum)  
  47.                 + "ns");  
  48.     }  
  49.   
  50.     public static void main(String[] args) throws Exception {  
  51.         for (int i = 0; i < RUNS; i++) {  
  52.             test();  
  53.         }  
  54.     }  
  55. }  


編譯后,在我自己的筆記本上( Intel(R) Core(TM) i5 CPU M 460  @ 2.53GHz, 2 core, 3M L3 Cache) 用測試幾輪，結果如下: 

Shell代碼   收藏代碼
  1. java -cp . ContextSwitchTest  
  2. parks: 953495  
  3. parks: 953485  
  4. Average time: 11373ns  
  5. parks: 936305  
  6. parks: 936302  
  7. Average time: 11975ns  
  8. parks: 965563  
  9. parks: 965560  
  10. Average time: 13261ns  

我們會發現這么簡單的for循環, 線性執行會非常快,不需要1秒, 而執行這段程序需要幾十秒的耗時. 每個上下文切換需要耗去十幾us的時間,這對於程序吞吐量的影響很大. 

同時我們可以執行vmstat 1 觀查一下上下文切換的頻率是否變快 

Shell代碼   收藏代碼
  1. $ vmstat 1  
  2. procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----  
  3.  r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa  
  4.  1  0      0 4424988 457964 1154912    0    0    13    12  252   80  6  1 92  1  
  5.  0  0      0 4420452 457964 1159900    0    0     0     0 1586 2069  6  1 93  0  
  6.  1  0      0 4407676 457964 1171552    0    0     0     0 1436 1883  8  3 89  0  
  7.  1  0      0 4402916 457964 1172032    0    0     0    84 22982 45792  9  4 85  2  
  8.  1  0      0 4416024 457964 1158912    0    0     0     0 95382 198544 17 10 73  0  
  9.  1  1      0 4416096 457964 1158968    0    0     0   116 79973 159934 18  7 74  0  
  10.  1  0      0 4420384 457964 1154776    0    0     0     0 96265 196076 15 10 74  1  
  11.  1  0      0 4403012 457972 1171096    0    0     0   152 104321 213537 20 12 66  2  



再使用strace觀察以上程序中Unsafe.park()究竟是哪道系統調用造成了上下文切換: 

Shell代碼   收藏代碼
  1. $strace -f java -cp . ContextSwitchTest  
  2. [pid  5969] futex(0x9571a9c, FUTEX_WAKE_OP_PRIVATE, 1, 1, 0x9571a98, {FUTEX_OP_SET, 0, FUTEX_OP_CMP_GT, 1}) = 1  
  3. [pid  5968] <... futex resumed> )       = 0  
  4. [pid  5969] futex(0x9571ad4, FUTEX_WAIT_PRIVATE, 949, NULL <unfinished ...>  
  5. [pid  5968] futex(0x9564368, FUTEX_WAKE_PRIVATE, 1) = 0  
  6. [pid  5968] futex(0x9571ad4, FUTEX_WAKE_OP_PRIVATE, 1, 1, 0x9571ad0, {FUTEX_OP_SET, 0, FUTEX_OP_CMP_GT, 1} <unfinished ...>  
  7. [pid  5969] <... futex resumed> )       = 0  
  8. [pid  5968] <... futex resumed> )       = 1  
  9. [pid  5969] futex(0x9571628, FUTEX_WAIT_PRIVATE, 2, NULL <unfinished ...>  

果然還是futex. 

再使用perf看看上下文對於Cache的影響: 

Shell代碼   收藏代碼
  1. $ perf stat -e cache-misses   java -cp . ContextSwitchTest  
  2. parks: 999999  
  3. parks: 1000000  
  4. Average time: 16201ns  
  5. parks: 998930  
  6. parks: 998926  
  7. Average time: 14426ns  
  8. parks: 998034  
  9. parks: 998204  
  10. Average time: 14489ns  
  11.   
  12.  Performance counter stats for 'java -cp . ContextSwitchTest':  
  13.   
  14.          2,550,605 cache-misses                                                  
  15.   
  16.       90.221827008 seconds time elapsed  

1分半鍾內有255萬多次cache未命中. 

嗯, 貌似太長了, 可以結束了. 接下來會繼續幾篇博文繼續分析一些有意思的東西. 
(1) 從Java視角看內存屏障 (Memory Barrier) 
(2) 從java視角看CPU親緣性 (CPU Affinity) 
等..敬請關注 


PS. 其實還做了一個實驗, 測試CPU Affinity對於Context Switch的影響. 

Shell代碼   收藏代碼
  1. $ taskset -c 0 java -cp . ContextSwitchTest  
  2. parks: 992713  
  3. parks: 1000000  
  4. Average time: 2169ns  
  5. parks: 978428  
  6. parks: 1000000  
  7. Average time: 2196ns  
  8. parks: 989897  
  9. parks: 1000000  
  10. Average time: 2214ns  

這個命令把進程綁定在0號CPU上,結果Context Switch的消耗小了一個數量級, 什么原因呢? 賣個關子, 在談到CPU Affinity的博文再說

http://coderplay.iteye.com/blog/1481211

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 【轉】CPU上下文切換的次數和時間（context switch） 深入理解Linux的CPU上下文切換 CPU上下文切換詳解 什么是CPU上下文切換 CPU上下文切換 寫給Java程序員看的，CPU 上下文切換、用戶態、內核態、進程與線程上下文切換（轉） Java性能 -- 線程上下文切換 多線程上下文切換 多線程上下文切換 線程的上下文切換
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM