freebsd9.2-ULE线程调度-创建数据结构来描述CPU拓扑信息

71v5

前提：
intel Xeon E3-1226V3，4个物理核心，不支持超线程，即4核心4线程，系统中有两个E3-1226V3，每个E3-1226V3
对应一个package。

在ULE调度程序初始化阶段，函数sched_setup_smp会调用smp_topo函数创建相应的数据结构来描述系统中cpu的
拓扑信息，并初始化变量cpu_top。

[struct cpu_group对象]-用来描述系统中cpu的拓扑信息，每个struct cpu_group对象用来描述系统中的每一个
package，cpu_top指向的struct cpu_group对象描述了系统中全部的package:

1. /***************************************************************************************
   
2. * Topology of a NUMA or HTT system.
   
3. *
   
4. * The top level topology is an array of pointers to groups.  Each group
   
5. * contains a bitmask of cpus in its group or subgroups.  It may also
   
6. * contain a pointer to an array of child groups.
   
7. *
   
8. * The bitmasks at non leaf groups may be used by consumers who support
   
9. * a smaller depth than the hardware provides.
   
10. *
    
11. * The topology may be omitted by systems where all CPUs are equal.
    
12.    
    
13.    static struct cpu_group group[MAXCPU];
    
14.    struct cpu_group *cpu_top;           CPU topology
    
15. 
    
16.    在我们假定的前提下，描述一下各个成员，部分成员通过看图，其含义将一目了然：
    
17. 
    
18.    cg_parent：指向parent group。
    
19. 
    
20.    cg_child：指向children group。
    
21. 
    
22.    cgmask：一个cpu位图，位图中的bit以logical cpu id为索引，在每一个group
    
23.            中，cg_mask中以该group中包含的cpu的logicl cpu id为索引的bit位
    
24.            被设置为1.cpu_top指向的group中cgmask成员设置了系统中全部
    
25.            cpu对应的bit位。
    
26. 
    
27.    cg_count：该group中logical cpu的数目，cpu_top指向的group中cg_count
    
28.              成员为系统中全部logical cpu的数目。
    
29. 
    
30.    cg_children：children group的数目。
    
31.   
    
32.    cg_level：描述每个group中cpu的高速缓存属性，可以取值如下：
    
33.              #define        CG_SHARE_NONE        0
    
34.              #define        CG_SHARE_L1        1
    
35.              #define        CG_SHARE_L2        2
    
36.              #define        CG_SHARE_L3        3
    
37.    
    
38.    cg_flags：可以取值如下，不清楚其具体用处：
    
39.    #define        CG_FLAG_HTT        0x01        Schedule the alternate core last.
    
40.    #define        CG_FLAG_SMT        0x02        New age htt, less crippled.
    
41.    #define        CG_FLAG_THREAD        (CG_FLAG_HTT | CG_FLAG_SMT)  Any threading.
    
42. 
    
43.    这里再谈一下每cpu的运行队列即tdq_cpu，假设cpu的logicl id为2，那么
    
44.    tdq_cpu[2]对象的tdq_cg成员就指向group[1].
    
45. **************************/         
    
46.     34        struct cpu_group {
    
47.     35                struct cpu_group *cg_parent;        /* Our parent group. */
    
48.     36                struct cpu_group *cg_child;        /* Optional children groups. */
    
49.     37                cpuset_t        cg_mask;        /* Mask of cpus in this group. */
    
50.     38                int32_t                cg_count;        /* Count of cpus in this group. */
    
51.     39                int16_t                cg_children;        /* Number of children groups. */
    
52.     40                int8_t                cg_level;        /* Shared cache level. */
    
53.     41                int8_t                cg_flags;        /* Traversal modifiers. */
    
54.     42        };
    
55.     43       
    
56.     44        typedef struct cpu_group *cpu_group_t;

复制代码

先看看函数smp_topo执行完后所创建的使用struct cpu_group对象描述cpu拓扑信息的数据结构图,这样更清楚一点：



[函数smp_topo]：

1. 487        struct cpu_group *
   
2.    488        smp_topo(void)
   
3.    489        {
   
4.    490                char cpusetbuf[CPUSETBUFSIZ], cpusetbuf2[CPUSETBUFSIZ];
   
5.    491                struct cpu_group *top;
   
6.    492       
   
7.    493               
   
8.    494
   
9.    495
   
10. /*******************************************************************
    
11. * Check for a fake topology request for debugging purposes.
    
12.    int smp_topology = 0;  Which topology we're using.                    
    
13. 
    
14.    496-530：这里将调用cpu_topo函数进行探测，这个探测过程挺有意思，
    
15.             下面重点分析这个函数，这个函数完成了描述cpu拓扑信息
    
16.             的大部分工作。
    
17.    
    
18.    531-540：进行额外的有效性检查。
    
19. *********************************/
    
20.    496                switch (smp_topology) {
    
21.    497                case 1:
    
22.    498                        /* Dual core with no sharing.  */
    
23.    499                        top = smp_topo_1level(CG_SHARE_NONE, 2, 0);
    
24.    500                        break;
    
25.    501                case 2:
    
26.    502                        /* No topology, all cpus are equal. */
    
27.    503                        top = smp_topo_none();
    
28.    504                        break;
    
29.    505                case 3:
    
30.    506                        /* Dual core with shared L2.  */
    
31.    507                        top = smp_topo_1level(CG_SHARE_L2, 2, 0);
    
32.    508                        break;
    
33.    509                case 4:
    
34.    510                        /* quad core, shared l3 among each package, private l2.  */
    
35.    511                        top = smp_topo_1level(CG_SHARE_L3, 4, 0);
    
36.    512                        break;
    
37.    513                case 5:
    
38.    514                        /* quad core,  2 dualcore parts on each package share l2.  */
    
39.    515                        top = smp_topo_2level(CG_SHARE_NONE, 2, CG_SHARE_L2, 2, 0);
    
40.    516                        break;
    
41.    517                case 6:
    
42.    518                        /* Single-core 2xHTT */
    
43.    519                        top = smp_topo_1level(CG_SHARE_L1, 2, CG_FLAG_HTT);
    
44.    520                        break;
    
45.    521                case 7:
    
46.    522                        /* quad core with a shared l3, 8 threads sharing L2.  */
    
47.    523                        top = smp_topo_2level(CG_SHARE_L3, 4, CG_SHARE_L2, 8,
    
48.    524                            CG_FLAG_SMT);
    
49.    525                        break;
    
50.    526                default:
    
51.    527                        /* Default, ask the system what it wants. */
    
52.    528                        top = cpu_topo();
    
53.    529                        break;
    
54.    530                }
    
55.    531                /*
    
56.    532                 * Verify the returned topology.
    
57.    533                 */
    
58.    534                if (top->cg_count != mp_ncpus)
    
59.    535                        panic("Built bad topology at %p.  CPU count %d != %d",
    
60.    536                            top, top->cg_count, mp_ncpus);
    
61.    537                if (CPU_CMP(&top->cg_mask, &all_cpus))
    
62.    538                        panic("Built bad topology at %p.  CPU mask (%s) != (%s)",
    
63.    539                            top, cpusetobj_strprint(cpusetbuf, &top->cg_mask),
    
64.    540                            cpusetobj_strprint(cpusetbuf2, &all_cpus));
    
65.    541                return (top);
    
66.    542        }
    

复制代码

[函数cpu_topo]：

1. /*******************************************************************************
   
2. * static int cpu_logical;                         logical cpus per core
   
3.    static int cpu_cores;                         cores per package
   
4.   
   
5.    cpu_logical：
   
6.    每个core包含几个logical cpu，对于支持超线程的cpu，cpu_logical的值为2；
   
7.    对于不支持超线程的cpu，cpu_logical的值为1.根据前提假定，cpu_logical的值为1。
   
8. 
   
9.    cpu_cores：
   
10.    每个cpu包含的物理核心数目，根据前提假定，这里cpu_cores的值为4.
    
11. 
    
12.    其实上面两个变量的值可以通过函数topo_probe_0xb计算得到。
    
13. ******************************/
    
14.    
    
15.    415        struct cpu_group *
    
16.    416        cpu_topo(void)
    
17.    417        {
    
18.    418                int cg_flags;
    
19.    419       
    
20.    420               
    
21.    421
    
22.    422
    
23. /*******************************************************************************
    
24. * Determine whether any threading flags are necessry。
    
25. *
    
26. * mp_ncpus:系统中cpu的数目，在初始化函数apic_init中被设置为有意义的值
    
27. * 424：函数topo_probe确定变量cpu_logical和cpu_cores的值。
    
28.         根据我们的假定，cpu_logical为1，cpu_cores为4.
    
29. 
    
30.    425-430：cg_flags设置为0.
    
31. 
    
32.    431-435：对logical cpu数目进行额外的检查。
    
33. 
    
34.    436-440：单核心单线程cpu。
    
35. 
    
36.    441-445：单核心多线程cpu。
    
37. 
    
38.    446-450：多核心单线程cpu。
    
39. 
    
40.    451-455：多核心多线程cpu。
    
41. 
    
42.    根据我们的前提假定，这里将执行446-450之间的代码，smp_topo_1level函数
    
43.    主要创建描述cpu拓扑信息的struct cpu_group对象，该函数没有什么特殊操作，
    
44.    很容易理解，也没有进行特别的分析，下面列出了这个函数，大家可以看看。
    
45. *****************************************************/
    
46.    423                 
    
47.    424                topo_probe();
    
48.    425                if (cpu_logical > 1 && hyperthreading_cpus)
    
49.    426                        cg_flags = CG_FLAG_HTT;
    
50.    427                else if (cpu_logical > 1)
    
51.    428                        cg_flags = CG_FLAG_SMT;
    
52.    429                else
    
53.    430                        cg_flags = 0;
    
54.    431                if (mp_ncpus % (cpu_cores * cpu_logical) != 0) {
    
55.    432                        printf("WARNING: Non-uniform processors.\n");
    
56.    433                        printf("WARNING: Using suboptimal topology.\n");
    
57.    434                        return (smp_topo_none());
    
58.    435                }
    
59.    436                /*
    
60.    437                 * No multi-core or hyper-threaded.
    
61.    438                 */
    
62.    439                if (cpu_logical * cpu_cores == 1)
    
63.    440                        return (smp_topo_none());
    
64.    441                /*
    
65.    442                 * Only HTT no multi-core.
    
66.    443                 */
    
67.    444                if (cpu_logical > 1 && cpu_cores == 1)
    
68.    445                        return (smp_topo_1level(CG_SHARE_L1, cpu_logical, cg_flags));
    
69.    446                /*
    
70.    447                 * Only multi-core no HTT.
    
71.    448                 */
    
72.    449                if (cpu_cores > 1 && cpu_logical == 1)
    
73.    450                        return (smp_topo_1level(CG_SHARE_L2, cpu_cores, cg_flags));
    
74.    451                /*
    
75.    452                 * Both HTT and multi-core.
    
76.    453                 */
    
77.    454                return (smp_topo_2level(CG_SHARE_L2, cpu_cores,
    
78.    455                    CG_SHARE_L1, cpu_logical, cg_flags));
    
79.    456        }

复制代码

[函数topo_probe]：

1.    367        /*
   
2.    368         * Both topology discovery code and code that consumes topology
   
3.    369         * information assume top-down uniformity of the topology.
   
4.    370         * That is, all physical packages must be identical and each
   
5.    371         * core in a package must have the same number of threads.
   
6.    372         * Topology information is queried only on BSP, on which this
   
7.    373         * code runs and for which it can query CPUID information.
   
8.    374         * Then topology is extrapolated on all packages using the
   
9.    375         * uniformity assumption.
   
10.    376         */
    
11.    377        static void
    
12.    378        topo_probe(void)
    
13.    379        {
    
14.    380                static int cpu_topo_probed = 0;
    
15.    381       
    
16.    382                if (cpu_topo_probed)
    
17.    383                        return;
    
18.    384       
    
19. /***************************************************************************************************
    
20. * 385：将变量logical_cpus_mask清零。
    
21.    cpuset_t logical_cpus_mask;
    
22.    变量logical_cpus_mask为logical cpu的位图，每个bit位对应系统中的每个logical cpu。
    
23. 
    
24.    386-387：
    
25.    mp_ncpus:系统中cpu的数目，在初始化函数apic_init中被设置为有意义的值。根据intel
    
26.    芯片中对APIC的描述，LOCAL APIC的数目就为系统中cpu的数目，ACPI规范
    
27.    中有一个专门的表来描述系统中的LOCAL APIC，apic_init函数读取这个表，
    
28.    根据其中的数据信息来正确初始化mp_ncpus。根据前提假设，mp_ncpus的值
    
29.    为8.
    
30.    
    
31.    388-389：AMD cpu? 这里忽略。
    
32. 
    
33.    390-403：对应的是intel cpu。
    
34.    cpu_high变量是在内核初始化的最初阶段，在locore.s中，eax寄存器设置为0，执行cpuid
    
35.    指令设置的，cpuid指令用来获取cpu相关的信息。
    
36. 
    
37.    cpu_high变量的具体含义如下：
    
38.    Highest CPUID Source Operand for Intel 64 and IA-32 Processors。
    
39.    具体大家可以参考一下intel 芯片手册中队cupid指令的详细介绍。
    
40. 
    
41. 
    
42.    根据Intel 64 Architecture Processor Topology Enumeration中的描述:
    
43.    The x2APIC extension in Intel 64 architecture defines a 32-bit x2APIC ID,
    
44.    the CPUID instruction in future Intel 64 processors will allow software to
    
45.    enumerate system topology using x2APIC IDs. The extended topology enumeration
    
46.    leaf of CPUID (leaf 11) is the preferred interface for system topology
    
47.    enumeration for future Intel 64 processor.
    
48. 
    
49.    The maximum value of supported CPUID leaf can be determined by setting EAX = 0,
    
50.    execute CPUID and examine the returned value in EAX, i.e. CPUID.0:EAX. If CPUID.0:EAX >= 11
    
51.    
    
52.    可以看出来，只有当cpu_high>= 11时，才会去检查x2APIC extension，即调用函数topo_probe_0xb。
    
53.    这里假设支持x2APIC extension，可以更具体的分析问题。
    
54. 
    
55.    函数用来确定变量cpu_logical和cpu_cores的值。
    
56. 
    
57.    410-412：是单核心单线程cpu?
    
58. 
    
59.    412：将变量cpu_topo_probed设置为1，表示已经调用过函数topo_probe。
    
60. **********************************************************************/
    
61.    385                CPU_ZERO(&logical_cpus_mask);
    
62.    386                if (mp_ncpus <= 1)
    
63.    387                        cpu_cores = cpu_logical = 1;
    
64.    388                else if (cpu_vendor_id == CPU_VENDOR_AMD)
    
65.    389                        topo_probe_amd();
    
66.    390                else if (cpu_vendor_id == CPU_VENDOR_INTEL) {
    
67.    391                        /*
    
68.    392                         * See Intel(R) 64 Architecture Processor
    
69.    393                         * Topology Enumeration article for details.
    
70.    394                         *
    
71.    395                         * Note that 0x1 <= cpu_high < 4 case should be
    
72.    396                         * compatible with topo_probe_0x4() logic when
    
73.    397                         * CPUID.1:EBX[23:16] > 0 (cpu_cores will be 1)
    
74.    398                         * or it should trigger the fallback otherwise.
    
75.    399                         */
    
76.    400                        if (cpu_high >= 0xb)
    
77.    401                                topo_probe_0xb();
    
78.    402                        else if (cpu_high >= 0x1)
    
79.    403                                topo_probe_0x4();
    
80.    404                }
    
81.    405       
    
82.    406                /*
    
83.    407                 * Fallback: assume each logical CPU is in separate
    
84.    408                 * physical package.  That is, no multi-core, no SMT.
    
85.    409                 */
    
86.    410                if (cpu_cores == 0 || cpu_logical == 0)
    
87.    411                        cpu_cores = cpu_logical = 1;
    
88.    412                cpu_topo_probed = 1;
    
89.    413        }

复制代码

[函数topo_probe_0xb]：

1.    319        static void
   
2.    320        topo_probe_0xb(void)
   
3.    321        {
   
4.    322                u_int p[4];
   
5.    323                int bits;
   
6.    324                int cnt;
   
7.    325                int i;
   
8.    326                int logical;
   
9.    327                int type;
   
10.    328                int x;
    
11.    329       
    
12. /********************************************************************************************************
    
13. * 对这个"We only support three levels for now."的解释如下，即以下三个level：
    
14.    SMT_ID: each unique SMT_ID allows software to distinguish different logical processors
    
15.            within a processor core,也就说这一个level可以确定每一个processor core包含的
    
16.            logical processor的数目。
    
17. 
    
18.    Core_ID: each unique Core_ID allows software to distinguish different processor cores
    
19.             within a physical package，也就是说这个一个level可以确定每个物理cpu包含的
    
20.             全部logical cpu的数目。
    
21. 
    
22.    Pkg_ID: each unique Pkg_ID allows software to distinguish different physical packages
    
23.            in a multi-processor system，这一个level可以确定系统中物理cpu的数目。
    
24. 
    
25.    
    
26.    cpuid_count函数完成下面的功能：
    
27.    software can determine whether CPUID leaf 11 exists by setting EAX=11, ECX=0,
    
28.    execute CPUID to examine the non-zero value returned in EBX。
    
29.    
    
30.    在SMP系统中，数组cpu_info用来描述系统中每个cpu相关信息，在初始化函数apic_init中会设置
    
31.    该数组中的元素。
    
32. 
    
33.    在SMP中，boot_cpu_id为BSP的APIC ID。
    
34. 
    
35.    cpuid_count函数以下面的参数执行cpuid指令：
    
36.    0xb->EAX寄存器
    
37.    i->ECX寄存器
    
38.    执行cpuid指令
    
39.    EAX寄存器->p[0]
    
40.    EBX寄存器->p[1]
    
41.    ECX寄存器->p[2]
    
42.    EDX寄存器->p[3]
    
43. 
    
44.    331-361：执行三次for循环，如下：
    
45.       
    
46.    第一次循环---确定cpu_logical变量的值：
    
47.    CPUID.(EAX=11, ECX=0)这样执行cpuid指令，对应的level为0，level type为CPUID_TYPE_SMT：
    
48. 
    
49.    335-338：忽略，没有分析意义。
    
50. 
    
51.    340：bits为一个位移量，
    
52. 
    
53.    341：logical为Number of logical processors at this level type，可以忽略。
    
54. 
    
55.    342：type为level type，此次循环时，type为CPUID_TYPE_SMT。
    
56. 
    
57.    350-356:
    
58.    检查系统中每个cpu的APIC ID，如果x >> bits == boot_cpu_id >> bits为真，就表示cpu x和boot_cpu_id
    
59.    在同一个processor core上，当这段for循环执行完后cnt变量就表示每个processor core上的logical cpu的
    
60.    数目；如果支持超线程等技术，cnt的值为2；如果不支持超线程等技术，cnt的值为1.
    
61.    
    
62.    357-360：
    
63.    此次循环，type为CPUID_TYPE_SMT，将cnt赋值给cpu_logical，根据我们前提，cpu_logical的值为1.
    
64. 
    
65.    
    
66.    第二次循环---确定变量cpu_cores的值：
    
67.    CPUID.(EAX=11, ECX=1)这样执行cpuid指令，对应的level为1，level type为CPUID_TYPE_CORE：
    
68. 
    
69.    335-338：忽略，没有分析意义。
    
70. 
    
71.    340：bits为一个位移量，
    
72. 
    
73.    341：logical为Number of logical processors at this level type，可以忽略。
    
74. 
    
75.    342：type为level type，此次次循环时，type为CPUID_TYPE_CORE。
    
76. 
    
77.    350-356:
    
78.    检查系统中每个cpu的APIC ID，如果x >> bits == boot_cpu_id >> bits为真，就表示cpu x和boot_cpu_id
    
79.    在同一个物理cpu上，当这段for循环执行完后cnt变量就表示每个物理cpu包含的logical cpu数目；对于4核心
    
80.    8线程的cpu，cnt的值为8；对于4核心4线程的cpu，cnt的值为4.
    
81.    
    
82.    
    
83.    357-360：
    
84.    此次循环，type为CPUID_TYPE_CORE，将cnt赋值给cpu_cores，根据我们前提，cpu_cores的值为4.
    
85. 
    
86. 
    
87.    第三次循环-没有分析意义。
    
88. 
    
89.    362-364：确定变量cpu_cores和cpu_logical的最终值。
    
90. 
    
91. *****************************************************************/
    
92.    330                /* We only support three levels for now. */
    
93.    331                for (i = 0; i < 3; i++) {
    
94.    332                        cpuid_count(0x0b, i, p);
    
95.    333       
    
96.    334                        /* Fall back if CPU leaf 11 doesn't really exist. */
    
97.    335                        if (i == 0 && p[1] == 0) {
    
98.    336                                topo_probe_0x4();
    
99.    337                                return;
    
100.    338                        }
     
101.    339       
     
102.    340                        bits = p[0] & 0x1f;
     
103.    341                        logical = p[1] &= 0xffff;
     
104.    342                        type = (p[2] >> 8) & 0xff;
     
105.    343                        if (type == 0 || logical == 0)
     
106.    344                                break;
     
107.    345                        /*
     
108.    346                         * Because of uniformity assumption we examine only
     
109.    347                         * those logical processors that belong to the same
     
110.    348                         * package as BSP.
     
111.    349                         */
     
112.    350                        for (cnt = 0, x = 0; x <= MAX_APIC_ID; x++) {
     
113.    351                                if (!cpu_info[x].cpu_present ||
     
114.    352                                    cpu_info[x].cpu_disabled)
     
115.    353                                        continue;
     
116.    354                                if (x >> bits == boot_cpu_id >> bits)
     
117.    355                                        cnt++;
     
118.    356                        }
     
119.    357                        if (type == CPUID_TYPE_SMT)
     
120.    358                                cpu_logical = cnt;
     
121.    359                        else if (type == CPUID_TYPE_CORE)
     
122.    360                                cpu_cores = cnt;
     
123.    361                }
     
124.    362                if (cpu_logical == 0)
     
125.    363                        cpu_logical = 1;
     
126.    364                cpu_cores /= cpu_logical;
     
127.    365        }

复制代码

[函数smp_topo_1level]：

1. /***************************************************************
   
2. * 参数描述：
   
3.    share：CG_SHARE_L2
   
4.    count：cpu_cores，即每个物理cpu上的核心数目，这里为4.
   
5.    flags：为0.
   
6. 
   
7.    static struct cpu_group group[MAXCPU];
   
8. *******************************/
   
9.    593        struct cpu_group *
   
10.    594        smp_topo_1level(int share, int count, int flags)
    
11.    595        {
    
12.    596                struct cpu_group *child;
    
13.    597                struct cpu_group *top;
    
14.    598                int packages;
    
15.    599                int cpu;
    
16.    600                int i;
    
17.    601       
    
18. /***********************************************************************
    
19. * mp_ncpus:系统中cpu的数目，在初始化函数apic_init中被设置为有意义的值。
    
20. 
    
21.    604：packages为系统中物理cpu的数目。
    
22. *****************************/
    
23.    602                cpu = 0;
    
24.    603                top = &group[0];
    
25.    604                packages = mp_ncpus / count;
    
26.    605                top->cg_child = child = &group[1];
    
27.    606                top->cg_level = CG_SHARE_NONE;
    
28.    607                for (i = 0; i < packages; i++, child++)
    
29.    608                        cpu = smp_topo_addleaf(top, child, share, count, flags, cpu);
    
30.    609                return (top);
    
31.    610        }

复制代码

[函数smp_topo_addleaf]：

1.    561        static int
   
2.    562        smp_topo_addleaf(struct cpu_group *parent, struct cpu_group *child, int share,
   
3.    563            int count, int flags, int start)
   
4.    564        {
   
5.    565                char cpusetbuf[CPUSETBUFSIZ], cpusetbuf2[CPUSETBUFSIZ];
   
6.    566                cpuset_t mask;
   
7.    567                int i;
   
8.    568       
   
9.    569                CPU_ZERO(&mask);
   
10.    570                for (i = 0; i < count; i++, start++)
    
11.    571                        CPU_SET(start, &mask);
    
12.    572                child->cg_parent = parent;
    
13.    573                child->cg_child = NULL;
    
14.    574                child->cg_children = 0;
    
15.    575                child->cg_level = share;
    
16.    576                child->cg_count = count;
    
17.    577                child->cg_flags = flags;
    
18.    578                child->cg_mask = mask;
    
19.    579                parent->cg_children++;
    
20.    580                for (; parent != NULL; parent = parent->cg_parent) {
    
21.    581                        if (CPU_OVERLAP(&parent->cg_mask, &child->cg_mask))
    
22.    582                                panic("Duplicate children in %p.  mask (%s) child (%s)",
    
23.    583                                    parent,
    
24.    584                                    cpusetobj_strprint(cpusetbuf, &parent->cg_mask),
    
25.    585                                    cpusetobj_strprint(cpusetbuf2, &child->cg_mask));
    
26.    586                        CPU_OR(&parent->cg_mask, &child->cg_mask);
    
27.    587                        parent->cg_count += child->cg_count;
    
28.    588                }
    
29.    589       
    
30.    590                return (start);
    
31.    591        }
    

复制代码