linux调度器源码分析 - 初始化(二)

/* 代码地址： linux/init/Main.c */
asmlinkage __visible void __init start_kernel(void)

  1 /* 代码路径： 内核源代码目录/kernel/sched/Core.c */
  2 
  3 /* 执行到此时内核只有一个进程init_task，current就为init_task。之后的init进程在初始化到最后的rest_init中启动 */
  4 void __init sched_init(void)
  5 {
  6     int i, j;
  7     unsigned long alloc_size = 0, ptr;
  8 
  9     /* 计算所需要分配的数据结构空间 */
 10 #ifdef CONFIG_FAIR_GROUP_SCHED    
 11     alloc_size += 2 * nr_cpu_ids * sizeof(void **);
 12 #endif
 13 
 14 #ifdef CONFIG_RT_GROUP_SCHED
 15     alloc_size += 2 * nr_cpu_ids * sizeof(void **);
 16 #endif
 17 #ifdef CONFIG_CPUMASK_OFFSTACK
 18     alloc_size += num_possible_cpus() * cpumask_size();
 19 #endif
 20     if (alloc_size) {
 21         /* 分配内存 */
 22         ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);
 23 
 24 #ifdef CONFIG_FAIR_GROUP_SCHED
 25         /* 设置 root_task_group 每个CPU上的调度实体指针se */
 26         root_task_group.se = (struct sched_entity **)ptr;
 27         ptr += nr_cpu_ids * sizeof(void **);
 28 
 29         /* 设置 root_task_group 每个CPU上的CFS运行队列指针cfs_rq */
 30         root_task_group.cfs_rq = (struct cfs_rq **)ptr;
 31         ptr += nr_cpu_ids * sizeof(void **);
 32 
 33 #endif /* CONFIG_FAIR_GROUP_SCHED */
 34 #ifdef CONFIG_RT_GROUP_SCHED
 35         /* 设置 root_task_group 每个CPU上的实时调度实体指针se */
 36         root_task_group.rt_se = (struct sched_rt_entity **)ptr;
 37         ptr += nr_cpu_ids * sizeof(void **);
 38 
 39         /* 设置 root_task_group 每个CPU上的实时运行队列指针rt_rq */
 40         root_task_group.rt_rq = (struct rt_rq **)ptr;
 41         ptr += nr_cpu_ids * sizeof(void **);
 42 
 43 #endif /* CONFIG_RT_GROUP_SCHED */
 44 #ifdef CONFIG_CPUMASK_OFFSTACK
 45         for_each_possible_cpu(i) {
 46             per_cpu(load_balance_mask, i) = (void *)ptr;
 47             ptr += cpumask_size();
 48         }
 49 #endif /* CONFIG_CPUMASK_OFFSTACK */
 50     }
 51     /* 初始化实时进程的带宽限制，用于设置实时进程在CPU中所占用比的 */
 52     init_rt_bandwidth(&def_rt_bandwidth,
 53             global_rt_period(), global_rt_runtime());
 54     init_dl_bandwidth(&def_dl_bandwidth,
 55             global_rt_period(), global_rt_runtime());
 56 
 57 #ifdef CONFIG_SMP
 58     /* 初始化默认的调度域，调度域包含一个或多个CPU，负载均衡是在调度域内执行的，相互之间隔离 */
 59     init_defrootdomain();
 60 #endif
 61 
 62 #ifdef CONFIG_RT_GROUP_SCHED
 63     /* 初始化实时进程的带宽限制，用于设置实时进程在CPU中所占用比的 */
 64     init_rt_bandwidth(&root_task_group.rt_bandwidth,
 65             global_rt_period(), global_rt_runtime());
 66 #endif /* CONFIG_RT_GROUP_SCHED */
 67 
 68 #ifdef CONFIG_CGROUP_SCHED
 69     /* 将分配好空间的 root_task_group 加入 task_groups 链表 */
 70     list_add(&root_task_group.list, &task_groups);
 71     INIT_LIST_HEAD(&root_task_group.children);
 72     INIT_LIST_HEAD(&root_task_group.siblings);
 73     /* 自动分组初始化，每个tty(控制台)动态的创建进程组，这样就可以降低高负载情况下的桌面延迟 */
 74     autogroup_init(&init_task);
 75 
 76 #endif /* CONFIG_CGROUP_SCHED */
 77     /* 遍历设置每一个CPU */
 78     for_each_possible_cpu(i) {
 79         struct rq *rq;
 80         /* 获取CPUi的rq队列 */
 81         rq = cpu_rq(i);
 82         /* 初始化rq队列的自旋锁 */
 83         raw_spin_lock_init(&rq->lock);
 84         /* CPU运行队列中调度实体(sched_entity)数量为0 */
 85         rq->nr_running = 0;
 86         /* CPU负载 */
 87         rq->calc_load_active = 0;
 88         /* 负载下次更新时间 */
 89         rq->calc_load_update = jiffies + LOAD_FREQ;
 90         /* 初始化CFS运行队列 */
 91         init_cfs_rq(&rq->cfs);
 92         /* 初始化实时进程运行队列 */
 93         init_rt_rq(&rq->rt, rq);
 94         init_dl_rq(&rq->dl, rq);
 95 #ifdef CONFIG_FAIR_GROUP_SCHED
 96         root_task_group.shares = ROOT_TASK_GROUP_LOAD;
 97         INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
 98         /*
 99          * How much cpu bandwidth does root_task_group get?
100          *
101          * In case of task-groups formed thr' the cgroup filesystem, it
102          * gets 100% of the cpu resources in the system. This overall
103          * system cpu resource is divided among the tasks of
104          * root_task_group and its child task-groups in a fair manner,
105          * based on each entity's (task or task-group's) weight
106          * (se->load.weight).
107          *
108          * In other words, if root_task_group has 10 tasks of weight
109          * 1024) and two child groups A0 and A1 (of weight 1024 each),
110          * then A0's share of the cpu resource is:
111          *
112          *    A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%
113          *
114          * We achieve this by letting root_task_group's tasks sit
115          * directly in rq->cfs (i.e root_task_group->se[] = NULL).
116          */
117         /* 初始化CFS的带宽限制，用于设置普通进程在CPU中所占用比的 */
118         init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
119         init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);
120 #endif /* CONFIG_FAIR_GROUP_SCHED */
121 
122         rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
123 #ifdef CONFIG_RT_GROUP_SCHED
124         init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL);
125 #endif
126         /* 初始化该队列所保存的每个CPU的负载情况 */
127         for (j = 0; j < CPU_LOAD_IDX_MAX; j++)
128             rq->cpu_load[j] = 0;
129         /* 该队列最后一次更新cpu_load的时间值为当前 */
130         rq->last_load_update_tick = jiffies;
131 
132 #ifdef CONFIG_SMP
133         /* 这些参数都是负载均衡使用的 */
134         rq->sd = NULL;
135         rq->rd = NULL;
136         rq->cpu_capacity = SCHED_CAPACITY_SCALE;
137         rq->post_schedule = 0;
138         rq->active_balance = 0;
139         rq->next_balance = jiffies;
140         rq->push_cpu = 0;
141         rq->cpu = i;
142         rq->online = 0;
143         rq->idle_stamp = 0;
144         rq->avg_idle = 2*sysctl_sched_migration_cost;
145         rq->max_idle_balance_cost = sysctl_sched_migration_cost;
146 
147         INIT_LIST_HEAD(&rq->cfs_tasks);
148         /* 将CPU运行队列加入到默认调度域中 */
149         rq_attach_root(rq, &def_root_domain);
150 #ifdef CONFIG_NO_HZ_COMMON
151         /* 动态时钟使用的标志位，初始时动态时钟是不使用的 */
152         rq->nohz_flags = 0;
153 #endif
154 #ifdef CONFIG_NO_HZ_FULL
155         /* 也是动态时钟才使用的标志位，用于保存上次调度tick发生时间 */
156         rq->last_sched_tick = 0;
157 #endif
158 #endif
159         /* 初始化运行队列定时器，这个是高精度定时器，但是只是初始化，这时并没有使用 */
160         init_rq_hrtick(rq);
161         atomic_set(&rq->nr_iowait, 0);
162     }
163     /* 设置 init_task 进程的权重 */
164     set_load_weight(&init_task);
165 
166 #ifdef CONFIG_PREEMPT_NOTIFIERS
167     /* 初始化通知链 */
168     INIT_HLIST_HEAD(&init_task.preempt_notifiers);
169 #endif
170 
171     /*
172      * The boot idle thread does lazy MMU switching as well:
173      */
174     atomic_inc(&init_mm.mm_count);
175     enter_lazy_tlb(&init_mm, current);
176 
177     /*
178      * Make us the idle thread. Technically, schedule() should not be
179      * called from this thread, however somewhere below it might be,
180      * but because we are the idle thread, we just pick up running again
181      * when this runqueue becomes "idle".
182      */
183     /* 将当前进程初始化为idle进程，idle进程用于当CPU没有进程可运行时运行，空转 */
184     init_idle(current, smp_processor_id());
185     /* 下次负载更新时间(是一个相对时间) */
186     calc_load_update = jiffies + LOAD_FREQ;
187 
188     /*
189      * During early bootup we pretend to be a normal task:
190      */
191     /* 设置idle进程使用CFS调度策略 */
192     current->sched_class = &fair_sched_class;
193 
194 #ifdef CONFIG_SMP
195     zalloc_cpumask_var(&sched_domains_tmpmask, GFP_NOWAIT);
196     /* May be allocated at isolcpus cmdline parse time */
197     if (cpu_isolated_map == NULL)
198         zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
199     idle_thread_set_boot_cpu();
200     set_cpu_rq_start_time();
201 #endif
202     init_sched_fair_class();
203     /* 这里只是标记调度器开始运行了，但是此时系统只有一个init_task(idle)进程，并且定时器都还没启动。并不会调度到其他进程，也没有其他进程可供调度 */
204     scheduler_running = 1;
205 }