AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

linux调度器源码分析 - 新进程加入(三)

2015-03-24 1085
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本文为原创，转载请注明：http://blog.chinaunix.net/uid/26772321.html  引言 　　之前的文章已经介绍了调度器已经初始化完成，现在只需要加入一个周期定时器tick驱动它进行周期调度即可，而加入定时器tick在下一篇文章进行简单说明(主要这部分涉及调度器比较少，更多的是时钟、定时器相关知识)。
本文为原创，转载请注明： http://blog.chinaunix.net/uid/26772321.html  

引言

　　之前的文章已经介绍了调度器已经初始化完成，现在只需要加入一个周期定时器tick驱动它进行周期调度即可，而加入定时器tick在下一篇文章进行简单说明(主要这部分涉及调度器比较少，更多的是时钟、定时器相关知识)。这篇文章主要说明系统如何把一个进程加入到队列中。

 

加入时机

　　之前的文章也有提到过，只有处于TASK_RUNNING状态下的进程才能够加入到调度器，其他状态都不行，也就说明了，当一个进程处于睡眠、挂起状态的时候是不存在于调度器中的，而进程加入调度器的时机如下：

  • 当进程创建完成时，进程刚创建完成时，即使它运行起来立即调用sleep()进程睡眠，它也必定先会加入到调度器，因为实际上它加入调度器后自己还需要进行一定的初始化和操作，才会调用到我们的“立即”sleep()。
  • 当进程被唤醒时，也使用sleep的例子说明，我们平常写程序使用的sleep()函数实现原理就是通过系统调用将进程状态改为TASK_INTERRUPTIBLE，然后移出运行队列，并且启动一个定时器，在定时器到期后唤醒进程，再重新放入运行队列。

sched_fork

　　在我的博文关于linux系统如何实现fork的研究(二)中专门描述了copy_process()这个创建函数，而里面有一个函数专门用于进程调度的初始化，就是sched_fork()，其代码如下

  1. int sched_fork(unsigned long clone_flags, struct task_struct *p)
  2. {
  3.     unsigned long flags;
  4.     /* 获取当前CPU，并且禁止抢占 */
  5.     int cpu = get_cpu();
  6.     
  7.     /* 初始化跟调度相关的值，比如调度实体，运行时间等 */
  8.     __sched_fork(clone_flags, p);
  9.     /*
  10.      * 标记为运行状态，表明此进程正在运行或准备好运行，实际上没有真正在CPU上运行，这里只是导致了外部信号和事件不能够唤醒此进程，之后将它插入到运行队列中
  11.      */
  12.     p->state = TASK_RUNNING;

  14.     /*
  15.      * 根据父进程的运行优先级设置设置进程的优先级
  16.      */
  17.     p->prio = current->normal_prio;

  19.     /*
  20.      * 更新该进程优先级
  21.      */
  22.     /* 如果需要重新设置优先级 */
  23.     if (unlikely(p->sched_reset_on_fork)) {
  24.         /* 如果是dl调度或者实时调度 */
  25.         if (task_has_dl_policy(p) || task_has_rt_policy(p)) {
  26.             /* 调度策略为SCHED_NORMAL，这个选项将使用CFS调度 */
  27.             p->policy = SCHED_NORMAL;
  28.             /* 根据默认nice值设置静态优先级 */
  29.             p->static_prio = NICE_TO_PRIO(0);
  30.             /* 实时优先级为0 */
  31.             p->rt_priority = 0;
  32.         } else if (PRIO_TO_NICE(p->static_prio) 0)
  33.             /* 根据默认nice值设置静态优先级 */
  34.             p->static_prio = NICE_TO_PRIO(0);

  36.         /* p->prio = p->normal_prio = p->static_prio */
  37.         p->prio = p->normal_prio = __normal_prio(p);
  38.         /* 设置进程权重 */
  39.         set_load_weight(p);

  41.          /* sched_reset_on_fork成员在之后已经不需要使用了，直接设为0 */
  42.         p->sched_reset_on_fork = 0;
  43.     }

  45.     if (dl_prio(p->prio)) {
  46.         /* 使能抢占 */
  47.         put_cpu();
  48.         /* 返回错误 */
  49.         return -EAGAIN;
  50.     } else if (rt_prio(p->prio)) {
  51.         /* 根据优先级判断，如果是实时进程，设置其调度类为rt_sched_class */
  52.         p->sched_class = &rt_sched_class;
  53.     } else {
  54.         /* 如果是普通进程，设置其调度类为fair_sched_class */
  55.         p->sched_class = &fair_sched_class;
  56.     }
  57.     /* 调用调用类的task_fork函数 */
  58.     if (p->sched_class->task_fork)
  59.         p->sched_class->task_fork(p);

  61.     /*
  62.      * The child is not yet in the pid-hash so no cgroup attach races,
  63.      * and the cgroup is pinned to this child due to cgroup_fork()
  64.      * is ran before sched_fork().
  65.      *
  66.      * Silence PROVE_RCU.
  67.      */
  68.     raw_spin_lock_irqsave(&p->pi_lock, flags);
  69.     /* 设置新进程的CPU为当前CPU */
  70.     set_task_cpu(p, cpu);
  71.     raw_spin_unlock_irqrestore(&p->pi_lock, flags);

  73. #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
  74.     if (likely(sched_info_on()))
  75.         memset(&p->sched_info, 0, sizeof(p->sched_info));
  76. #endif
  77. #if defined(CONFIG_SMP)
  78.     p->on_cpu = 0;
  79. #endif
  80.     /* task_thread_info(p)->preempt_count = PREEMPT_DISABLED; */
  81.     /* 初始化该进程为内核禁止抢占 */
  82.     init_task_preempt_count(p);
  83. #ifdef CONFIG_SMP
  84.     plist_node_init(&p->pushable_tasks, MAX_PRIO);
  85.     RB_CLEAR_NODE(&p->pushable_dl_tasks);
  86. #endif
  87.     /* 使能抢占 */
  88.     put_cpu();
  89.     return 0;
  90. }

 　　在sched_fork()函数中，主要工作如下：

  • 获取当前CPU号
  • 禁止内核抢占(这里基本就是关闭了抢占，因为执行到这里已经是内核态，又禁止了被抢占)
  • 初始化进程p的一些变量(实时进程和普通进程通用的那些变量)
  • 设置进程p的状态为TASK_RUNNING(这一步很关键，因为只有处于TASK_RUNNING状态下的进程才会被调度器放入队列中)
  • 根据父进程和clone_flags参数设置进程p的优先级和权重。
  • 根据进程p的优先级设置其调度类(实时进程优先级:0~99　　普通进程优先级:100~139)
  • 根据调度类进行进程p类型相关的初始化(这里就实现了实时进程和普通进程独有的变量进行初始化)
  • 设置进程p的当前CPU为此CPU。
  • 初始化进程p禁止内核抢占(因为当CPU执行到进程p时，进程p还需要进行一些初始化)
  • 使能内核抢占

　　可以看出sched_fork()进行的初始化也比较简单，需要注意的是不同类型的进程会使用不同的调度类，并且也会调用调度类中的初始化函数。在实时进程的调度类中是没有特定的task_fork()函数的，而普通进程使用cfs策略时会调用到task_fork_fair()函数，我们具体看看实现：

  1. static void task_fork_fair(struct task_struct *p)
  2. {
  3.     struct cfs_rq *cfs_rq;
  4.     
  5.     /* 进程p的调度实体se */
  6.     struct sched_entity *se = &p->se, *curr;
  7.     
  8.     /* 获取当前CPU */
  9.     int this_cpu = smp_processor_id();
  10.     
  11.     /* 获取此CPU的运行队列 */
  12.     struct rq *rq = this_rq();
  13.     unsigned long flags;
  14.     
  15.     /* 上锁并保存中断记录 */
  16.     raw_spin_lock_irqsave(&rq->lock, flags);
  17.     
  18.     /* 更新rq运行时间 */
  19.     update_rq_clock(rq);
  20.     
  21.     /* cfs_rq = current->se.cfs_rq; */
  22.     cfs_rq = task_cfs_rq(current);
  23.     
  24.     /* 设置当前进程所在队列为父进程所在队列 */
  25.     curr = cfs_rq->curr;

  27.     /*
  28.      * Not only the cpu but also the task_group of the parent might have
  29.      * been changed after parent->se.parent,cfs_rq were copied to
  30.      * child->se.parent,cfs_rq. So call __set_task_cpu() to make those
  31.      * of child point to valid ones.
  32.      */
  33.     rcu_read_lock();
  34.     /* 设置此进程所属CPU */
  35.     __set_task_cpu(p, this_cpu);
  36.     rcu_read_unlock();

  38.     /* 更新当前进程运行时间 */
  39.     update_curr(cfs_rq);

  41.     if (curr)
  42.         /* 将父进程的虚拟运行时间赋给了新进程的虚拟运行时间 */
  43.         se->vruntime = curr->vruntime;
  44.     /* 调整了se的虚拟运行时间 */
  45.     place_entity(cfs_rq, se, 1);

  47.     if (sysctl_sched_child_runs_first && curr && entity_before(curr, se)) {
  48.         /*
  49.          * Upon rescheduling, sched_class::put_prev_task() will place
  50.          * 'current' within the tree based on its new key value.
  51.          */
  52.         swap(curr->vruntime, se->vruntime);
  53.         resched_curr(rq);
  54.     }

  56.     /* 保证了进程p的vruntime是运行队列中最小的(这里占时不确定是不是这个用法，不过确实是最小的了) */
  57.     se->vruntime -= cfs_rq->min_vruntime;
  58.     
  59.     /* 解锁，还原中断记录 */
  60.     raw_spin_unlock_irqrestore(&rq->lock, flags);
  61. }

　　在task_fork_fair()函数中主要就是设置进程p的虚拟运行时间和所处的cfs队列，值得我们注意的是 cfs_rq = task_cfs_rq(current); 这一行，在注释中已经表明task_cfs_rq(current)返回的是current的se.cfs_rq，注意se.cfs_rq保存的并不是根cfs队列，而是所处的cfs_rq，也就是如果父进程处于一个进程组的cfs_rq中，新创建的进程也会处于这个进程组的cfs_rq中。

 

wake_up_new_task()

　　到这里新进程关于调度的初始化已经完成，但是还没有被调度器加入到队列中，其是在do_fork()中的wake_up_new_task(p)；中加入到队列中的，我们具体看看wake_up_new_task()的实现：


  1. void wake_up_new_task(struct task_struct *p)
  2. {
  3.     unsigned long flags;
  4.     struct rq *rq;

  6.     raw_spin_lock_irqsave(&p->pi_lock, flags);
  7. #ifdef CONFIG_SMP
  8.     /*
  9.      * Fork balancing, do it here and not earlier because:
  10.      * - cpus_allowed can change in the fork path
  11.      * - any previously selected cpu might disappear through hotplug
  12.      */
  13.      /* 为进程选择一个合适的CPU */
  14.     set_task_cpu(p, select_task_rq(p, task_cpu(p), SD_BALANCE_FORK, 0));
  15. #endif

  17.     /* Initialize new task's runnable average */
  18.     /* 这里是跟多核负载均衡有关 */
  19.     init_task_runnable_average(p);
  20.     /* 上锁 */
  21.     rq = __task_rq_lock(p);
  22.     /* 将进程加入到CPU的运行队列 */
  23.     activate_task(rq, p, 0);
  24.     /* 标记进程p处于队列中 */
  25.     p->on_rq = TASK_ON_RQ_QUEUED;
  26.     /* 跟调试有关 */
  27.     trace_sched_wakeup_new(p, true);
  28.     /* 检查是否需要切换当前进程 */
  29.     check_preempt_curr(rq, p, WF_FORK);
  30. #ifdef CONFIG_SMP
  31.     if (p->sched_class->task_woken)
  32.         p->sched_class->task_woken(rq, p);
  33. #endif
  34.     task_rq_unlock(rq, p, &flags);
  35. }
　　在wake_up_new_task()函数中，将进程加入到运行队列的函数为activate_task(),而activate_task()函数最后会调用到新进程调度类中的enqueue_task指针所指函数，这里我们具体看一下cfs调度类的enqueue_task指针所指函数enqueue_task_fair()：
  1. static void
  2. enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
  3. {
  4.     struct cfs_rq *cfs_rq;
  5.     struct sched_entity *se = &p->se;

  7.     /* 这里是一个迭代，我们知道，进程有可能是处于一个进程组中的，所以当这个处于进程组中的进程加入到该进程组的队列中时，要对此队列向上迭代 */
  8.     for_each_sched_entity(se) {
  9.         if (se->on_rq)
  10.             break;
  11.         /* 如果不是CONFIG_FAIR_GROUP_SCHED，获取其所在CPU的rq运行队列的cfs_rq运行队列
  12.          * 如果是CONFIG_FAIR_GROUP_SCHED，获取其所在的cfs_rq运行队列
  13.          */
  14.         cfs_rq = cfs_rq_of(se);
  15.         /* 加入到队列中 */
  16.         enqueue_entity(cfs_rq, se, flags);

  18.         /*
  19.          * end evaluation on encountering a throttled cfs_rq
  20.          *
  21.          * note: in the case of encountering a throttled cfs_rq we will
  22.          * post the final h_nr_running increment below.
  23.         */
  24.         if (cfs_rq_throttled(cfs_rq))
  25.             break;
  26.         cfs_rq->h_nr_running++;

  28.         flags = ENQUEUE_WAKEUP;
  29.     }

  31.     /* 只有se不处于队列中或者cfs_rq_throttled(cfs_rq)返回真才会运行这个循环 */
  32.     for_each_sched_entity(se) {
  33.         cfs_rq = cfs_rq_of(se);
  34.         cfs_rq->h_nr_running++;

  36.         if (cfs_rq_throttled(cfs_rq))
  37.             break;

  39.         update_cfs_shares(cfs_rq);
  40.         update_entity_load_avg(se, 1);
  41.     }

  43.     if (!se) {
  44.         update_rq_runnable_avg(rq, rq->nr_running);
  45.         /* 当前CPU运行队列活动进程数 + 1 */
  46.         add_nr_running(rq, 1);
  47.     }
  48.     /* 设置下次调度中断发生时间 */
  49.     hrtick_update(rq);
  50. }
　　在enqueue_task_fair()函数中又使用了enqueue_entity()函数进行操作，如下：
  1. static void
  2. enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
  3. {
  4.     /*
  5.      * Update the normalized vruntime before updating min_vruntime
  6.      * through calling update_curr().
  7.      */
  8.     if (!(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_WAKING))
  9.         se->vruntime += cfs_rq->min_vruntime;

  11.     /*
  12.      * Update run-time statistics of the 'current'.
  13.      */
  14.     /* 更新当前进程运行时间和虚拟运行时间 */
  15.     update_curr(cfs_rq);
  16.     enqueue_entity_load_avg(cfs_rq, se, flags & ENQUEUE_WAKEUP);
  17.     /* 更新cfs_rq队列总权重(就是在原有基础上加上se的权重) */
  18.     account_entity_enqueue(cfs_rq, se);
  19.     update_cfs_shares(cfs_rq);

  21.     /* 新建的进程flags为0，不会执行这里 */
  22.     if (flags & ENQUEUE_WAKEUP) {
  23.         place_entity(cfs_rq, se, 0);
  24.         enqueue_sleeper(cfs_rq, se);
  25.     }

  27.     update_stats_enqueue(cfs_rq, se);
  28.     check_spread(cfs_rq, se);
  29.     
  30.     /* 将se插入到运行队列cfs_rq的红黑树中 */
  31.     if (se != cfs_rq->curr)
  32.         __enqueue_entity(cfs_rq, se);
  33.     /* 将se的on_rq标记为1 */
  34.     se->on_rq = 1;

  36.     /* 如果cfs_rq的队列中只有一个进程，这里做处理 */
  37.     if (cfs_rq->nr_running == 1) {
  38.         list_add_leaf_cfs_rq(cfs_rq);
  39.         check_enqueue_throttle(cfs_rq);
  40.     }
  41. }

 

总结

　　需要注意的几点：

  • 新创建的进程先会进行调度相关的结构体和变量初始化，其中会根据不同的类型进行不同的调度类操作，此时并没有加入到队列中。
  • 当新进程创建完毕后，它的父进程会将其运行状态置为TASK_RUNNING，并加入到运行队列中。
  • 加入运行队列时系统会根据CPU的负载情况放入不同的CPU队列中。






文章标签：
调度
Linux
关键词：
Linux调度器
Linux进程
进程调度器
Linux源码分析
源码分析进程
club111
目录
相关文章
丰宝宝
|
3天前
|
算法 Linux 调度
深入理解Linux内核调度器：从基础到优化####
本文旨在通过剖析Linux操作系统的心脏——内核调度器，为读者揭开其高效管理CPU资源的神秘面纱。不同于传统的摘要概述，本文将直接以一段精简代码片段作为引子，展示一个简化版的任务调度逻辑，随后逐步深入，详细探讨Linux内核调度器的工作原理、关键数据结构、调度算法演变以及性能调优策略，旨在为开发者与系统管理员提供一份实用的技术指南。 ####
丰宝宝
19 4
萝卜带泥
|
7天前
|
缓存 算法 Linux
深入理解Linux内核调度器：公平性与性能的平衡####
真知灼见 本文将带你深入了解Linux操作系统的核心组件之一——完全公平调度器（CFS），通过剖析其设计原理、工作机制以及在实际系统中的应用效果，揭示它是如何在众多进程间实现资源分配的公平性与高效性的。不同于传统的摘要概述，本文旨在通过直观且富有洞察力的视角，让读者仿佛亲身体验到CFS在复杂系统环境中游刃有余地进行任务调度的过程。 ####
萝卜带泥
27 6
石小浪♪
|
1月前
|
资源调度 Linux 调度
Linux c/c++之进程基础
这篇文章主要介绍了Linux下C/C++进程的基本概念、组成、模式、运行和状态，以及如何使用系统调用创建和管理进程。
石小浪♪
34 0
Ly001122
|
13天前
|
缓存 监控 Linux
linux进程管理万字详解！！！
本文档介绍了Linux系统中进程管理、系统负载监控、内存监控和磁盘监控的基本概念和常用命令。主要内容包括： 1. **进程管理**： - **进程介绍**：程序与进程的关系、进程的生命周期、查看进程号和父进程号的方法。 - **进程监控命令**：`ps`、`pstree`、`pidof`、`top`、`htop`、`lsof`等命令的使用方法和案例。 - **进程管理命令**：控制信号、`kill`、`pkill`、`killall`、前台和后台运行、`screen`、`nohup`等命令的使用方法和案例。
Ly001122
43 4
linux进程管理万字详解！！！
Echo_Wish
|
4天前
|
存储 运维 监控
深入Linux基础：文件系统与进程管理详解
深入Linux基础：文件系统与进程管理详解
Echo_Wish
39 8
131王
|
4天前
|
缓存 负载均衡 Linux
深入理解Linux内核调度器
本文探讨了Linux操作系统核心组件之一——内核调度器的工作原理和设计哲学。不同于常规的技术文章，本摘要旨在提供一种全新的视角来审视Linux内核的调度机制，通过分析其对系统性能的影响以及在多核处理器环境下的表现，揭示调度器如何平衡公平性和效率。文章进一步讨论了完全公平调度器（CFS）的设计细节，包括它如何处理不同优先级的任务、如何进行负载均衡以及它是如何适应现代多核架构的挑战。此外，本文还简要概述了Linux调度器的未来发展方向，包括对实时任务支持的改进和对异构计算环境的适应性。
131王
22 6
ShaFaChuang-36210
|
5天前
|
算法 Unix Linux
深入理解Linux内核调度器：原理与优化
本文探讨了Linux操作系统的心脏——内核调度器（Scheduler）的工作原理，以及如何通过参数调整和代码优化来提高系统性能。不同于常规摘要仅概述内容，本摘要旨在激发读者对Linux内核调度机制深层次运作的兴趣，并简要介绍文章将覆盖的关键话题，如调度算法、实时性增强及节能策略等。
ShaFaChuang-36210
20 5
萝卜带泥
|
12天前
|
算法 Linux 定位技术
Linux内核中的进程调度算法解析####
【10月更文挑战第29天】 本文深入剖析了Linux操作系统的心脏——内核中至关重要的组成部分之一，即进程调度机制。不同于传统的摘要概述，我们将通过一段引人入胜的故事线来揭开进程调度算法的神秘面纱，展现其背后的精妙设计与复杂逻辑，让读者仿佛跟随一位虚拟的“进程侦探”，一步步探索Linux如何高效、公平地管理众多进程，确保系统资源的最优分配与利用。 ####
萝卜带泥
45 4
叫个什么名字
|
13天前
|
缓存 负载均衡 算法
Linux内核中的进程调度算法解析####
本文深入探讨了Linux操作系统核心组件之一——进程调度器，着重分析了其采用的CFS（完全公平调度器）算法。不同于传统摘要对研究背景、方法、结果和结论的概述，本文摘要将直接揭示CFS算法的核心优势及其在现代多核处理器环境下如何实现高效、公平的资源分配，同时简要提及该算法如何优化系统响应时间和吞吐量，为读者快速构建对Linux进程调度机制的认知框架。 ####
叫个什么名字
35 1
最好zzz
|
15天前
|
消息中间件 存储 Linux
Linux进程间通信（IPC）：深入理解核心机制
【10月更文挑战第27天】
最好zzz
41 1

热门文章

最新文章

  • 1
    linux内核分析之进程地址空间【转】
  • 2
    操作系统中进程的实现
  • 3
    Script:计算Oracle Streams进程所占用的内存大小
  • 4
    RAC5——11gR2以后GI进程的变化
  • 5
    6种查看Linux进程占用端口号的方法
  • 6
    深入linux内核架构读书笔记-进程管理和调度
  • 7
    python并发编程:Python在FastAPI服务中使用多进程池加速程序运行
  • 8
    【Oracle】-【体系结构-DBWR】-DBWR进程相关理解
  • 9
    进程和计划任务
  • 10
    2011年Android IPC进程间通讯机制学习笔记之一
  • 1
    LabVIEW 在NI Linux实时设备上访问Shell
    98
  • 2
    【Linux】线程的内核级理解&&详谈页表以及虚拟地址到物理地址之间的转化
    63
  • 3
    suse linux 11 安装GCC开发环境
    113
  • 4
    【Linux】详解信号的保存&&信号屏蔽字的设置
    63
  • 5
    【Linux】对信号产生的内核级理解
    39
  • 6
    【Linux】详解信号产生的方式
    56
  • 7
    【Linux】详解信号的分类&&如何自定义信号的作用
    88
  • 8
    【Linux】详解进程通信中信号量的本质&&同步和互斥的概念&&临界资源和临界区的概念
    62
  • 9
    【Linux】命名管道的创建方法&&基于命名管道的两个进程通信的实现
    82
  • 10
    【Linux】匿名管道实现简单进程池
    40

    • 相关课程

    更多
  • Linux Web服务器Nginx搭建与配置
  • Linux服务器运维基本操作
  • Linux基本命令
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • 观察进程的并发性
  • 部署Linux主机管理系统WDCP
  • 快速配置Linux云服务器
  • 基于Linux命令实现WordPress手动建站
  • Linux系统的安全登录

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    阿里云OSS设置跨域访问