從Java視角了解系統結構 (一) CPU上下文切換

本文是從Java視角了解系統結構連載文章

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

上下文切換的精确定義可以參考:

http://www.linfo.org/context_switch.html 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的消耗(

).那麼Java程式怎麼測試和觀察上下文切換的消耗呢?

我做了一個小實驗, 代碼很簡單, 有兩個工作線程. 開始時，第一個線程挂起自己;

第二個線程喚醒第一個線程，再挂起自己; 第一個線程醒來之後喚醒第二個線程,

再挂起自己. 就這樣一來一往,互相喚醒對方, 挂起自己. 代碼如下:

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 觀查一下上下文切換的頻率是否變快

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

Average time: 2169ns

parks: 978428

Average time: 2196ns

parks: 989897

Average time: 2214ns

這個指令把程序綁定在0号CPU上,結果Context Switch的消耗小了一個數量級, 什麼原因呢? 賣個關子, 在談到CPU Affinity的博文再說 :)。