【转帖】isolcpus功能与使用

isolcpus,功能,使用 · 浏览次数 : 0

小编点评

**生成内容时需要带简单的排版** **排版格式** * **空行** * ****换行** * ****字体** * ****颜色** * ****格式** **排版示例** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ``` 空行 **换行** **字体** **颜色** **格式** ```

正文

isolcpus功能存在已久，笔者追溯v2.6.11（2005年）那时内核就已经存在了isolcpus功能。根据kernel-parameters.txt 上的解释，”isolcpus功能用于在SMP均衡调度算法中将一个或多个CPU孤立出来。同时可通过亲和性设置将进程置于 “孤立CPU”运行，isolcpus后面所跟的cpu参数，可设置孤立0~最大CPU个数-1个cpu。这种方法是推荐使用的孤立cpu的方式，与手动设置每个任务的亲和性相比，后一种方式降低了调度器的性能”。

    isolcpus带来的好处是有效地提高了孤立cpu上任务运行的实时性。该功能在保证孤立cpu上任务的运行，同时减少了其他任务可以运行的cpu资源，所以需要使用前对cpu资源进行规划：

isolcpus功能使用步骤：

1、  决定需要孤立多少、哪些cpu。

如果需要孤立多个cpu，应当尽量使孤立cpu与非孤立cpu尽量不属于同一个域。

2、命令行参数添加孤立cpu。

修改/boot/grub/grub.conf文件，比如孤立cpu5~8核（cpu id对应4~7），添加isolcpus=4,5,6,7至内核命令行，逗号分隔。

3、  禁止使用中断均衡服务。

中断均衡会使得孤立核上中断不确定性，导致孤立核上任务实时性能下降。同时避免均衡带来的效益会被cache刷新的开销抵消掉。

4、  了解所有中断，进行中断亲和的设计与设置。

5、  决定运行在孤立cpu上的任务。

如下是双核系统，孤立cpu0，启动之后的部分进程情况：

  1.   PID COMMAND                                          PSR
  2.  
  3.     1 /sbin/init                                         1
  4.  
  5.     3 [migration/0]                                      0
  6.  
  7.     4 [ksoftirqd/0]                                      0
  8.  
  9.     5 [watchdog/0]                                       0
  10.  
  11.     6 [migration/1]                                      1
  12.  
  13.     7 [ksoftirqd/1]                                      1
  14.  
  15.     8 [watchdog/1]                                       1
  16.  
  17.     9 [events/0]                                         0
  18.  
  19.    10 [events/1]                                         1
  20.  
  21.    18 [kintegrityd/0]                                    0
  22.  
  23.    19 [kintegrityd/1]                                    1
  24.  
  25.    20 [kblockd/0]                                        0
  26.  
  27.    21 [kblockd/1]                                        1
  28.  
  29.    25 [ata/0]                                            0
  30.  
  31.    26 [ata/1]                                            1
  32.  
  33.    36 [aio/0]                                            0
  34.  
  35.    37 [aio/1]                                            1
  36.  
  37.    38 [crypto/0]                                         0
  38.  
  39.    39 [crypto/1]                                         1
  40.  
  41.    45 [kpsmoused]                                        0
  42.  
  43.    46 [usbhid_resumer]                                   0
  44.  
  45.    75 [kstriped]                                         0
  46.  
  47.  1081 rpcbind                                            1
  48.  
  49.  1093 mdadm --monitor --scan -f--pid-file=/var/run/mdad   1
  50.  
  51.  1102 dbus-daemon --system                               1
  52.  
  53.  1113 NetworkManager--pid-file=/var/run/NetworkManager/   1
  54.  
  55.  1117 /usr/sbin/modem-manager                            1
  56.  
  57.  1124 /sbin/dhclient -d -4 -sf/usr/libexec/nm-dhcp-clie   1
  58.  
  59.  1129 /usr/sbin/wpa_supplicant -c/etc/wpa_supplicant/wp   1
  60.  
  61.  1131 avahi-daemon: registering[linux.local]              1
  62.  
  63.  1132 avahi-daemon: chroot helper                        1
  64.  
  65.  1598 sshd: root@pts/0                                   1
  66.  
  67.  1603 -bash                                              1

可以看到有一些内核线程比如[kblockd/0]占用了CPU0,这是因为它指定了在CPU0上执行。其余的进程占用了CPU1。启动系统时默认不使用CPU0,但并不是不可以使用,操作系统仍然可以显式指定使用0号CPU。

    最后要说明的是如果使用isolcpus=1,则系统默认会使用CPU0提供服务。如果我们只有两个cpu,却指定孤立了所有cpu，isolcpus=0,1,这时默认使用的是第一个cpu即CPU0提供服务。

isolcpus原理与代码分析
设置与初始化
isolcpus设置
上文所述，Isolcpus变量通过boot传入内核后，首先通过isolated_cpu_setup复值给cpu_isolated_map，cpu_isolated_map表示孤立cpu组的位图。
 

  1. /* cpus with isolated domains */
  2.  
  3. static cpumask_var_t cpu_isolated_map;
  4.  
  5.  
  6.  
  7. /* Setup the mask of cpus configured forisolated domains */
  8.  
  9. static int __init isolated_cpu_setup(char*str)
  10.  
  11. {undefined
  12.  
  13.          alloc_bootmem_cpumask_var(&cpu_isolated_map);
  14.  
  15.          cpulist_parse(str,cpu_isolated_map);
  16.  
  17.          return1;
  18.  
  19. }
  20.  
  21.  
  22.  
  23. __setup("isolcpus=",isolated_cpu_setup);

在调度域（SchedulingDomains）初始化(arch_init_sched_domains)的时候，cpu_isolated_map派上用场。

Scheduling Domains初始化
调度域初始化流程，Kernel_init()->sched_init_smp->arch_init_sched_domains():
 

  1. static int arch_init_sched_domains(conststruct cpumask *cpu_map)
  2.  
  3. {undefined
  4.  
  5.          interr;
  6.  
  7.  
  8.  
  9.          arch_update_cpu_topology();
  10.  
  11.          ndoms_cur= 1;
  12.  
  13.          doms_cur= kmalloc(cpumask_size(), GFP_KERNEL);
  14.  
  15.          if(!doms_cur)
  16.  
  17.                    doms_cur= fallback_doms;
  18.  
  19.          cpumask_andnot(doms_cur, cpu_map,cpu_isolated_map);
  20.  
  21.          dattr_cur= NULL;
  22.  
  23.          err = build_sched_domains(doms_cur);
  24.  
  25.          register_sched_domain_sysctl();
  26.  
  27.  
  28.  
  29.          returnerr;
  30.  
  31. }

其中doms_cur是当前调度域中的CPU位图, cpu_map是传入参数cpu_active_mask，可见这里是cpu_active_mask中除去cpu_isolated_map后的cpu作为当前调度域。

调度域是现代硬件技术尤其是多 CPU 多核技术发展的产物。一个 NUMA 架构的系统，系统中的每个 Node 访问系统中不同区域的内存有不同的速度。

同时它又是一个 SMP 系统。由多个物理CPU(Physical Package) 构成。这些物理 CPU 共享系统中所有的内存。但都有自己独立的 Cache 。

每个物理 CPU 又由多个核 (Core) 构成，即Multi-core 技术或者叫 Chip-level Multi processor(CMP) 。一般有自己独立的 L1 Cache，但可能共享 L2Cache 。

每个核中又通过 SMT 之类的技术实现多个硬件线程，或者叫 Virtual CPU( 比如 Intel 的 Hyper-threading 技术 ) 。这些硬件线程，逻辑上看是就是一个 CPU 。它们之间几乎所有的东西都共享。包括 L1 Cache，甚至是逻辑运算单元 (ALU) 以及 Power 。

在上述系统中，最小的执行单元是逻辑 CPU，进程的调度执行也是相对于逻辑 CPU 的。

build_sched_domains用来进行调度域的建立，分为四大块：调度域的初始化、调度组的初始化、调度组cpu power的初始化、运行队列和调度域的关联。

调度域的初始化：

  1.   for_each_cpu(i, cpu_map) {/*孤立cpu排除在调度域初始化之外*/
  2.  
  3.                    cpumask_and(d.nodemask,cpumask_of_node(cpu_to_node(i)),
  4.  
  5.                                 cpu_map);
  6.  
  7.  
  8.  
  9.                    sd= __build_numa_sched_domains(&d, cpu_map, attr, i);
  10.  
  11.                    sd= __build_cpu_sched_domain(&d, cpu_map, attr, sd, i);
  12.  
  13.                    sd= __build_mc_sched_domain(&d, cpu_map, attr, sd, i);
  14.  
  15.                    sd= __build_smt_sched_domain(&d, cpu_map, attr, sd, i);
  16.  
  17.          }

这里分别初始化了以上所述的四个调度域：allnodes_domains、phys_domains、core_domains、cpu_domains。以cpu_domains为例：

  1. static struct sched_domain*__build_smt_sched_domain(struct s_data *d,
  2.  
  3.          conststruct cpumask *cpu_map, struct sched_domain_attr *attr,
  4.  
  5.          structsched_domain *parent, int i)
  6.  
  7. {undefined
  8.  
  9.          structsched_domain *sd = parent;
  10.  
  11. #ifdef CONFIG_SCHED_SMT
  12.  
  13.          sd = &per_cpu(cpu_domains, i).sd;/*四个域均是每cpu变量，保留了cpu所属的四个域*/
  14.  
  15.          SD_INIT(sd,SIBLING);/*设置sd的均衡策略等*/
  16.  
  17.          set_domain_attribute(sd,attr);
  18.  
  19.          cpumask_and(sched_domain_span(sd),cpu_map, topology_thread_cpumask(i));
  20.  
  21.          sd->parent = parent;/* cpu_domains的parent是 core_domains */
  22.  
  23.          parent->child= sd;
  24.  
  25.          cpu_to_cpu_group(i, cpu_map,&sd->groups, d->tmpmask);/*初始化sd中的调度组*/
  26. #endif
  27.  
  28.          returnsd;
  29.  
  30. }

为了配合调度域，在Linux内核中引入了调度组（sched_group）: 每一级的调度域都有一个或多个调度组，每个调度组可以有一个CPU或多个CPU，都被调度域当做一个的整体来对待，对负载的计算，判断都是以该调度域所属的调度组为单位的。

调度组cpu power（cpu处理能力）的初始化:

调度组的cpu power就是调度组的负载能力,例如在超线性的cpu中,主核与超线程的虚拟核它们的负载能力是不一样,在load balance的时候,会根据各组的cpu power来决定应该分配给该组多少的负载才合适。在SMP系统中,各CPU是完全对称的,也就是说,它们的处理能力都是一样的,因此在这里,每个cpu对应的调度组的cpu power设置为SHED_LOAD_SCALE。
 

  1. static void init_sched_groups_power(intcpu, struct sched_domain *sd)
  2.  
  3. {undefined
  4.  
  5.          structsched_domain *child;
  6.  
  7.          structsched_group *group;
  8.  
  9.          longpower;
  10.  
  11.          intweight;
  12.  
  13.  
  14.  
  15.          WARN_ON(!sd|| !sd->groups);
  16.  
  17.  
  18.  
  19.          if(cpu != group_first_cpu(sd->groups))
  20.  
  21.                    return;
  22.  
  23.  
  24.  
  25.          sd->groups->group_weight= cpumask_weight(sched_group_cpus(sd->groups));
  26.  
  27.  
  28.  
  29.          child= sd->child;
  30.  
  31.  
  32.  
  33.          sd->groups->cpu_power= 0;
  34.  
  35.  
  36.  
  37.          if(!child) {undefined
  38.  
  39.                    power= SCHED_LOAD_SCALE;
  40.  
  41.                    weight= cpumask_weight(sched_domain_span(sd));
  42.  
  43.                    /*
  44.  
  45.                     * SMT siblings share the power of a singlecore.
  46.  
  47.                     * Usually multiple threads get a better yieldout of
  48.  
  49.                     * that one core than a single thread wouldhave,
  50.  
  51.                     * reflect that in sd->smt_gain.
  52.  
  53.                     */
  54.  
  55.                    if((sd->flags & SD_SHARE_CPUPOWER) && weight > 1) {undefined
  56.  
  57.                             power*= sd->smt_gain;
  58.  
  59.                             power/= weight;
  60.  
  61.                             power>>= SCHED_LOAD_SHIFT;
  63.                    }
  64.  
  65.                   sd->groups->cpu_power+= power;/*如果没有子sg，cpu_power等于SCHED_LOAD_SCALE */
  66.  
  67.                    return;
  68.  
  69.          }
  70.  
  71.  
  72.  
  73.          /*
  74.  
  75.           * Add cpu_power of each child group to thisgroups cpu_power.
  76.  
  77.           */
  78.  
  79.          group= child->groups;
  80.  
  81.          do{
  82.  
  83.                    sd->groups->cpu_power+= group->cpu_power;
  84.  
  85.                    group= group->next;
  86.  
  87.          }while (group != child->groups); /*如果有子sg，cpu_power等于各子组的cpu_power 之和 */
  88.  
  89. }

最后将运行队列和调度域的关联，运行队列和调度域的关联在以下代码中完成:

Cpu_attach_domain()如下:

  1. /*
  2.  
  3.  *Attach the domain 'sd' to 'cpu' as its base domain. Callers must
  5.  *hold the hotplug lock.
  7.  */
  9. cpu_attach_domain
  10.  
  11. {undefined
  12.  
  13. … …
  14.  
  15.  
  16.  
  17.          sched_domain_debug(sd,cpu);
  18.  
  19.  
  20.  
  21.          rq_attach_root(rq,rd);
  22.  
  23.          rcu_assign_pointer(rq->sd, sd); /*将rq->sd=sd.即cpu的运行队列指向其基本调度域，后续均衡时需要通过cpu找到其所属的sd：
  24.  
  25. for_each_domain(cpu, __sd) for (__sd =rcu_dereference(cpu_rq(cpu)->sd); __sd; __sd = __sd->parent) */
  26.  
  27. }
  28.  
  29. #define rcu_assign_pointer(p, v)       ({ \
  30.  
  31.                                                         smp_wmb();\
  32.  
  33.                                                         (p)= (v); \
  34.  
  35.                                                })

负载均衡时机与算法

均衡的时机有定时均衡、闲时均衡和唤醒均衡三种。

定时均衡

时钟中断时，会根据条件触发均衡软中断（内核为其设置了专门的软中断），称为定时均衡。

  1.  void__init sched_init(void)
  2.  
  3. {undefined
  4.  
  5. …
  6.  
  7.          open_softirq(SCHED_SOFTIRQ,run_rebalance_domains);
  8.  
  9. …
  10.  
  11. }

在tick中断处理中,会调用scheduler_tick()：

  1. void scheduler_tick(void)
  2.  
  3. {undefined
  4.  
  5. … …
  6.  
  7.  
  8.  
  9. #ifdef CONFIG_SMP
  10.  
  11.          rq->idle_at_tick= idle_cpu(cpu);
  12.  
  13.          trigger_load_balance(rq,cpu);
  14.  
  15. #endif
  16.  
  17. … …
  18.  
  19. }

trigger_load_balance代码实现如下：

  1. static inline voidtrigger_load_balance(struct rq *rq, int cpu)
  2.  
  3. {undefined
  4.  
  5. … …  
  6.  
  7.          if(time_after_eq(jiffies, rq->next_balance) &&/* rq->next_balance表示下次load balance操作的时间戳，避免进行load balance的操作过于频繁*/
  8.  
  9.              likely(!on_null_domain(cpu)))
  10.  
  11.                    raise_softirq(SCHED_SOFTIRQ);
  12.  
  13. }

如果jiffies大于或者等于rq->next_balance时候,就会调用raise_softirq()将load balance的软中断打开。rq->next_balance表示下次loadbalance操作的时间戳。这样是为了避免进行load balance的操作过于频繁,影响系统性能。

该软中断对应的处理函数为run_rebalance_domains()：
 

  1. static void run_rebalance_domains(structsoftirq_action *h)
  2.  
  3. {undefined
  4.  
  5.          intthis_cpu = smp_processor_id();
  6.  
  7.          structrq *this_rq = cpu_rq(this_cpu);
  8.  
  9.          enumcpu_idle_type idle = this_rq->idle_at_tick ?
  10.  
  11.                                                         CPU_IDLE: CPU_NOT_IDLE;/* this_rq->idle_at_tick表示当前的运行队列是否空闲*/
  12.  
  13.  
  14.  
  15.          rebalance_domains(this_cpu,idle);
  16.  
  17.  
  18.  
  19. … …
  20.  
  21. }

rebalance_domains

  1. static void rebalance_domains(intcpu, enum cpu_idle_type idle)
  2.  
  3. {undefined
  4.  
  5. … …
  6.  
  7. /*从基本调度域开始从下往上遍历，可见非孤立cpu跟本不会尝试从孤立cpu上进行均衡，因为根本不在一个sd中，这里是和排他性绑定的区别*/
  8.  
  9.          for_each_domain(cpu,sd) {
  10.  
  11.                    if(!(sd->flags & SD_LOAD_BALANCE))
  12.  
  13.                             continue;
  14.  
  15. /*计算平衡的时间间隔*/
  16.  
  17.                    interval= sd->balance_interval;/* balance_interval 在初始化SD_**_INIT设置*/
  18.  
  19. /*如果当前CPU不为空闲,调整时间间隔为较长值, 在当前CPU忙和空闲的情况下,执行load balance的频率是不一样的,在空闲情况下,会以很高的频率执行*/
  20.  
  21.                    if(idle != CPU_IDLE)
  22.  
  23.                             interval*= sd->busy_factor;
  24.  
  25.  
  26.  
  27.                    /*将ms转换成jiffies*/
  28.  
  29.                    interval= msecs_to_jiffies(interval);
  30.  
  31. /*对interval大小进行有效性调整*/
  32.  
  33.                    if(unlikely(!interval))
  34.  
  35.                             interval= 1;
  36.  
  37.                    if(interval > HZ*NR_CPUS/10)
  38.  
  39.                             interval= HZ*NR_CPUS/10;
  40.  
  41.  
  42.  
  43.                    need_serialize= sd->flags & SD_SERIALIZE;
  44.  
  45.  
  46.  
  47.                    if(need_serialize) {undefined
  48.  
  49.                             if(!spin_trylock(&balancing)) /*每个load balance的soft irq必须持有自旋锁才能进行下一步操作*/
  50.  
  51.                                      gotoout;
  52.  
  53.                    }
  54.  
  55. /*如果到了调度时间*/
  56.  
  57.                    if(time_after_eq(jiffies, sd->last_balance + interval)) {undefined
  58.  
  59.                             if (load_balance(cpu, rq, sd, idle,&balance)) {
  60.  
  61. /*均衡操作：
  62.  
  63. 从子sched_domain到父sched_domain遍历该CPU对应的domain，优先在低级domain中寻找迁移任务，该sched_domain里最忙的sched_group，从该group里找出最忙的运行队列，从该“最忙”运行队列里挑出几个进程到当前CPU的运行队列里*/
  64.  
  65.                                      /*已经从其它cpu上拉了进程过来,所以不再空闲了*/
  66.  
  67.                                      idle= CPU_NOT_IDLE;
  68.  
  69.                             }
  70.  
  71.                             sd->last_balance= jiffies;
  72.  
  73.                    }
  74.  
  75.                    if(need_serialize)
  76.  
  77.                             spin_unlock(&balancing);
  78.  
  79. out:
  80.  
  81.                    if(time_after(next_balance, sd->last_balance + interval)) {undefined
  82.  
  83.                             next_balance= sd->last_balance + interval;
  84.  
  85.                             update_next_balance= 1;
  86.  
  87.                    }
  88.  
  89.  
  90.  
  91.                    /*
  92.  
  93.                     * Stop the load balance at this level. Thereis another
  94.  
  95.                     * CPU in our sched group which is doing loadbalancing more
  96.  
  97.                     * actively.
  98.  
  99.                     */
  100.  
  101. /*如果balance为0,表示在所属调度组中有更合适的cpu来做负载平衡的工作，退出*/
  102.  
  103.                    if(!balance)
  104.  
  105.                             break;
  106.  
  107.          }
  108.  
  109.  
  110.  
  111.          /*
  112.  
  113.           * next_balance will be updated only when thereis a need.
  114.  
  115.           * When the cpu is attached to null domain forex, it will not be
  116.  
  117.           * updated.
  118.  
  119.           */
  120.  
  121.          if(likely(update_next_balance))
  122.  
  123.                    rq->next_balance= next_balance;
  124.  
  125. }

load_balance()中进行，load_balance函数实现与下文的load_balance_newidle基本一致，后文介绍。从子sched_domain到父sched_domain遍历该CPU对应的domain，优先在低级domain中寻找迁移任务，该sched_domain里最忙的sched_group，从该group里找出最忙的运行队列，从该“最忙”运行队列里挑出几个进程到当前CPU的运行队列里。


 

闲时均衡
任务调度时，会检查当前cpu是否空闲，如果空闲则进行负载均衡，相应均衡函数为idle_balance()，与定时均衡相比，只要拉到任务就会返回不会遍历完所有的调度域属于轻量级均衡算法。

CPU的运行队列里如果为空，就说明当前CPU没有可调度的任务了，那就要调用idle_balance从其它CPU上“均衡”一些进程到当前rq里:
 

  1. asmlinkage void __sched schedule(void)
  2.  
  3. {… …
  4.  
  5.          if(unlikely(!rq->nr_running))
  6.  
  7.                    idle_balance(cpu,rq);
  8.  
  9. … …
  10.  
  11. }

再看idle_balance（）的实现,

  1. static voididle_balance(intthis_cpu, struct rq *this_rq)
  2.  
  3. {undefined
  4.  
  5. …
  6.  
  7. /*从基本调度域开始从下往上遍历，可见非孤立cpu跟本不会尝试从孤立cpu上进行均衡，因为根本不在一个sd中，这里是和排他性绑定的区别*/
  8.  
  9.          for_each_domain(this_cpu,sd) {undefined
  10.  
  11.                    unsignedlong interval;
  12.  
  13.                    if(!(sd->flags & SD_LOAD_BALANCE))
  14.  
  15.                             continue;
  16.  
  17.  
  18.  
  19.                    if(sd->flags & SD_BALANCE_NEWIDLE)
  20.  
  21.                             /*If we've pulled tasks over stop searching: */
  23.                             pulled_task= load_balance_newidle(this_cpu, this_rq,
  25.                                                                     sd);
  27.  
  29.                    interval= msecs_to_jiffies(sd->balance_interval);
  31.                    if(time_after(next_balance, sd->last_balance + interval))
  33.                             next_balance= sd->last_balance + interval;
  35.                    if(pulled_task) {/*拉到任务即退出*/
  37.                             this_rq->idle_stamp= 0;
  39.                             break;
  41.                    }
  43.          }
  45. …
  47. }

从子sched_domain到父sched_domain遍历该CPU对应的domain，优先在低级domain中寻找迁移任务。关注调用load_balance_newidle:

  1. static int
  2.  
  3. load_balance_newidle(int this_cpu, structrq *this_rq, struct sched_domain *sd)
  4.  
  5. {undefined
  6.  
  7. 。。。 。。。
  8.  
  9.  
  10.  
  11.          schedstat_inc(sd,lb_count[CPU_NEWLY_IDLE]);
  12.  
  13. redo:
  14.  
  15.          update_shares_locked(this_rq,sd);
  16.  
  17.          group= find_busiest_group(sd, this_cpu, &imbalance, CPU_NEWLY_IDLE,
  18.  
  19.                                         &sd_idle, cpus, NULL);/*该sched_domain里最忙的sched_group */
  20.  
  21.          if(!group) {undefined
  22.  
  23.                    schedstat_inc(sd,lb_nobusyg[CPU_NEWLY_IDLE]);
  24.  
  25.                    gotoout_balanced;
  26.  
  27.          }
  28.  
  29.  
  30.  
  31.          busiest= find_busiest_queue(group, CPU_NEWLY_IDLE, imbalance, cpus); /*从该group里找出最忙的运行队列*/       if (!busiest){undefined
  32.  
  33.                    schedstat_inc(sd,lb_nobusyq[CPU_NEWLY_IDLE]);
  34.  
  35.                    gotoout_balanced;
  36.  
  37.          }
  38.  
  39.  
  40.  
  41.          BUG_ON(busiest== this_rq);
  42.  
  43.  
  44.  
  45.          schedstat_add(sd,lb_imbalance[CPU_NEWLY_IDLE], imbalance);
  46.  
  47.  
  48.  
  49.          ld_moved= 0;
  50.  
  51.          if(busiest->nr_running > 1) {undefined
  52.  
  53.                    /*Attempt to move tasks */
  54.  
  55.                    double_lock_balance(this_rq,busiest);
  56.  
  57.                    /*this_rq->clock is already updated */
  58.  
  59.                    update_rq_clock(busiest);
  60.  
  61.                    ld_moved=move_tasks(this_rq, this_cpu,busiest,
  62.  
  63.                                                imbalance,sd, CPU_NEWLY_IDLE,
  64.  
  65.                                                &all_pinned);/*最后从该“最忙”运行队列里挑出几个进程到当前CPU的运行队列里。move_tasks函数到底挪多少进程到当前CPU是由第4个参数决定的，第4个参数是指最多挪多少负载。 */
  66.  
  67.                    double_unlock_balance(this_rq,busiest);
  68.  
  69.  
  70.  
  71.                    if(unlikely(all_pinned)) {undefined
  72.  
  73.                             cpumask_clear_cpu(cpu_of(busiest),cpus);
  74.  
  75.                             if(!cpumask_empty(cpus))
  76.  
  77.                                      gotoredo;
  78.  
  79.                    }
  80.  
  81.          }
  82.  
  83. … …
  84.  
  85. }

在发现不均衡需要movetask的时候，需要考虑亲和性，因此可能移动任务也可能失败导致多次循环尝试，这里也是非排他性绑定性能损失之处：

  1. int can_migrate_task(struct task_struct*p, struct rq *rq, int this_cpu,
  2.  
  3.                         struct sched_domain *sd, enumcpu_idle_type idle,
  4.  
  5.                         int *all_pinned)
  6.  
  7. {undefined
  8.  
  9.          /*
  10.  
  11.           * We do not migrate tasks that are:
  12.  
  13.           * 1) running (obviously), or
  14.  
  15.           * 2) cannot be migrated to this CPU due tocpus_allowed, or
  16.  
  17.           * 3) are cache-hot on their current CPU.
  18.  
  19.           */
  20.  
  21.          if(!cpu_isset(this_cpu, p->cpus_allowed))
  22.  
  23.                    return0;
  24.  
  25.          *all_pinned= 0;
  26.  
  27.  
  28.  
  29.          if(task_running(rq, p))
  30.  
  31.                    return0;
  32.  
  33.  
  34.  
  35.          return1;
  36.  
  37. }

寻找group里找出最忙的运行队列方法：

  1. static struct rq *
  2.  
  3. find_busiest_queue(struct sched_group*group, enum cpu_idle_type idle,
  4.  
  5.                       unsigned long imbalance, cpumask_t *cpus)
  6.  
  7. {undefined
  8.  
  9.          structrq *busiest = NULL, *rq;
  10.  
  11.          unsignedlong max_load = 0;
  12.  
  13.          inti;
  14.  
  15.  
  16.  
  17.          for_each_cpu_mask(i, group->cpumask) {/*轮询该group所有cpu*/
  18.  
  19.                    unsignedlong wl;
  20.  
  21.  
  22.  
  23.                    if(!cpu_isset(i, *cpus))
  24.  
  25.                             continue;
  26.  
  27.  
  28.  
  29.                    rq= cpu_rq(i);
  30.  
  31.                    wl= weighted_cpuload(i);/*计算该cpu上负载，计算方法后文*/
  32.  
  33. #ifdef CONFIG_SIRQ_BALANCE/*是否考虑软中断的负载*/
  34.  
  35.              if (cpu_in_sirq_judge(i)) {undefined
  36.  
  37.                           wl+= SIRQ_WEIGHT(i);
  38.  
  39.                    }
  40.  
  41. #endif
  42.  
  43.                    if(rq->nr_running == 1 && wl > imbalance)
  44.  
  45.                             continue;
  46.  
  47.  
  48.  
  49.                    if(wl > max_load) {/*保存最大负载任务的cpu*/
  50.  
  51.                             max_load= wl;
  52.  
  53.                             busiest= rq;
  54.  
  55.                    }
  56.  
  57.          }
  58.  
  59.  
  60.  
  61.          returnbusiest;
  62.  
  63. }

调度组负载的计算与说明：

如前所述，一个调度组sched_group可能有1个或多个CPU（依赖于硬件和所属调度域的级别）；在计算负载时，会把该调度组所属的每个CPU的负载加在一起作为整个调度组的负载。

CPU的负载计算方法也很简单，就是把CPU的运行队列上每个任务的负载权值累加起来即可；

任务的负载权值通过查如下的权值表来确定：
 

  1. static const int prio_to_weight[40] = {undefined
  2.  
  3.  /*-20 */     88761,     71755,    56483,     46273,     36291,
  4.  
  5.  /*-15 */     29154,     23254,    18705,     14949,     11916,
  6.  
  7.  /*-10 */      9548,      7620,     6100,      4904,      3906,
  8.  
  9.  /*  -5*/      3121,      2501,     1991,      1586,      1277,
  10.  
  11.  /*   0*/      1024,       820,       655,       526,       423,
  12.  
  13.  /*   5*/       335,       272,       215,       172,      137,
  14.  
  15.  /*  10*/       110,        87,        70,        56,        45,
  16.  
  17.  /*  15*/        36,        29,        23,        18,        15,
  18.  
  19. };

对于实时任务 weight =prio_to_weight[0] * 2;

  1.    if(task_has_rt_policy(p)) {undefined
  2.  
  3.                    p->se.load.weight= prio_to_weight[0] * 2;
  4.  
  5.                    p->se.load.inv_weight= prio_to_wmult[0] >> 1;
  7.                    return;
  8.  
  9.          }

对于IDLE任务weight = 2;

对于非实时的公平调度任务，weight= prio_to_weight[p->static_prio - 100];显然，static_prio越小，其权值越大，在CGLE内核中static_prio 取值区间在[100 - 139]，和prio_to_weight表是对应的。

CPU的运行队列(rq)的负载的设置主要有如下点：

任务被添加到运行队列（如被唤醒等情况）时，任务的负载就被加到运行队列的负载(rq->load)上；

任务从运行队列上删除时（如任务被阻塞）时，任务的负载就从运行队列的负载(rq->load)上去除。

唤醒均衡
唤醒任务时，会在try_to_wake_up()中根据当前cpu的调度域参数决定是否进行负载均衡，称为唤醒均衡。this_cpu是实际运行这个函数的处理器称之为“目标处理器” ，变量cpu是进程p在睡眠之前运行的处理器称之为“源处理器”：
 

  1. static int try_to_wake_up(structtask_struct *p, unsigned int state,                         int wake_flags,int mutex)
  2.  
  3. {undefined
  4.  
  5.          if(cpu == this_cpu) {
  6.  
  7.                    schedstat_inc(rq,ttwu_local);
  8.  
  9.                    gotoout_set_cpu;/* 进程p在处理器A上运行，然后睡眠，而运行try_to_wake_up的也是处理器A，其实这样就最好了，进程p在处理器A里cache的数据都不用动，直接让A运行p就行了*/
  10.  
  11.          }
  12.  
  13. }

如果this_cpu和cpu不是同一个处理器，那么代码继续：

  1.    if(unlikely(!cpu_isset(this_cpu, p->cpus_allowed)))
  2.  
  3.                    gotoout_set_cpu;
  4.  
  5. … …
  6.  
  7.          if(this_sd) {/*对于孤立cpu来说，this_sd为空，不会尝试均衡*/
  8.  
  9.                    intidx = this_sd->wake_idx;
  10.  
  11.                    unsignedint imbalance;
  12.  
  13. #ifdef CONFIG_SIRQ_BALANCE
  14.  
  15.              int in_sirq;
  16.  
  17.    
  18.  
  19.                    imbalance= 100 + (this_sd->imbalance_pct - 100) / 2;
  20.  
  21.  
  22.  
  23.              in_sirq =cpu_in_sirq_judge(this_cpu);
  24.  
  25.                    this_load= target_load(this_cpu, idx, in_sirq);
  26.  
  27.  
  28.  
  29.              in_sirq = cpu_in_sirq_judge(cpu);
  30.  
  31.                    load= source_load(cpu, idx, in_sirq);
  32.  
  33. #else
  34.  
  35.              imbalance = 100 +(this_sd->imbalance_pct - 100) / 2;
  36.  
  37.  
  38.  
  39.                    load= source_load(cpu, idx);/*计算源处理器”各自的负载*/
  40.  
  41.                    this_load= target_load(this_cpu,idx);/* 计算 “目标处理器”负载*/
  42.  
  43. #endif
  44.  
  45.                    new_cpu= this_cpu; /* Wake to this CPU if we can */
  46.  
  47.  
  48.  
  49.                   if(this_sd->flags & SD_WAKE_AFFINE) {/*通过读这段代码，我们发现如果一个任务设置同时亲和在孤立cpu与非孤立cpu上，在唤醒均衡时可以看到该任务会调度到非孤立cpu上，将再没有机会回到孤立cpu。所以应当避免将任务同时亲和在孤立cpu与非孤立cpu上这样无趣的做法*/
  50.  
  51.                             unsignedlong tl = this_load;
  52.  
  53.                             unsignedlong tl_per_task;
  54.  
  55.  
  56.  
  57.                             tl_per_task= cpu_avg_load_per_task(this_cpu);/*计算“目标处理器”上的每任务平均负载 tl_per_task*/
  58.  
  59.  
  60.  
  61.                             /*
  62.  
  63.                              * If sync wakeup then subtract the (maximumpossible)
  64.  
  65.                              * effect of the currently running task fromthe load
  66.  
  67.                              * of the current CPU:
  68.  
  69.                              */
  70.  
  71.                             if(sync)
  72.  
  73.                                      tl-= current->se.load.weight;
  74.  
  75. #ifdef CONFIG_SIRQ_BALANCE
  76.  
  77.                             if((tl <= load &&
  78.  
  79.                                      tl+ target_load(cpu, idx, in_sirq) <= tl_per_task) ||
  80.  
  81.                                    100*(tl + p->se.load.weight) <=imbalance*load) {undefined
  82.  
  83. #else
  84.  
  85.                    if ((tl <= load&&
  86.  
  87.                                      tl+ target_load(cpu, idx) <= tl_per_task) ||
  88.  
  89.                                    100*(tl + p->se.load.weight) <=imbalance*load)/*如果“目标处理器”的负载小于“源处理器”的负载且两处理器负载相加都比 tl_per_task小的话，唤醒的进程转为“目标处理器”执行。还有一种情况如果“目标处理器”的负载加上被唤醒的进程的负载后，还比“源处理器”的负载（乘以imbalance后）的小的话，也要把唤醒的进程转为“目标处理器”执行。如果两个因素都不满足，那还是由p进程原来呆的那个CPU（即”源处理器“）继续来处理*/
  90.  
  91. {undefined
  92.  
  93. #endif
  94.  
  95.                                      /*
  96.  
  97.                                       * This domain has SD_WAKE_AFFINE and
  98.  
  99.                                       * p is cache cold in this domain, and
  100.  
  101.                                       * there is no bad imbalance.
  102.  
  103.                                       */
  104.  
  105.                                      schedstat_inc(this_sd,ttwu_move_affine);
  106.  
  107.                                      gotoout_set_cpu;
  108.  
  109.                             }
  110.  
  111.                    }
  112.  
  113.  
  114.  
  115.                    /*
  116.  
  117.                     * Start passive balancing when half theimbalance_pct
  118.  
  119.                     * limit is reached.
  120.  
  121.                     */
  122.  
  123.                    if(this_sd->flags & SD_WAKE_BALANCE) {undefined
  124.  
  125.                             if(imbalance*this_load <= 100*load) {undefined
  126.  
  127.                                      schedstat_inc(this_sd,ttwu_move_balance);
  128.  
  129.                                      gotoout_set_cpu;
  130.  
  131.                             }
  132.  
  133.                    }
  134.  
  135.          }
  136.  
  137.  
  138.  
  139.          new_cpu= cpu; /* Could not wake to this_cpu. Wake to cpu instead */

原文链接：https://blog.csdn.net/haitaoliang/article/details/22427045

文章知识点与官方知识档案匹配，可进一步学习相关知识
云原生入门技能树首页概览11870 人正在系统学习中
isolcpus 功能 使用

与【转帖】isolcpus功能与使用相似的内容：

【转帖】isolcpus功能与使用

isolcpus功能存在已久，笔者追溯v2.6.11（2005年）那时内核就已经存在了isolcpus功能。根据kernel-parameters.txt 上的解释，”isolcpus功能用于在SMP均衡调度算法中将一个或多个CPU孤立出来。同时可通过亲和性设置将进程置于 “孤立CPU”运行，iso

isolcpus 功能 使用
0
[转帖]

Linux ubuntu20.04 网络配置（图文教程） 因为我是刚装好的最小系统，所以很多东西都没有，在开始配置之前需要做下准备 环境准备 系统：ubuntu20.04网卡：双网卡 网卡一：供连接互联网使用网卡二：供连接内网使用（看情况，如果一张网卡足够，没必要做第二张网卡） 工具： net-to

0
[转帖]

https://cloud.tencent.com/developer/article/2168105?areaSource=104001.13&traceId=zcVNsKTUApF9rNJSkcCbB 前言 Redis作为高性能的内存数据库，在大数据量的情况下也会遇到性能瓶颈，日常开发中只有时刻

0
[转帖]ISV 、OSV、 SIG 概念

ISV 、OSV、 SIG 概念 2022-10-14 12:29530原创大杂烩 本文链接：https://www.cndba.cn/dave/article/108699 1. ISV: Independent Software Vendors “独立软件开发商”，特指专门从事软件的开发、生产、

isv osv sig 概念
0
[转帖]Redis 7 参数 修改 说明

2022-06-16 14:491800原创Redis 本文链接：https://www.cndba.cn/dave/article/108066 在之前的博客我们介绍了Redis 7 的安装和配置，如下： Linux 7.8 平台 Redis 7 安装并配置开机自启动 操作手册https://ww

redis 参数 修改 说明
0
[转帖]HTTPS中间人攻击原理

https://www.zhihu.com/people/bei-ji-85/posts 背景 前一段时间，公司北京地区上线了一个HTTPS防火墙，用来监听HTTPS流量。防火墙上线之前，邮件通知给管理层，我从我老大那里听说这个事情的时候，说这个有风险，然后意外地发现，很多人原来都不知道HTTPS防

https 中间人 攻击 原理
0
[转帖]关于字节序（大小端）的一点想法

https://www.zhihu.com/people/bei-ji-85/posts 今天在一个技术群里有人问起来了，当时有一些讨论（不完全都是我个人的观点），整理一下： 为什么网络字节序（多数情况下）是大端？ 早年设备的缓存很小，先接收高字节能快速的判断报文信息：包长度（需要准备多大缓存）、地

关于 字节 大小 一点
0
[转帖]awk提取某一行某一列的数据

https://www.jianshu.com/p/dbcb7fe2da56 1、提取文件中第1列数据 awk '{print $1}' filename > out.txt 2、提取前2列的文件 awk `{print $1,$2}' filename > out.txt 3、打印完第一列，然后打

awk 提取 一行 一列
0
[转帖]awk 中 FS的用法

https://www.cnblogs.com/rohens-hbg/p/5510890.html 在openwrt文件 ar71xx.sh中 查询设备类型时，有这么一句， machine=$(awk 'BEGIN{FS="[ \t]+:[ \t]"} /machine/ {print $2}' /

awk fs 用法
0
[转帖]Windows Server 2022 简体中文版、英文版下载 (updated Oct 2022)

https://sysin.org/blog/windows-server-2022/ Windows Server 2022 正式版，2022 年 10 月更新，VLSC Posted by sysin on 2022-10-27 Estimated Reading Time 8 Minutes

windows server 简体中文版 英文版
0
# 热门排行
微软 New Bing AI 申请与使用保姆级教程（免魔法） ChatGPT API使用介绍 ChatGPT开发实战 一篇带你了解如何使用纯前端类Excel表格构建现金流量表 手把手教你玩转 Excel 数据透视表 为什么 C# 可能是最好的第一编程语言 .NET 入门到高级路线 提高工作效率的神器：基于前端表格实现Chrome Excel扩展插件 React + Springboot + Quartz，从0实现Excel报表自动化 用Echarts实现前端表格引用从属关系可视化
© PmDaddy. 2023 PmDaddy教程网 All rights reserved.