第一次作业：基于Linux进程模型分析

• 前言

  　　　用户进程数一般多于处理机数，而在这样的情况下，对于如何将处理机分配给处于就绪队列的某一个进程以使之执行的处理是至关重要的。而本文将就Linux 2.6.32 及 CFS调度器进行其进程模型的分析。

  一、进程组织

• 　　进程提供了两种优先级，一种是普通的进程优先级，第二个是实时优先级。前者适用SCHED_NORMAL调度策略，后者可选SCHED_FIFO或SCHED_RR调度策略。任何时候，实时进程的优先级都高于普通进程，实时进程只会被更高级的实时进程抢占，同级实时进程之间是按照FIFO（一次机会做完）或者RR（多次轮转）规则调度的。

• 1.1    进程的概念

  进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

  进程在Windows下（通过任务管理器查看）：

• 

   

  进程在Linux下（通过ps指令查看）：

• 

• 1.2 进程调度的目标

• 1.高效性：高效意味着在相同的时间下要完成更多的任务。调度程序会被频繁的执行，所以调度程序要尽可能的高效；

• 2.加强交互性能:在系统相当的负载下，也要保证系统的响应时间； 

• 3.保证公平和避免饥渴；

• 4.SMP调度：调度程序必须支持多处理系统；

• 5.软实时调度：系统必须有效的调用实时进程，但不保证一定满足其要求；

• 1.3     Linux中的进程控制块PCB

• struct task_struct 
  {
   //说明了该进程是否可以执行,还是可中断等信息
      volatile long state;  
   //Flage 是进程号,在调用fork()时给出
   unsigned long flags;  
   //进程上是否有待处理的信号
   int sigpending;   
   //进程地址空间,区分内核进程与普通进程在内存存放的位置不同
   mm_segment_t addr_limit; //0-0xBFFFFFFF for user-thead  
        //0-0xFFFFFFFF for kernel-thread
                          
   //调度标志,表示该进程是否需要重新调度,若非0,则当从内核态返回到用户态,会发生调度
   volatile long need_resched;
   //锁深度
   int lock_depth;  
   //进程的基本时间片
   long nice;      
  
   //进程的调度策略,有三种,实时进程:SCHED_FIFO,SCHED_RR, 分时进程:SCHED_OTHER
   unsigned long policy;
   //进程内存管理信息
   struct mm_struct *mm; 
   
   int processor;
   //若进程不在任何CPU上运行, cpus_runnable 的值是0，否则是1 这个值在运行队列被锁时更新
   unsigned long cpus_runnable, cpus_allowed;
   //指向运行队列的指针
   struct list_head run_list; 
   //进程的睡眠时间
   unsigned long sleep_time; 
  
   //用于将系统中所有的进程连成一个双向循环链表, 其根是init_task
   struct task_struct *next_task, *prev_task;
   struct mm_struct *active_mm;
   struct list_head local_pages;       //指向本地页面      
   unsigned int allocation_order, nr_local_pages;
   struct linux_binfmt *binfmt;  //进程所运行的可执行文件的格式
   int exit_code, exit_signal;
   int pdeath_signal;     //父进程终止是向子进程发送的信号
   unsigned long personality;
   //Linux可以运行由其他UNIX操作系统生成的符合iBCS2标准的程序
   int did_exec:1; 
   pid_t pid;    //进程标识符,用来代表一个进程
   pid_t pgrp;   //进程组标识,表示进程所属的进程组
   pid_t tty_old_pgrp;  //进程控制终端所在的组标识
   pid_t session;  //进程的会话标识
   pid_t tgid;
   int leader;     //表示进程是否为会话主管
   struct task_struct *p_opptr,*p_pptr,*p_cptr,*p_ysptr,*p_osptr;
   struct list_head thread_group;   //线程链表
   struct task_struct *pidhash_next; //用于将进程链入HASH表
   struct task_struct **pidhash_pprev;
   wait_queue_head_t wait_chldexit;  //供wait4()使用
   struct completion *vfork_done;  //供vfork() 使用
   unsigned long rt_priority; //实时优先级，用它计算实时进程调度时的weight值
   //it_real_value，it_real_incr用于REAL定时器，单位为jiffies, 系统根据it_real_value
  
   //设置定时器的第一个终止时间. 在定时器到期时，向进程发送SIGALRM信号，同时根据
  
   //it_real_incr重置终止时间，it_prof_value，it_prof_incr用于Profile定时器，单位为jiffies。
  
   //当进程运行时，不管在何种状态下，每个tick都使it_prof_value值减一，当减到0时，向进程发送
  
   //信号SIGPROF，并根据it_prof_incr重置时间.
   //it_virt_value，it_virt_value用于Virtual定时器，单位为jiffies。当进程运行时，不管在何种
  
   //状态下，每个tick都使it_virt_value值减一当减到0时，向进程发送信号SIGVTALRM，根据
  
   //it_virt_incr重置初值。
  
   unsigned long it_real_value, it_prof_value, it_virt_value;
   unsigned long it_real_incr, it_prof_incr, it_virt_value;
   struct timer_list real_timer;   //指向实时定时器的指针
   struct tms times;      //记录进程消耗的时间
   unsigned long start_time;  //进程创建的时间
  
   //记录进程在每个CPU上所消耗的用户态时间和核心态时间
   long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS]; 
   //内存缺页和交换信息:
  
   //min_flt, maj_flt累计进程的次缺页数（Copy on　Write页和匿名页）和主缺页数（从映射文件或交换
  
   //设备读入的页面数）； nswap记录进程累计换出的页面数，即写到交换设备上的页面数。
   //cmin_flt, cmaj_flt, cnswap记录本进程为祖先的所有子孙进程的累计次缺页数，主缺页数和换出页面数。
  
   //在父进程回收终止的子进程时，父进程会将子进程的这些信息累计到自己结构的这些域中
   unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
   int swappable:1; //表示进程的虚拟地址空间是否允许换出
   //进程认证信息
   //uid,gid为运行该进程的用户的用户标识符和组标识符，通常是进程创建者的uid，gid
  
   //euid，egid为有效uid,gid
   //fsuid，fsgid为文件系统uid,gid，这两个ID号通常与有效uid,gid相等，在检查对于文件
  
   //系统的访问权限时使用他们。
   //suid，sgid为备份uid,gid
   uid_t uid,euid,suid,fsuid;
   gid_t gid,egid,sgid,fsgid;
   int ngroups; //记录进程在多少个用户组中
   gid_t groups[NGROUPS]; //记录进程所在的组
  
   //进程的权能，分别是有效位集合，继承位集合，允许位集合
   kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
  
   int keep_capabilities:1;
   struct user_struct *user;
   struct rlimit rlim[RLIM_NLIMITS];  //与进程相关的资源限制信息
   unsigned short used_math;   //是否使用FPU
   char comm[16];   //进程正在运行的可执行文件名
   //文件系统信息
   int link_count, total_link_count;
  
   //NULL if no tty 进程所在的控制终端，如果不需要控制终端，则该指针为空
   struct tty_struct *tty;
   unsigned int locks;
   //进程间通信信息
   struct sem_undo *semundo;  //进程在信号灯上的所有undo操作
   struct sem_queue *semsleeping; //当进程因为信号灯操作而挂起时，他在该队列中记录等待的操作
   //进程的CPU状态，切换时，要保存到停止进程的task_struct中
   struct thread_struct thread;
     //文件系统信息
   struct fs_struct *fs;
     //打开文件信息
   struct files_struct *files;
     //信号处理函数
   spinlock_t sigmask_lock;
   struct signal_struct *sig; //信号处理函数
   sigset_t blocked;  //进程当前要阻塞的信号，每个信号对应一位
   struct sigpending pending;  //进程上是否有待处理的信号
   unsigned long sas_ss_sp;
   size_t sas_ss_size;
   int (*notifier)(void *priv);
   void *notifier_data;
   sigset_t *notifier_mask;
   u32 parent_exec_id;
   u32 self_exec_id;
  
   spinlock_t alloc_lock;
   void *journal_info;
   };

  其中PID作为程序的标识符，通过pid_t getpid(void)得到

• 二、进程状态转换（给出进程状态转换图）

• 2.1 Linux 中的进程状态

• TASK_RUNNING	可执行状态。
  TASK_INTERRUPTIBLE	可中断的睡眠状态
  TASK_UNINTERRUPTIBLE	不可中断的睡眠状态
  TASK_STOPPED	暂停状态
  TASK_TRACED	跟踪状态
  TASK_DEAD - EXIT_ZOMBIE	退出状态，进程成为僵尸进程
  (TASK_DEAD - EXIT_DEAD	退出状态，进程即将被销毁

• TASK_RUNNING: 只有在该状态的进程才可能在CPU上运行。而同一时刻可能有多个进程处于可执行状态
• TASK_INTERRUPTIBLE:  处于这个状态的进程因为等待某某事件的发生（比如等待socket连接、等待信号量），而被挂起。
• TASK_UNITERRUPTIBLE: 与TASK_INTERRUPTIBLE状态类似，进程处于睡眠状态，但是此刻进程是不可中断的。
• TASK_STOPPED 和 TASK_TRACED: TASK_STOPPED和TASK_TRACED状态很类似，都是表示进程暂停下来。而TASK_TRACED状态相当于在TASK_STOPPED之上多了一层保护，处于TASK_TRACED状态的进程不能响应SIGCONT信号而被唤醒。只能等到调试进程通过ptrace系统调用执行PTRACE_CONT、PTRACE_DETACH等操作（通过ptrace系统调用的参数指定操作），或调试进程退出，被调试的进程才能恢复TASK_RUNNING状态。
• TASK_DEAD - EXIT_ZOMBIE: 在进程的退出过程中，进程占有的所有资源将被回收，除了task_struct结构（以及少数资源）以外。于是进程就只剩下task_struct这么个空壳，故称为僵尸。
• TASK_DEAD - EXIT_DEAD: 进程在退出过程中也不保留它的task_struct， 此时，进程将被置于EXIT_DEAD退出状态

• 2.2 进程状态转换图

• 

   

• 三、进程调度

• 3.1.CFS（completely fair schedule）调度器简介：

•  cfs定义了一种新的模型，它给cfs_rq（cfs的run queue）中的每一个进程安排一个虚拟时钟，vruntime。如果一个进程得以执行，随着时间的增长（也就是一个个tick的到来），其vruntime将不断增大。没有得到执行的进程vruntime不变。

• 3.2 CFS调度器的实现

• 3.2.1 vruntime 的计算

• CFS根据各个进程的权重分配运行时间
• 计算公式为：分配给进程的运行时间 = 调度周期 * 进程权重 / 所有进程权重之和
• vruntime = 实际运行时间 * (NICE_0_LOAD / 权重）

• 3.2.1 CFS主要数据结构

• struct sched_entity {
  /* 权重，在数组prio_to_weight[]包含优先级转权重的数值 */
  struct load_weight load; /* for load-balancing */
  /* 实体在红黑树对应的结点信息 */
  struct rb_node run_node; 
  /* 实体所在的进程组 */
  struct list_head group_node;
  /* 实体是否处于红黑树运行队列中 */
  unsigned int on_rq;
  
  /* 开始运行时间 */
  u64 exec_start;
  /* 总运行时间 */
  u64 sum_exec_runtime;
  /* 虚拟运行时间，在时间中断或者任务状态发生改变时会更新
  * 其会不停增长，增长速度与load权重成反比，load越高，增长速度越慢，就越可能处于红黑树最左边被调度
  * 每次时钟中断都会修改其值
  * 具体见calc_delta_fair()函数
  */
  u64 vruntime;
  /* 进程在切换进CPU时的sum_exec_runtime值 */
  u64 prev_sum_exec_runtime;
  
  /* 此调度实体中进程移到其他CPU组的数量 */
  u64 nr_migrations;
  
  #ifdef CONFIG_SCHEDSTATS
  /* 用于统计一些数据 */
  struct sched_statistics statistics;
  #endif
  
  #ifdef CONFIG_FAIR_GROUP_SCHED
  /* 代表此进程组的深度，每个进程组都比其parent调度组深度大1 */
  int depth;
  /* 父亲调度实体指针，如果是进程则指向其运行队列的调度实体，如果是进程组则指向其上一个进程组的调度实体
  * 在 set_task_rq 函数中设置
  */
  struct sched_entity *parent;
  /* 实体所处红黑树运行队列 */
  struct cfs_rq *cfs_rq; 
  /* 实体的红黑树运行队列，如果为NULL表明其是一个进程，若非NULL表明其是调度组 */
  struct cfs_rq *my_q;
  #endif
  
  #ifdef CONFIG_SMP
  /* Per-entity load-tracking */
  struct sched_avg avg;
  #endif
  };

• 其中需要注意的成员有：
• 1. load：权重，通过优先级转换而成，用于计算vruntime
• 2.on_rq：表示是否在红黑树运行队列中
• 3.vruntime：vitual runtime 虚拟运行时间，作为红黑树排序的标准

• 3.2.3 调度处理函数

• asmlinkage void __sched schedule(void)  
  {  
      struct task_struct *prev, *next;  
      unsigned long *switch_count;  
      struct rq *rq;  
      int cpu;  
  need_resched:  
      preempt_disable(); //在这里面被抢占可能出现问题，故禁止
      cpu = smp_processor_id();  
      rq = cpu_rq(cpu);  
      rcu_qsctr_inc(cpu);  
      prev = rq->curr;  
      switch_count = &prev->nivcsw;  
      release_kernel_lock(prev);  
  need_resched_nonpreemptible:  
      spin_lock_irq(&rq->lock);  
      update_rq_clock(rq);  
      clear_tsk_need_resched(prev); //清除需要调度的位  
  
      if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {  
          if (unlikely(signal_pending_state(prev->state, prev)))  
              prev->state = TASK_RUNNING;  
          else  
              deactivate_task(rq, prev, 1); 
          switch_count = &prev->nvcsw;  
      }  
      if (unlikely(!rq->nr_running))  
          idle_balance(cpu, rq);  
  
      prev->sched_class->put_prev_task(rq, prev);  //把当前进程加入红黑树中
      next = pick_next_task(rq, prev);  //从红黑树中挑选出下一个要运行的进程, 并
  //将其设置为当前进程
      if (likely(prev != next)) {  
          sched_info_switch(prev, next);  
          rq->nr_switches++;  
          rq->curr = next;  
          ++*switch_count;  
          //完成进程切换 
          context_switch(rq, prev, next); 
  
          cpu = smp_processor_id();  
          rq = cpu_rq(cpu);  
      } else  
          spin_unlock_irq(&rq->lock);  
      if (unlikely(reacquire_kernel_lock(current) < 0))  
          goto need_resched_nonpreemptible;  
      preempt_enable_no_resched();  
      //这里新进程也可能有TIF_NEED_RESCHED标志，如果新进程也需要调度则再调度一次  
      if (unlikely(test_thread_flag(TIF_NEED_RESCHED)))  
          goto need_resched;  
  }  

•  通过将当前进程加入红黑树，然后从红黑树中挑选出下一个要运行的进程并将其设置为当前进程来完成进程的切换

• 四、对该操作系统进程模型的看法 

• 　　 Linux作为主流的开源系统之一，有其天然的优越性，它在进程调度方面的优化对整个系统的提升是至关重要的，而在其中扮演关键角色的CFS调度器，在这方面处理的很好，他既能公平选择进程，又能保证高优先级进程
  获得较多的运行时间，正如他的名字Completely Fair Schedule一样，他是一个近似完全公平的算法，而正是有了这个调度器作为核心，调动起整个系统进程，使得多个进程能够以较优的顺序运行着。