linux进程调度之 FIFO 和 RR 调度策略

转载 http://blog.chinaunix.net/uid-24774106-id-3379478.html 
linux进程调度之 FIFO 和 RR 调度策略 2012-10-19 18:16:43

分类： LINUX

 

    作者：manuscola.bean@gmail.com

    博客地址：bean.blog.chinaunix.net
 最近花了10几天的时间，将linux进程调度相关的内核代码看了两遍左右，也看了一些讲述linux进程调度的一些文章，总想写个系列文章，把进程调度全景剖析一遍，但是总是感觉力不逮己，自己都不敢下笔写文章了。算了，还是不难为自己了，就随便写写自己的心得好了。

    在用户空间，或者应用编程领域 ，Linux提供了一些API或者系统调用来影响Linux的内核调度器，或者是获取内核调度器的信息。比如可以获取或者设置进程的调度策略、优先级，获取CPU时间片大小的信息。
 
    这些接口一旦在应用程序中调用，就像给湖面扔进一颗石子，对内核带来了那些的影响，其实这是我内心很激动很想分享的东西，但是内容好没有组织好，所以本文的主题暂不深入涉及这些系统调用及对应的内核层的代码。
 
    严格地说，对于优先级对于实时进程和普通进程的意义是不一样的。
    1 在一定程度上，实时进程优先级高，实时进程存在，就没有普通进程占用CPU的机会，（但是前一篇博文也讲过了，实时组调度出现在内核以后，允许普通进程占用少量的CPU时间,取决于配置)。
    2 对于实时进程而言，高优先级的进程存在，低优先级的进程是轮不上的，没机会跑在CPU上，所谓实时进程的调度策略,指的是相同优先级之间的调度策略。如果是FIFO实时进程在占用CPU，除非出现以下事情，否则FIFO一条道跑到黑。
     a）FIFO进程良心发现，调用了系统调用sched_yield 自愿让出CPU
     b) 更高优先级的进程横空出世，抢占FIFO进程的CPU。有些人觉得很奇怪，怎么FIFO占着CPU，为啥还能有更高优先级的进程出现呢。别忘记，我们是多核多CPU ,如果其他CPU上出现了一个比FIFO优先级高的进程，可能会push到FIFO进程所在的CPU上。
     c)FIFO进程停止（TASK_STOPPED or TASK_TRACED状态）或者被杀死（EXIT_ZOMBIE or EXIT_DEAD状态）
    d) FIFO进程执行了阻塞调用并进入睡眠（TASK_INTERRUPTIBLE OR TASK_UNINTERRUPTIBLE）。
    
    如果是进程的调度策略是时间片轮转RR，那么，除了前面提到的abcd，RR实时进程耗尽自己的时间片后，自动退到对应优先级实时队列的队尾，重新调度。
 
    下面我们就是来探究FIFO策略和RR策略的特点。为了降低理解的难度，我将我们启动的实时进程绑定到同一个核上。

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<unistd.h>
  4. #include<sys/time.h>
  5. #include<sys/types.h>
  6. #include<sys/sysinfo.h>
  7. #include<time.h>
  9. #define __USE_GNU
  10. #include<sched.h>
  11. #include<ctype.h>
  12. #include<string.h>
  14. #define COUNT 300000
  15. #define MILLION 1000000L
  16. #define NANOSECOND 1000
  18. void test_func()
  19. {
  20.     int i = 0;
  21.     unsigned long long result = 0;;
  23.     for(i = 0; i<8000 ;i++)
  24.     {
  25.         result += 2;
  26.     }
  28. }
  29. int main(int argc,char* argv[])
  30. {
  31.     int i;
  32.     struct timespec sleeptm;
  33.     long interval;
  34.     struct timeval tend,tstart;
  35.     struct tm lcltime = {0};
  36.     struct sched_param param;
  37.     int ret = 0;
  39.     if(argc != 3)
  40.     {
  41.         fprintf(stderr,"usage:./test sched_method sched_priority\n");
  42.         return -1;
  43.     }
  45.     cpu_set_t mask ;
  46.     CPU_ZERO(&mask);
  47.     CPU_SET(1,&mask);
  49.     if (sched_setaffinity(0, sizeof(mask), &mask) == -1) 
  50.     { 
  51.         printf("warning: could not set CPU affinity, continuing...\n");
  52.     } 
  53.     int sched_method = atoi(argv[1]);
  54.     int sched_priority = atoi(argv[2]);
  56.     /*    if(sched_method > 2 || sched_method < 0)
  57.         {
  58.         fprintf(stderr,"sched_method scope [0,2]\n");
  59.         return -2;
  60.         }
  61.         if(sched_priority > 99 || sched_priority < 1)
  62.         {
  63.         fprintf(stderr,"sched_priority scope [1,99]\n");
  64.         return -3;
  65.         }
  67.         if(sched_method == 1 || sched_method == 2)*/
  68.     {
  69.         param.sched_priority = sched_priority;
  70.         ret = sched_setscheduler(getpid(),sched_method,&param);
  71.         if(ret)
  72.         {
  73.             fprintf(stderr,"set scheduler to %d %d failed %m\n");
  74.             return -4;
  75.         }
  76.     }
  78.     int scheduler = sched_getscheduler(getpid());
  80.     fprintf(stderr,"the scheduler of PID(%ld) is %d, priority (%d),BEGIN time is :%ld\n",
  81.             getpid(),scheduler,sched_priority,time(NULL));
  83.     sleep(2);
  84.     sleeptm.tv_sec = 0;
  85.     sleeptm.tv_nsec = NANOSECOND;
  87.     for(i = 0;i<COUNT;i++)
  88.     {
  89.         test_func();
  90.     }
  92.  
  94.     interval = MILLION*(tend.tv_sec - tstart.tv_sec)
  95.                +(tend.tv_usec-tstart.tv_usec);
  97.     fprintf(stderr," PID = %d\t priority: %d\tEND TIME is %ld\n",getpid(),sched_priority,time(NULL));
  98.     return 0;
  99. }
    上面这个程序有几点需要说明的地方
    1 为了降低复杂度，绑定到了同一个核上，我做实验的机器是四核（通过cat /proc/cpuinfo可以看到）
    2  sleep（2）,是给其他进程得到调度的机会，否则无法模拟出多个不同优先级的实时进程并行的场景。sleep过后，就没有阻塞性的系统调用了，高优先级的就会占据CPU（FIFO），同等优先级的进程轮转（RR） 

  1. struct sched_param {
  2. /* ... */
  3. int sched_priority;
  4. /* ... */
  5. };
int sched_setscheduler (pid_t pid,
int policy,
const struct sched_param *sp);

sched_setscheduler函数的第二个参数调度方法 ：

  1. #define SCHED_OTHER 0
  2. #define SCHED_FIFO 1
  3. #define SCHED_RR 2
  4. #ifdef __USE_GNU
  5. # define SCHED_BATCH 3
  6. #endif
    SCHED_OTHER表示普通进程，对于普通进程，第三个参数sp->sched_priority只能是0
   SCHED_FIFO 和SCHED_RR表示实时进程的调度策略，第三个参数的取值范围为[1,99]。
   如果sched_setscheduler 优先级设置的值和调度策略不符合的话，会返回失败的。
 
   内核中有这么一段注释：
  1. /*
  2.      * Valid priorities for SCHED_FIFO and SCHED_RR are
  3.      * 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL,
  4.      * SCHED_BATCH and SCHED_IDLE is 0.
  5.      */
    LINUX系统提供了其他的系统调用来获取不同策略优先级的取值范围：
  1. #include <sched.h>
  2. int sched_get_priority_min (int policy);
  3. int sched_get_priority_max (int policy);

另外需要指出的一点是，应用层和内核层的优先级含义是不同的：
   首先说实时进程：实时进程的优先级设置可以通过sched_setsheduler设置，也可以通过sched_setparam设置优先级的大小。
  1. int sched_setparam (pid_t pid, const struct sched_param *sp);
    在用户层或者应用层，1表示优先级最低，99表示优先级最高。但是在内核中，[0,99]表示的实时进程的优先级，0最高，99最低。[100,139]是普通进程折腾的范围。应用层比较天真率直，就看大小，数字大，则优先级高。ps查看进程的优先级也是如此。有意思的是，应用层实时进程最高优先级的99，在ps看进程优先级的时候，输出的是139.
 
    下面是ps -C test -o pid,pri,cmd,time,psr 的输出：
  1. PID   PRI  CMD             TIME     PSR
  2.  6303 139 ./test 1 99  00:00:04       1
    虽说本文主要讲的是实时进程，但是需要插句话。对于普通进程，是通过nice系统调用来调整优先级的。从内核角度讲[100,139]是普通进程的优先级的范围，100最高，139最低，默认是120。普通进程的优先级的作用和实时进程不同，普通进程优先级表示的是占的CPU时间。深入linux内核架构中提到，普通优先级越高（100最高，139最低），享受的CPU time越多，相邻的两个优先级，高一级的进程比低一级的进程多占用10%的CPU，比如内核优先级数值为120的进程要比数值是121的进程多占用10%的CPU。
 
    内核中有一个数组：prio_to_weight[20]表示的是默认优先级120的权重，数值为1024，prio_to_weight[21]表示nice值为1，优先级为121的进程的权重，数值为820。这就到了CFS的原理了
  1. static const int prio_to_weight[40] = {
  2.  /* -20 */ 88761, 71755, 56483, 46273, 36291,
  3.  /* -15 */ 29154, 23254, 18705, 14949, 11916,
  4.  /* -10 */ 9548, 7620, 6100, 4904, 3906,
  5.  /* -5 */ 3121, 2501, 1991, 1586, 1277,
  6.  /* 0 */ 1024, 820, 655, 526, 423,
  7.  /* 5 */ 335, 272, 215, 172, 137,
  8.  /* 10 */ 110, 87, 70, 56, 45,
  9.  /* 15 */ 36, 29, 23, 18, 15,
  10. };
假如有1台电脑，10个人玩，怎么才公平。
1 约定好时间片，每人玩1小时，玩完后记账，张XX 1小时，谁玩的时间短，谁去玩
    2 引入优先级的概念，李四有紧急情况，需要提高他玩电脑的时间，怎么办，玩1个小时，记账半小时，那么同等情况下，李四会比其他人被选中玩电脑的频率要高，就体现了这个优先级的概念。
    3  王五也有紧急情况，但是以考察，不如李四的紧急，好吧，玩1个小时，记账45分钟。
    4  情况有变化，听说这里有电脑，突然又来了10个人，如果按照每人玩1小时的时间片，排在最后的那哥们早就开始骂人了，怎么办？时间片动态变化，根据人数来确定时间片。人越多，每个人玩的时间越少，防止哥们老捞不着玩，耐心耗尽，开始骂人。
 
    这个记账就是我们prio_to_weight的作用。我就不多说了，prio_to_weight[20]就是基准，玩一小时，记账一小时，数组20以前的值是特权一级，玩1小时记账20分钟之类的享有特权的，数组20之后是倒霉蛋，玩1小时，记账1.5小时之类的倒霉蛋。 CFS这种调度好在大家都能捞着玩。
 
    扯到优先级多说了几句，现在回到正题。我将上面的C程序编译成可执行程序test，然后写了一个脚本comp.sh。

  1. [root@localhost sched]# cat comp.sh
  2. #/bin/sh
  5. ./test $1 99 &
  6. usleep 1000;
  7. ./test $1 70 &
  8. usleep 1000;
  10. ./test $1 70 &
  11. usleep 1000;
  13. ./test $1 70 &
  14. usleep 1000;
  16. ./test $1 50 &
  17. usleep 1000;
  18. ./test $1 30 &
  19. usleep 1000;
  20. ./test $1 10 &
       因为test进程有sleep 2秒，所以可以给comp.sh启动其他test的机会。可以看到有 99级（最高优先级）的实时进程，3个70级的实时进程，50级，30级，10级的各一个。
      对于FIFO而言，一旦sleep过后，高优先级运行，低优先级是没戏运行的，同等优先级的进程，先运行的不运行完，后运行的也没戏。
     对于RR而言，高优先级的先运行，同等优先级的进程过家家，你玩完，我玩，我玩完你再玩，每个进程耗费一个时间片的时间。对于Linux，RR时间片是100ms：
 
  1. #define DEF_TIMESLICE        (100 * HZ / 1000)
  
    下面我们验证： 我写了两个观察脚本，来观察实时进程的调度情况：
 
    第一个脚本比较简单，观察进程的CPU 占用的time，用ps工具就可以了：

  1. [root@localhost sched]# cat getpsinfo.sh
  2. #!/bin/sh
  4. for((i = 0; i < 40; i++))
  5. do
  6.     ps -C test -o pid,pri,cmd,time,psr >>psinfo.log 2>&1
  7.     sleep 2;
  8. done
    第二个脚本比较复杂是systemtap脚本，观察名字为test的进程相关的上下文切换，谁替换了test，或者test替换了谁，同时记录下test进程的退出：
  1. [root@localhost sched]# cat cswmon_spec.stp 
  3. global time_offset
  4. probe begin { time_offset = gettimeofday_us() }
  6. probe scheduler.ctxswitch {
  7.     if(next_task_name == "test" ||prev_task_name == "test")
  8.     {
  9.          t = gettimeofday_us()
  10.          printf(" time_off (%8d )%20s(%6d)(pri=%4d)(state=%d)->%20s(%6d)(pri=%4d)(state=%d)\n",
  11.                   t-time_offset,
  12.                   prev_task_name,
  13.                   prev_pid,
  14.                   prev_priority,
  15.                   (prevtsk_state),
  16.                   next_task_name,
  17.                   next_pid,
  18.                   next_priority,
  19.                   (nexttsk_state))
  20.     }
  21. }
  24. probe scheduler.process_exit
  25. {
  26.     if(execname() == "test")
  27.     printf("task :%s PID(%d) PRI(%d) EXIT\n",execname(),pid,priority);
  28. }
  30. probe timer.s($1) {
  31.     printf("--------------------------------------------------------------\n")
  32.         exit();
  33. }
   
A)    FIFO调度策略的输出：
  1. 终端1 ：
  2. stap ./cswmon_spec.stp 70
  4. 终端2 ：
  5. ./getpsinfo.sh
  7. 终端3
  8. ./comp.sh 1
输出结果如下：

    99优先级跑完了，才轮到70优先级，但是虽说有3个70优先级，但是先跑的那个进程跑完了，第二个优先级为70的才能跑。因为输出结果用代码无法漂亮的展示，所以我截了图，截图又不能把这个输出都截下来，所以我很蛋疼。有需要结果的，我以附件形式附在最后。
    看下第二个脚本的输出：

  1. time_off ( 689546 ) test( 6305)(pri= 120)(state=0)-> migration/2( 11)(pri= 0)(state=0)
  2. time_off ( 689977 ) stap( 5895)(pri= 120)(state=0)-> test( 6305)(pri= 120)(state=0)
  3. time_off ( 690067 ) test( 6305)(pri= 29)(state=1)-> stap( 5895)(pri= 120)(state=0)
  4. time_off ( 697899 ) test( 6303)(pri= 120)(state=0)-> migration/2( 11)(pri= 0)(state=0)
  5. time_off ( 698042 ) test( 6307)(pri= 120)(state=0)-> migration/0( 3)(pri= 0)(state=0)
  6. time_off ( 699114 ) stap( 5895)(pri= 120)(state=0)-> test( 6303)(pri= 120)(state=0)
  7. time_off ( 699307 ) test( 6303)(pri= 0)(state=1)-> test( 6307)(pri= 120)(state=0)
  8. time_off ( 699371 ) test( 6307)(pri= 29)(state=1)-> stap( 5895)(pri= 120)(state=0)
  9. time_off ( 699392 ) test( 6309)(pri= 120)(state=0)-> migration/3( 15)(pri= 0)(state=0)
  10. time_off ( 699966 ) events/1( 20)(pri= 120)(state=1)-> test( 6309)(pri= 120)(state=0)
  11. time_off ( 700034 ) test( 6309)(pri= 29)(state=1)-> stap( 5895)(pri= 120)(state=0)
  12. time_off ( 707379 ) test( 6311)(pri= 120)(state=0)-> migration/3( 15)(pri= 0)(state=0)
  13. time_off ( 707587 ) test( 6313)(pri= 120)(state=0)-> migration/0( 3)(pri= 0)(state=0)
  14. time_off ( 712021 ) stap( 5895)(pri= 120)(state=0)-> test( 6311)(pri= 120)(state=0)
  15. time_off ( 712145 ) test( 6311)(pri= 49)(state=1)-> test( 6313)(pri= 120)(state=0)
  16. time_off ( 712252 ) test( 6313)(pri= 69)(state=1)-> stap( 5895)(pri= 120)(state=0)
  17. time_off ( 727057 ) test( 6315)(pri= 120)(state=0)-> migration/0( 3)(pri= 0)(state=0)
  18. time_off ( 727952 ) stap( 5895)(pri= 120)(state=0)-> test( 6315)(pri= 120)(state=0)
  19. time_off ( 728047 ) test( 6315)(pri= 89)(state=1)-> stap( 5895)(pri= 120)(state=0)
  20. time_off ( 2690181 ) stap( 5895)(pri= 120)(state=0)-> test( 6305)(pri= 29)(state=0)
  21. time_off ( 2699316 ) test( 6305)(pri= 29)(state=0)-> test( 6303)(pri= 0)(state=0)
  22. task :test PID(6303) PRI(0) EXIT
  23. time_off (13057854 ) test( 6303)(pri= 0)(state=64)-> watchdog/1( 10)(pri= 0)(state=0)
  24. time_off (13057864 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6305)(pri= 29)(state=0)
  25. time_off (15333340 ) test( 6305)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  26. time_off (15333354 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6305)(pri= 29)(state=0)
  27. time_off (18743409 ) test( 6305)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  28. time_off (18743422 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6305)(pri= 29)(state=0)
  29. time_off (22154757 ) test( 6305)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  30. time_off (22154771 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6305)(pri= 29)(state=0)
  31. task :test PID(6305) PRI(29) EXIT
  32. time_off (22466855 ) test( 6305)(pri= 29)(state=64)-> test( 6307)(pri= 29)(state=0)
  33. time_off (25563548 ) test( 6307)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  34. time_off (25563566 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6307)(pri= 29)(state=0)
  35. time_off (28973602 ) test( 6307)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  36. time_off (28973616 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6307)(pri= 29)(state=0)
  37. task :test PID(6307) PRI(29) EXIT
  38. time_off (31846121 ) test( 6307)(pri= 29)(state=64)-> test( 6309)(pri= 29)(state=0)
  39. time_off (32383671 ) test( 6309)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  40. time_off (32383683 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6309)(pri= 29)(state=0)
  41. time_off (35793735 ) test( 6309)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  42. time_off (35793747 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6309)(pri= 29)(state=0)
  43. time_off (39203797 ) test( 6309)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  44. time_off (39203809 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6309)(pri= 29)(state=0)
  45. task :test PID(6309) PRI(29) EXIT
  46. time_off (41200440 ) test( 6309)(pri= 29)(state=64)-> test( 6311)(pri= 49)(state=0)
  47. time_off (42613866 ) test( 6311)(pri= 49)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  48. time_off (42613898 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6311)(pri= 49)(state=0)
  49. time_off (46024070 ) test( 6311)(pri= 49)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  50. time_off (46024082 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6311)(pri= 49)(state=0)
  51. time_off (49434004 ) test( 6311)(pri= 49)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  52. time_off (49434017 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6311)(pri= 49)(state=0)
  53. task :test PID(6311) PRI(49) EXIT
    可以清楚的可到，同样是70优先级（内核态是29），6305退出以前，6307根本就捞不着跑。同样6307退出一样，6309根本就捞不着跑。这就是FIFO。
 
B) RR的情况

  1. 终端1 ：
  2. stap ./cswmon_spec.stp 70
  4. 终端2 ：
  5. ./getpsinfo.sh
  7. 终端3
  8. ./comp.sh 1

 
    实时优先级是70的三个进程齐头并进。再看第二个脚本的输出：

  1. time_off ( 4188015 ) test( 6428)(pri= 0)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  2. time_off ( 4188025 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6428)(pri= 0)(state=0)
  3. time_off ( 7612014 ) test( 6428)(pri= 0)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  4. time_off ( 7612024 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6428)(pri= 0)(state=0)
  5. task :test PID(6428) PRI(0) EXIT
  6. time_off (10679062 ) test( 6428)(pri= 0)(state=64)-> test( 6430)(pri= 29)(state=0)
  7. time_off (10964413 ) test( 6430)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  8. time_off (10964422 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6430)(pri= 29)(state=0)
  9. time_off (11709024 ) test( 6430)(pri= 29)(state=0)-> test( 6432)(pri= 29)(state=0)
  10. time_off (12736030 ) test( 6432)(pri= 29)(state=0)-> test( 6434)(pri= 29)(state=0)
  11. time_off (13779022 ) test( 6434)(pri= 29)(state=0)-> test( 6430)(pri= 29)(state=0)
  12. time_off (13879021 ) test( 6430)(pri= 29)(state=0)-> test( 6432)(pri= 29)(state=0)
  13. time_off (13984075 ) test( 6432)(pri= 29)(state=0)-> test( 6434)(pri= 29)(state=0)
  14. time_off (14084020 ) test( 6434)(pri= 29)(state=0)-> test( 6430)(pri= 29)(state=0)
  15. time_off (14184023 ) test( 6430)(pri= 29)(state=0)-> test( 6432)(pri= 29)(state=0)
  16. time_off (14284024 ) test( 6432)(pri= 29)(state=0)-> test( 6434)(pri= 29)(state=0)
  17. time_off (14374486 ) test( 6434)(pri= 29)(state=0)-> watchdog/1( 10)(pri= 0)(state=0)
  18. time_off (14374502 ) watchdog/1( 10)(pri= 0)(state=1)-> test( 6434)(pri= 29)(state=0)
  19. time_off (14384097 ) test( 6434)(pri= 29)(state=0)-> test( 6430)(pri= 29)(state=0)
  20. time_off (14484066 ) test( 6430)(pri= 29)(state=0)-> test( 6432)(pri= 29)(state=0)
  21. time_off (14584023 ) test( 6432)(pri= 29)(state=0)-> test( 6434)(pri= 29)(state=0)
  22. time_off (14684020 ) test( 6434)(pri= 29)(state=0)-> test( 6430)(pri= 29)(state=0)
  23. time_off (14786032 ) test( 6430)(pri= 29)(state=0)-> test( 6432)(pri= 29)(state=0)
  24. time_off (14886020 ) test( 6432)(pri= 29)(state=0)-> test( 6434)(pri= 29)(state=0)
  25. time_off (14986026 ) test( 6434)(pri= 29)(state=0)-> test( 6430)(pri= 29)(state=0)
  26. time_off (15089023 ) test( 6430)(pri= 29)(state=0)-> test( 6432)(pri= 29)(state=0)
  27. time_off (15192030 ) test( 6432)(pri= 29)(state=0)-> test( 6434)(pri= 29)(state=0)
  28. time_off (15292026 ) test( 6434)(pri= 29)(state=0)-> test( 6430)(pri= 29)(state=0)
  29. time_off (15396085 ) test( 6430)(pri= 29)(state=0)-> test( 6432)(pri= 29)(state=0)
  30. time_off (15496022 ) test( 6432)(pri= 29)(state=0)-> test( 6434)(pri= 29)(state=0)
  31. time_off (15596027 ) test( 6434)(pri= 29)(state=0)-> test( 6430)(pri= 29)(state=0)
  32. time_off (15696153 ) test( 6430)(pri= 29)(state=0)-> test( 6432)(pri= 29)(state=0)
  33. time_off (15796022 ) test( 6432)(pri= 29)(state=0)-> test( 6434)(pri= 29)(state=0)
    用户态实时优先级为99，内核态优先级为0的进程6428退出后，3个用户态实时优先级为70的进程6430，6432，6434你方唱罢我登场，每个人都"唱"多久呢？看相邻2条记录的时间差，基本都在100ms左右，这就是时间片。
 
    后记：如果放开绑定到一个CPU的限制，同时加大实时进程的个数，多个实时进程在CPU之间PULL和PUSH，是更复杂的情况，呵呵，希望抛砖引玉，能有人模拟下这种情况。
 
    附件为测试代码及输出：
     study_sched.txt   
参考文献
1 深入linux 内核架构
2 linux system program
3 systemtap example

转载于:https://www.cnblogs.com/diegodu/p/3924927.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/575291.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

echarts 获取点击的y轴数值_有机磷酸催化对醌的不对称直接加成反应合成轴手性芳基醌类化合物...

echarts 获取点击的y轴数值_有机磷酸催化对醌的不对称直接加成反应合成轴手性芳基醌类化合物...

有机磷酸催化对醌的不对称直接加成反应合成轴手性芳基醌类化合物本文作者&#xff1a;Summer轴手性联芳基二醇骨架广泛存在于天然产物、生物活性分子、有用的手性配体以及催化剂中(Figure 1a)&#xff0c;因此&#xff0c;轴手性联芳基二醇化合物的合成受到广泛关注且已经取得了…
阅读更多...
H264解码的一个測试程序

H264解码的一个測试程序

网上看到的一个H264视频格式的解码測试程序&#xff0c;能够用来參考其逻辑流程。 代码例如以下&#xff1a; Test_Display_H264(){ in_fd open(H264_INPUT_FILE, O_RDONLY); //video file open fstat(in_fd, &s); …
阅读更多...
spring框架 web开发_go语言web开发框架学习：Iris框架讲解（一）

spring框架 web开发_go语言web开发框架学习：Iris框架讲解（一）

Golang介绍Go语言是谷歌推出的一种全新的编程语言&#xff0c;可以在不损失应用程序性能的情况下降低代码的复杂性。谷歌首席软件工程师罗布派克(Rob Pike)说&#xff1a;我们之所以开发Go&#xff0c;是因为过去10多年间软件开发的难度令人沮丧。谷歌资深软件工程师罗布派克(R…
阅读更多...
linux终端的背景_如何在终端显示图像缩略图 | Linux 中国

linux终端的背景_如何在终端显示图像缩略图 | Linux 中国

lsix 是一个简单的命令行实用程序&#xff0c;旨在使用 Sixel 图形格式在终端中显示缩略图。-- Sk不久前&#xff0c;我们讨论了 Fim[1]&#xff0c;这是一个轻量级的命令行图像查看器应用程序&#xff0c;用于从命令行显示各种类型的图像&#xff0c;如 bmp、gif、jpeg 和 png…
阅读更多...
混合App开发，HBuilder开发移动App

混合App开发，HBuilder开发移动App

使用HBuilder开发混合App&#xff1a; Hbuilder&#xff1a;是一个在线打包工具&#xff0c;不需要在本地配置开发环境&#xff1b;直接将做好的网站&#xff0c;通过一些简单的操作&#xff0c;就能在线打包为一个App&#xff1b; 混合APP开发常见技术&#xff1a;Html5、Re…
阅读更多...
fanuc roboguide_ROBOGUIDE软件：机器人产线输送带输送物料虚拟仿真操作

fanuc roboguide_ROBOGUIDE软件：机器人产线输送带输送物料虚拟仿真操作

概述输送带在机器人生产线或工作站中是常见的物料传送设备&#xff0c;它能够将物料从一个工位自动传送到另一个工位&#xff0c;是实现自动化生产制造必不可少的装置设备之一。虚拟仿真是对真实的工业机器人生产线或工作站的图形化再现&#xff0c;因此&#xff0c;对于具有输…
阅读更多...
双电阻差分电流采样_小小的采样电阻，还真有点门道！

双电阻差分电流采样_小小的采样电阻，还真有点门道！

电流检测电阻的基本原理根据欧姆定律,当被测电流流过电阻时,电阻两端的电压与电流成正比.当1W的电阻通过的电流为几百毫安时,这种设计是没有问题的.然而如果电流达到10-20A,情况就完全不同,因为在电阻上损耗的功率(PI2xR)就不容忽视了.我们可以通过降低电阻阻值来降低功率损耗,…
阅读更多...
jpa in查询_优选在shopee虾皮怎么发货价格查询皮皮虾云仓

jpa in查询_优选在shopee虾皮怎么发货价格查询皮皮虾云仓

优选在shopee虾皮怎么发货价格查询皮皮虾云仓皮皮虾云仓物流系统为现代化管理系统&#xff0c;可集中化&#xff0c;高效化的处理本土店物流订单。物流系统可对接主流的的电商平台ERP可以实现高效的订单处理。如lazada&#xff0c;shopee&#xff0c;1688、速卖通、eaby、shopi…
阅读更多...
html5+、ReactNative、Weex、Ionic之间的区别、（配置java、python、Android环境）、ReactNative(react-native-cli)、yarn、Weex

html5+、ReactNative、Weex、Ionic之间的区别、（配置java、python、Android环境）、ReactNative(react-native-cli)、yarn、Weex

html5、ReactNative、Weex、Ionic之间的区别&#xff1a; html5和Ionic&#xff1a; 在开发原理上基本相同&#xff0c;都是需要先开发出一个完整的网站&#xff0c;再通过html5或Ionic提供的打包技术对网站进行打包成移动app&#xff0c;它们实际还是一个网站&#xff0c;并非…
阅读更多...
delphi listview失去焦点后的颜色_阴阳师姑获鸟和惠比寿建模更新对比 爷爷帅了 觉醒后鸟姐颜值提升...

delphi listview失去焦点后的颜色_阴阳师姑获鸟和惠比寿建模更新对比 爷爷帅了 觉醒后鸟姐颜值提升...

阴阳师体验服近期更新了人气式神姑获鸟还有惠比寿的相关建模&#xff0c;本次特别奉上有关这两位式神的建模形象对比图&#xff0c;对比后发现经过修改和优化之后&#xff0c;爷爷更帅了&#xff0c;而觉醒后的鸟姐颜值也有所提升&#xff0c;一起来看看吧。惠比寿觉醒前觉醒前…
阅读更多...
kibana 显示 @timestamp 时间问题（utc or browser当前时间）自动转换显示

kibana 显示 @timestamp 时间问题（utc or browser当前时间）自动转换显示

https://github.com/elasticsearch/kibana/issues/95 可以统一timestamp时间字段为当前信息时区的时间&#xff01; http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/mapping-date-format.html 转载于:https://www.cnblogs.com/sunxucool/p/3939701.ht…
阅读更多...
React简介、虚拟DOM、Diff算法、创建React项目、JSX语法、组件、组件声明方式、组件传值props和state、组件的生命周期

React简介、虚拟DOM、Diff算法、创建React项目、JSX语法、组件、组件声明方式、组件传值props和state、组件的生命周期

React简介&#xff1a; 前面只是简单介绍移动APP开发&#xff0c;后面还会继续深入介绍移动app开发&#xff1b;其中想要用ReactNative开发出更出色的应用&#xff0c;那么就得学好React&#xff0c;下面将介绍React&#xff1a; React 是一个由 Facebook 开发用于构建用户界…
阅读更多...
去掉 edittext 长按全选_开封消毒湿巾全选

去掉 edittext 长按全选_开封消毒湿巾全选

开封消毒湿巾全选 　　其实&#xff0c;带有杀菌效果的清洁产品大多通过降低微生物的繁殖力达到预期的杀菌效果&#xff0c;所添加的每种杀菌成分都针对特定细菌&#xff0c;无法杀灭所有细菌。如果产品中的杀菌剂浓度总是不能将细菌完全杀灭&#xff0c;就可能导致细菌对该类杀…
阅读更多...
代数余子式之和怎么算_小明说养老 | 养老金怎么算之月平均缴费指数怎么来的？...

代数余子式之和怎么算_小明说养老 | 养老金怎么算之月平均缴费指数怎么来的？...

上一期小明分享了企业职工养老保险退休待遇怎么算&#xff0c;具体可戳小明说养老|养老金怎么算&#xff1f;小明来教你。在以张阿姨为例的计算举例中&#xff0c;提到张阿姨15年的平均缴费指数为0.8209。对这个平均缴费指数的概念提问较多&#xff0c;今天就来解释一下月平均缴…
阅读更多...
ReactNative简介、开发环境、调试、常用组件、useState状态、FlatList组件、SectionList组件、Platform 模块、定义样式、图片组件、触摸事件、打包apk发布版

ReactNative简介、开发环境、调试、常用组件、useState状态、FlatList组件、SectionList组件、Platform 模块、定义样式、图片组件、触摸事件、打包apk发布版

ReactNative简介&#xff1a; ReactNative是基于React语法来进行开发移动app的框架&#xff1b; ReactNative中提供了移动端专用的一些组件&#xff0c;我们要使用ReactNative固有的组件代替网页中使用的一些元素&#xff0c;如&#xff1a;div, p, img 都不能用了&#xff1…
阅读更多...
odis工程师使用方法_傅里叶红外光谱仪常见故障维修及排除方法，你了解有多少种呢？...

odis工程师使用方法_傅里叶红外光谱仪常见故障维修及排除方法，你了解有多少种呢？...

傅里叶红外光谱仪在使用过程中难免会出现故障&#xff0c;那我们该怎么检修呢&#xff1f;赛默飞傅里叶红外光谱仪有些光谱仪器的使用说明书会给出光谱仪的常见故障及排查方法&#xff0c;有些光谱仪器还有自诊断功能&#xff0c;当傅里叶红外光谱仪不能正常工作时&#xff0c;…
阅读更多...
微信小程序简介、发展史、小程序的优点、申请账号、开发工具、初识wxml文件和wxss文件

微信小程序简介、发展史、小程序的优点、申请账号、开发工具、初识wxml文件和wxss文件

微信小程序介绍&#xff1a; 小程序简介&#xff1a; 小程序是一种连接用户与服务的方式&#xff0c;它能在微信内被便捷地获取和传播&#xff0c;具有出色的使用体验。 不需要下载安装&#xff0c;用户通过搜一搜或扫一扫就可以打开使用&#xff0c;使用完后退出即可。 小…
阅读更多...
tia v15 添加项目_硬技能，TIA 博途软件界面的介绍

tia v15 添加项目_硬技能，TIA 博途软件界面的介绍

在前面的文章中给大家介绍了TIA 博途软件的安装包等介绍&#xff0c;这次小编给大家介绍一下TIA 博途软件的界面。#电工学习PLC#你知道吗&#xff0c;在博途软件的自动化项目任务的创建中&#xff0c;我们可以使用portal视图和项目视图。Portal视图是面向任务的视图&#xff0c…
阅读更多...
UIImagePickerController按钮的中文问题

UIImagePickerController按钮的中文问题

UIImagePickerController按钮的中文问题 执行以下两步即可 1. 在targets中设置region为China 2. 在project中添加支持中文 转载于:https://www.cnblogs.com/YouXianMing/p/3935460.html
阅读更多...
rsatool使用步骤图解_工作中想要事半功倍？图解来助你

rsatool使用步骤图解_工作中想要事半功倍？图解来助你

一次会议上&#xff0c;老板让我们进行一场头脑风暴&#xff0c;然后将脑中浮现出来的想法以ppt的形式&#xff0c;在会议上与大家分享。在会上我看到其他区域的同事做的ppt&#xff0c;真的叫一个精美啊&#xff0c;有图形对比、有案例分析、有未来展望。反观自己的&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023