update sched and mm

freelancer-leon · freelancer-leon · commit e45c36ad04e9 · 2018-06-19T17:14:37.000+08:00
diff --git a/kernel/mm/mm_pagetable.md b/kernel/mm/mm_pagetable.md
@@ -129,7 +129,7 @@
 * **[翻译后缓冲器（translation lookaside buffer，TLB）](https://en.wikipedia.org/wiki/Translation_lookaside_buffer)**——为了加快从虚拟内存中页面到物理内存中对应地址的搜索，多数体系结构都实现了一个将虚拟地址映射到物理地址的硬件缓存。
   * 当访问一个虚拟地址时，CPU的MMU先检查TLB中是否缓存了该虚拟地址到物理地址的映射，如果在缓存中直接命中，物理地址立刻返回。
   * 否则，通过页表搜索需要的物理地址。
-  * TLB中缓冲的是 **页表条目（PTE）**，而不是物理页。因此TLB命中返回PTE给MMU后，节省了MMU去查询页表的时间，仍然需要通过cache/memory去获取内容。
+  * TLB中缓冲的是映射关系，而不是物理页。因此如果 TLB 命中直接将结果返回给MMU后，节省了MMU去查询页表的时间，仍然需要通过cache/memory去获取内容。
 * **[MMU](https://en.wikipedia.org/wiki/Memory_management_unit)** 是一种负责处理中央处理器（CPU）的内存访问请求的计算机硬件。它的功能包括：
   * 虚拟地址到物理地址的转换（即虚拟内存管理）
   * 内存保护、CPU cache的控制
diff --git a/kernel/sched/sched_cfs-1.md b/kernel/sched/sched_cfs-1.md
@@ -1,6 +1,7 @@
 
-### CFS调度器相关的`sched_latency_ns`、`sched_min_granularity_ns` 和 `sched_wakeup_granularity_ns`
+## CFS调度器相关的`sched_latency_ns`、`sched_min_granularity_ns`和 `sched_wakeup_granularity_ns`参数
 
+### 初始化
 * 与 CFS 调度器工作密切相关的几个参数值在不同机器上看到的值可能会不一样，但是看内核源代码，内核的`.config`，`/etc/sysctl.conf`，`/etc/sysctl.d/*`以及其他能想到会配置`sysctl`的地方却找不到有哪里修改了它们。
 * 这几个变量在内核中的缺省值：
 * kernel/sched/fair.c
@@ -54,6 +55,7 @@ kernel.sched_wakeup_granularity_ns = 4000000
 * 为什么不采用固定值，或者随着 CPU 数目线性增长，而是将`log(ncpus)`作为因子？
 * 简单的说，就是随着 CPU 性能的增多，调度的“有效延迟”肯定会减小，但减小的幅度却不可能是线性的。
 * 可以想象，到后来即使加入更多的 CPU，调度因此而获得的收益会愈不明显，所以也就没有必要再返回更大的 factor 了。
+* kernel/sched/fair.c
 ```c
 /*
  * Increase the granularity value when there are more CPUs,
@@ -110,3 +112,125 @@ start_kernel()
                                      -> update_sysctl()
                                        -> get_update_sysctl_factor()
 ```
+
+### 设置
+
+* 而设置这几个参数则通过回调函数`sched_proc_update_handler()`修改
+```c
+int sched_proc_update_handler(struct ctl_table *table, int write,
+                void __user *buffer, size_t *lenp,
+                loff_t *ppos)
+{
+        int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+        unsigned int factor = get_update_sysctl_factor();
+
+        if (ret || !write)
+                return ret;
+
+        sched_nr_latency = DIV_ROUND_UP(sysctl_sched_latency,
+                                        sysctl_sched_min_granularity);
+
+#define WRT_SYSCTL(name) \
+        (normalized_sysctl_##name = sysctl_##name / (factor))
+        WRT_SYSCTL(sched_min_granularity);
+        WRT_SYSCTL(sched_latency);
+        WRT_SYSCTL(sched_wakeup_granularity);
+#undef WRT_SYSCTL
+
+        return 0;
+}
+#endif
+...__```
+```
+* 注意，全局变量`sched_nr_latency`除了初始化外，唯一被赋值的地方就是这里，公式为：
+  ```c
+  sched_nr_latency = ceil( sysctl_sched_latency / sysctl_sched_min_granularity )
+  ```
+
+### 微调
+* 关于调节`sched_latency_ns`和`sched_min_granularity_ns`会对系统，或者说抢占，造成的影响，主要考察`sched_latency_ns`的计算公式和以下几个函数：
+  ```c
+  check_preempt_tick()
+    -> sched_slice()
+       -> __sched_period()
+  ```
+#### 计算调度周期__sched_period
+* 首先是看计算 **调度周期**（也叫 *目标延迟* 或者 *调度延迟*）的函数`__sched_period()`
+* 该延迟使得 CFS 不必每个 tick 都去检查是否需要调度切换，而是延迟到一定程度再去检查
+* 在调度延迟这个时间片内，`cfs_rq`中的每个进程以求优先级为权重瓜分时间
+```c
+/*
+ * The idea is to set a period in which each task runs once.
+ *
+ * When there are too many tasks (sched_nr_latency) we have to stretch
+ * this period because otherwise the slices get too small.
+ *
+ * p = (nr <= nl) ? l : l*nr/nl
+ */
+static u64 __sched_period(unsigned long nr_running)
+{
+        if (unlikely(nr_running > sched_nr_latency))
+                return nr_running * sysctl_sched_min_granularity;
+        else
+                return sysctl_sched_latency;
+}
+```
+* `nr_running`通常是就绪队列上的进程数，由此可以看到，调度周期同时受`nr_running`,`sysctl_sched_min_granularity`,`sysctl_sched_latency`三者影响，`sched_nr_latency`是根据后二者计算出来的
+* 我们将这两个分支称为 **条件1** 和 **条件2**
+1. **条件1**: `nr_running > sched_nr_latency`：排队的就绪进程较多，每个进程分得的时间按权重比例划分`nr_running * sysctl_sched_min_granularity`
+2. **条件2**:`nr_running > sched_nr_latency`：排队的就绪进程较少，每个进程分得的时间按权重比例划分`sysctl_sched_latency`
+
+```c
+/*
+ * We calculate the wall-time slice from the period by taking a part
+ * proportional to the weight.
+ *
+ * s = p*P[w/rw]
+ */
+static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
+{
+        u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq);
+
+        for_each_sched_entity(se) {
+                struct load_weight *load;
+                struct load_weight lw;
+
+                cfs_rq = cfs_rq_of(se);
+                load = &cfs_rq->load;
+
+                if (unlikely(!se->on_rq)) {
+                        lw = cfs_rq->load;
+
+                        update_load_add(&lw, se->load.weight);
+                        load = &lw;
+                }    
+                slice = __calc_delta(slice, se->load.weight, load);
+        }    
+        return slice;
+}
+...*```
+```
+* `sched_slice()`是按权重比例划分调度周期为时间片的过程
+* 注意，这里的时间片是墙上时间（实际时间），不是虚拟时间
+* `check_preempt_tick()`详见 [周期性调度检查check_preempt_tick](#sched_cfs.md#周期性调度检查check_preempt_tick)
+
+#### `sysctl_sched_latency`不变，只减小`sysctl_sched_min_granularity`
+* 根据公式，`sched_nr_latency`会比较大，因此容易进入 **条件2**
+* 有可能用更长的调度周期`sysctl_sched_latency`，而不是`nr_running * sysctl_sched_min_granularity`
+* 虽然调度最小粒度比较小，但比改动前的理想运行时间会更长
+* 在`check_preempt_tick()`时会因`if (delta_exec > ideal_runtime)` 不易达成变得不易被抢占
+#### `sysctl_sched_min_granularity`不变，只减小`sysctl_sched_latency`
+* 根据公式，`sched_nr_latency`会比较小，因此容易进入 **条件1**
+* 以调度最小粒度换算后进行调度
+* 在`check_preempt_tick()`时，会使检查调度最小粒度的条件不容易通过，因此变得易被抢占
+  ```c
+  if (delta_exec < sysctl_sched_min_granularity)
+      return;
+  ```
+#### 同时减小`sysctl_sched_latency`和`sysctl_sched_min_granularity`
+* 根据公式，`sched_nr_latency`不变，因此容易进入 **条件1** 和 **条件2** 的机会和调整之前想当
+* 然而，不论是进入哪个条件，调度周期都变短了，见`__sched_period()`
+* 因此，理想运行时间也变短了，见`sched_slice()`
+* 在`check_preempt_tick()`时，
+  * `if (delta_exec > ideal_runtime)` 容易达成，易被抢占
+  * `if (delta_exec < sysctl_sched_min_granularity)` 不易达成，易被抢占
diff --git a/kernel/sched/sched_cfs.md b/kernel/sched/sched_cfs.md
@@ -534,9 +534,10 @@ wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
     return 0;
 }
 ```
-* 当`wakeup_preempt_entity()`返回**1**时，`check_preempt_wakeup()`会设置`TIF_NEED_RESCHED`标志允许新进程抢占当前进程。
-* 注释中的s1,s2,s3是新进程/调度实体的三种情况，横座标轴为`vruntime`。
+* 当`wakeup_preempt_entity()`返回 **1** 时，`check_preempt_wakeup()`会设置`TIF_NEED_RESCHED`标志允许新进程抢占当前进程。
+* 注释中的 s1，s2，s3 是新进程/调度实体的三种情况，横座标轴为`vruntime`。仅当 s3 情况，`se-vruntime`比`curr->vruntime`的值小且超过`gran`，可以抢占。
 * 为了让进程切换不会过于频繁，这里不会因为新进程的`vruntime`较小就立即切换，而是“缓冲”一下，与`wakeup_gran()`计算结果进行比较后再决定。
+* 注意参数的顺序，该函数判断`se`能否抢占`curr`
 
 ### 唤醒时粒度的计算wakeup_gran
 * `wakeup_gran()`函数用于计算根据`sysctl_sched_wakeup_granularity`和**新进程的权重**转换得到的虚拟时间。
@@ -1177,8 +1178,8 @@ pick_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *curr)
     /*
      * Prefer last buddy, try to return the CPU to a preempted task.
      */
-    /*尝试把CPU还给被抢占的进程，条件是，last进程的vruntime和left进程的vruntime相差不大
-      （具体可以回去看wakeup_preempt_entity()的实现）。这是为了提高cache的利用。
+    /*尝试把CPU还给被抢占的进程，条件是，last 进程的 vruntime 和 left 进程的 vruntime
+		  相差不大（具体可以回去看wakeup_preempt_entity()的实现）。这是为了提高cache的利用。
       如果last进程的vruntime比left进程的vruntime大很多，说明left进程已经积累的较大的不
       公平，需要及时被调度。
      */
@@ -1199,7 +1200,10 @@ pick_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *curr)
 ```
 * `cfs_rq->rb_leftmost`会在`__enqueue_entity()`或者`__dequeue_entity()`操作时顺带缓存起来，再用到的时候就无需重新搜索红黑树了。
 * `cfs_rq->skip`通常会在`yield_task_fair()`的时候被设置，表明该实体会失去一次被调度的机会。
-* 在调用`wakeup_preempt_entity()`与`cfs_rq->next`和`cfs_rq->last`比较的时候传的是`left`，以及为什么这几个检查的顺序要这么排列，关系到次序问题，见该函数的注释。
+* 在调用`wakeup_preempt_entity()`与`cfs_rq->next`和`cfs_rq->last`比较时用的是`left`
+	* `left`记录的是当前红黑树上和当前进程中`vruntime`最小的调度实体
+	* 该调度实体会按照注释所说的顺序分别与`skip`，`last`，`next`实体的`vruntime`进行比较
+	* 最后一个给`se`赋值的被选中，因此实现时的顺序与列举的顺序相反
 
 ### 标记选出的进程set_next_entity
 * 进程选出来后还需要有一些与CFS运行队列相关的后续工作，由`set_next_entity()`完成
diff --git a/kernel/sched/sched_lb.md b/kernel/sched/sched_lb.md
@@ -0,0 +1,92 @@
+```c
+start_kernel()
+  -> rest_init()
+       -> kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
+
+kernel_init()
+  -> kernel_init_freeable()
+     -> smp_init()
+        -> idle_threads_init()
+     -> sched_init_smp()
+        -> sched_init_numa()
+        -> init_sched_domains(cpu_active_mask)
+           -> alloc_sched_domains(ndoms_cur = 1)
+           -> build_sched_domains(doms_cur[0], NULL)
+              -> __visit_domain_allocation_hell()
+                 -> __sdt_alloc(cpu_map)
+           -> register_sched_domain_sysctl()
+  -> run_init_process()
+```
+
+* kernel/sched/core.c
+```c
+struct sd_data {
+        struct sched_domain **__percpu sd;
+        struct sched_domain_shared **__percpu sds;
+        struct sched_group **__percpu sg;
+        struct sched_group_capacity **__percpu sgc;
+};
+
+struct sched_domain_topology_level {
+        sched_domain_init_f init;
+        sched_domain_mask_f mask;
+        int                 flags;
+        int                 numa_level;
+        struct sd_data      data;
+};
+...
+/*
+ * Topology list, bottom-up.
+ */
+static struct sched_domain_topology_level default_topology[] = {
+#ifdef CONFIG_SCHED_SMT
+        { sd_init_SIBLING, cpu_smt_mask, },
+#endif
+#ifdef CONFIG_SCHED_MC
+        { sd_init_MC, cpu_coregroup_mask, },
+#endif
+#ifdef CONFIG_SCHED_BOOK
+        { sd_init_BOOK, cpu_book_mask, },
+#endif
+        { sd_init_CPU, cpu_cpu_mask, },
+        { NULL, },
+};
+
+static struct sched_domain_topology_level *sched_domain_topology = default_topology;
+
+#define for_each_sd_topology(tl)                        \
+        for (tl = sched_domain_topology; tl->mask; tl++)
+...**```
+```
+* 每个级别的调度域和调度组会在`__sdt_alloc()`用`kzalloc_node()`分配出来
+* `register_sched_domain_sysctl()` 建立如下 `sysctl` 控制项
+```
+proc/sys/kernel/sched_domain/
+├── cpu0
+│   ├── domain0
+│   │   ├── busy_factor
+│   │   ├── busy_idx
+│   │   ├── cache_nice_tries
+│   │   ├── flags
+│   │   ├── forkexec_idx
+│   │   ├── idle_idx
+│   │   ├── imbalance_pct
+│   │   ├── max_interval
+│   │   ├── min_interval
+│   │   ├── name
+│   │   ├── newidle_idx
+│   │   └── wake_idx
+│   └── domain1
+├── cpu1
+│   ├── domain0
+│   └── domain1
+├── cpu2
+│   ├── domain0
+│   └── domain1
+├── cpu3
+│   ├── domain0
+│   └── domain1
+└── cpu4
+    ├── domain0
+    └── domain1
+```
