zoukankan      html  css  js  c++  java

  • 从Java视角理解CPU上下文切换(Context Switch)

    在高性能编程时,经常接触到多线程. 起初我们的理解是, 多个线程并行地执行总比单个线程要快, 就像多个人一起干活总比一个人干要快. 然而实际情况是, 多线程之间需要竞争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的博文再说
  • 相关阅读:
    OK335x mksd.sh hacking
    Qt jsoncpp 对象拷贝、删除、函数调用 demo
    OK335xS 256M 512M nand flash make ubifs hacking
    Qt QScrollArea and layout in code
    JsonCpp Documentation
    Qt 4.8.5 jsoncpp lib
    Oracle数据库生成UUID
    freemarker得到数组的长度
    FreeMarker中if标签内的判断条件
    freemarker语法
  • 原文地址：https://www.cnblogs.com/dayhand/p/3645379.html
Copyright © 2011-2022 走看看