從Java視角理解系統結構(一)CPU上下文切換
作者：Minzhou 本文是從Java視角理解系統結構連載文章
在高效能程式設計時,經常接觸到多執行緒. 起初我們的理解是, 多個執行緒並行地執行總比單個執行緒要快, 就像多個人一起幹活總比一個人幹要快. 然而實際情況是, 多執行緒之間需要競爭IO裝置, 或者競爭鎖資源，導致往往執行速度還不如單個執行緒. 在這裡有一個經常提及的概念就是: 上下文切換(Context Switch).
上下文切換的精確定義可以參考: http://www.linfo.org/context_switch.html。下面做個簡單的介紹. 多工系統往往需要同時執行多道作業.作業數往往大於機器的CPU數, 然而一顆CPU同時只能執行一項任務, 如何讓使用者感覺這些任務正在同時進行呢? 作業系統的設計者巧妙地利用了時間片輪轉的方式, CPU給每個任務都服務一定的時間, 然後把當前任務的狀態儲存下來, 在載入下一任務的狀態後, 繼續服務下一任務. 任務的狀態儲存及再載入, 這段過程就叫做上下文切換. 時間片輪轉的方式使多個任務在同一顆CPU上執行變成了可能, 但同時也帶來了儲存現場和載入現場的直接消耗。
(Note. 更精確地說, 上下文切換會帶來直接和間接兩種因素影響程式效能的消耗. 直接消耗包括: CPU暫存器需要儲存和載入, 系統排程器的程式碼需要執行, TLB例項需要重新載入, CPU 的pipeline需要刷掉; 間接消耗指的是多核的cache之間得共享資料, 間接消耗對於程式的影響要看執行緒工作區操作資料的大小).
在linux中可以使用vmstat觀察上下文切換的次數. 執行命令如下:
$ vmstat 1 procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu---- r b swpd free buff cache si so bi bo in cs us sy id wa 1 0 0 4593944 453560 1118192 0 0 14 12 238 30 6 1 92 1 0 0 0 4593212 453568 1118816 0 0 0 96 958 1108 4 1 94 2 0 0 0 4593360 453568 1118456 0 0 0 0 895 1044 3 1 95 0 1 0 0 4593408 453568 1118456 0 0 0 0 929 1073 4 1 95 0 0 0 0 4593496 453568 1118456 0 0 0 0 1133 1363 6 1 93 0 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的消耗(
我做了一個小實驗, 程式碼很簡單, 有兩個工作執行緒. 開始時，第一個執行緒掛起自己; 第二個執行緒喚醒第一個執行緒，再掛起自己; 第一個執行緒醒來之後喚醒第二個執行緒, 再掛起自己. 就這樣一來一往,互相喚醒對方, 掛起自己. 程式碼如下:
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;
public final class ContextSwitchTest {
static final int RUNS = 3;
static final int ITERATES = 1000000;
static AtomicReference turn = new AtomicReference();
static final class WorkerThread extends Thread {
volatile Thread other;
volatile int nparks;
public void run() {
final AtomicReference t = turn;
final Thread other = this.other;
if (turn == null || other == null)
throw new NullPointerException();
int p = 0;
for (int i = 0; i < ITERATES; ++i) {
while (!t.compareAndSet(other, this)) {
LockSupport.park();
++p;
}
LockSupport.unpark(other);
}
LockSupport.unpark(other);
nparks = p;
System.out.println("parks: " + p);
}
}
static void test() throws Exception {
WorkerThread a = new WorkerThread();
WorkerThread b = new WorkerThread();
a.other = b;
b.other = a;
turn.set(a);
long startTime = System.nanoTime();
a.start();
b.start();
a.join();
b.join();
long endTime = System.nanoTime();
int parkNum = a.nparks + b.nparks;
System.out.println("Average time: " + ((endTime - startTime) / parkNum)
+ "ns");
}
public static void main(String[] args) throws Exception {
for (int i = 0; i < RUNS; i++) {
test();
}
}
}
編譯後,在我自己的筆記本上( Intel(R) Core(TM) i5 CPU M 460 @ 2.53GHz, 2 core, 3M L3 Cache) 用測試幾輪，結果如下:
java -cp . ContextSwitchTest parks: 953495 parks: 953485 Average time: 11373ns parks: 936305 parks: 936302 Average time: 11975ns parks: 965563 parks: 965560 Average time: 13261ns
我們會發現這麼簡單的for迴圈, 線性執行會非常快,不需要1秒, 而執行這段程式需要幾十秒的耗時. 每個上下文切換需要耗去十幾us的時間,這對於程式吞吐量的影響很大.
同時我們可以執行vmstat 1 觀查一下上下文切換的頻率是否變快
$ vmstat 1 procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu---- r b swpd free buff cache si so bi bo in cs us sy id wa 1 0 0 4424988 457964 1154912 0 0 13 12 252 80 6 1 92 1 0 0 0 4420452 457964 1159900 0 0 0 0 1586 2069 6 1 93 0 1 0 0 4407676 457964 1171552 0 0 0 0 1436 1883 8 3 89 0 1 0 0 4402916 457964 1172032 0 0 0 84 22982 45792 9 4 85 2 1 0 0 4416024 457964 1158912 0 0 0 0 95382 198544 17 10 73 0 1 1 0 4416096 457964 1158968 0 0 0 116 79973 159934 18 7 74 0 1 0 0 4420384 457964 1154776 0 0 0 0 96265 196076 15 10 74 1 1 0 0 4403012 457972 1171096 0 0 0 152 104321 213537 20 12 66 2
再使用strace觀察以上程式中Unsafe.park()究竟是哪道系統呼叫造成了上下文切換:
$strace -f java -cp . ContextSwitchTest
[pid 5969] futex(0x9571a9c, FUTEX_WAKE_OP_PRIVATE, 1, 1, 0x9571a98, {FUTEX_OP_SET, 0, FUTEX_OP_CMP_GT, 1}) = 1
[pid 5968] ) = 0
[pid 5969] futex(0x9571ad4, FUTEX_WAIT_PRIVATE, 949, NULL
[pid 5968] futex(0x9564368, FUTEX_WAKE_PRIVATE, 1) = 0
[pid 5968] futex(0x9571ad4, FUTEX_WAKE_OP_PRIVATE, 1, 1, 0x9571ad0, {FUTEX_OP_SET, 0, FUTEX_OP_CMP_GT, 1}
[pid 5969] ) = 0
[pid 5968] ) = 1
[pid 5969] futex(0x9571628, FUTEX_WAIT_PRIVATE, 2, NULL
果然還是futex.
再使用perf看看上下文對於Cache的影響:
$ perf stat -e cache-misses java -cp . ContextSwitchTest
parks: 999999
parks: 1000000
Average time: 16201ns
parks: 998930
parks: 998926
Average time: 14426ns
parks: 998034
parks: 998204
Average time: 14489ns
Performance counter stats for 'java -cp . ContextSwitchTest':
2,550,605 cache-misses
90.221827008 seconds time elapsed
1分半鐘內有255萬多次cache未命中.
嗯, 貌似太長了, 可以結束了. 接下來會繼續幾篇博文繼續分析一些有意思的東西.
(1) 從Java視角看記憶體屏障 (Memory Barrier)
(2) 從java視角看CPU親緣性 (CPU Affinity)
等..敬請關注
PS. 其實還做了一個實驗, 測試CPU Affinity對於Context Switch的影響.
$ taskset -c 0 java -cp . ContextSwitchTest parks: 992713 parks: 1000000 Average time: 2169ns parks: 978428 parks: 1000000 Average time: 2196ns parks: 989897 parks: 1000000 Average time: 2214ns
這個命令把程序繫結在0號CPU上,結果Context Switch的消耗小了一個數量級, 什麼原因呢? 賣個關子, 在談到CPU Affinity的博文再說 :)。
周忱。阿里巴巴技術專家，曾經負責淘寶Hadoop,Hive研發, Hive Contributor, 目前在做分散式實時計算