进程调度如何找到优先级最高的进程

以下是调度器用于判断优先级最高进程的主要代码：

1. struct task_struct *prev, *next;
2. struct list_head *queue;
3. struct prio_array *array;
4. int indx;
6. prev = current;
7. array = rq->active;
8. indx = sched_find_first_bit(array->bitmap);
9. queue = array->queue + indx;
10. next = list_entry(queue->next,struct task_struct,run_list);

我们先看看上面提到的几个数据结构和函数。

• struct  task_struct

 内核把进程存放在叫做任务队列的双向循环链表中。链表中的每一项都是类型为task_struct（称为进程描述符）的结构。该结构在<linux/sched.h>中定义。该结构中，包含了两个结构成员struct list_head run_list和struct prio_array *array。

• 1. struct task_struct {
  2.     volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
  3.     struct thread_info *thread_info;
  4.     atomic_t usage;
  5.     unsigned long flags;    /* per process flags, defined below */
  6.     unsigned long ptrace;
  8.     int lock_depth;     /* BKL lock depth */
  10. #ifdef CONFIG_SMP 
  11. #ifdef __ARCH_WANT_UNLOCKED_CTXSW 
  12.     int oncpu;
  13. #endif 
  14. #endif 
  15.     int load_weight;    /* for niceness load balancing purposes */
  16.     int prio, static_prio, normal_prio;
  17.     struct list_head run_list;
  18.     struct prio_array *array;
  20.     unsigned short ioprio;
  21. #ifdef CONFIG_BLK_DEV_IO_TRACE 
  22.     unsigned int btrace_seq;
  23. #endif 
  24.     unsigned long sleep_avg;
  25.     unsigned long long timestamp, last_ran;
  26.     unsigned long long sched_time; /* sched_clock time spent running */
  27.     enum sleep_type sleep_type;
  29.     unsigned long policy;
  30.     cpumask_t cpus_allowed;
  31.     unsigned int time_slice, first_time_slice;
  33. #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) 
  34.     struct sched_info sched_info;
  35. #endif 
  37.     struct list_head tasks;
  38.     /*
  39.      * ptrace_list/ptrace_children forms the list of my children
  40.      * that were stolen by a ptracer.
  41.      */
  42.     struct list_head ptrace_children;
  43.     struct list_head ptrace_list;
  45.     struct mm_struct *mm, *active_mm;
  47. /* task state */
  48.     struct linux_binfmt *binfmt;
  49.     long exit_state;
  50.     int exit_code, exit_signal;
  51.     int pdeath_signal;  /*  The signal sent when the parent dies  */
  52.     /* ??? */
  53.     unsigned long personality;
  54.     unsigned did_exec:1;
  55.     pid_t pid;
  56.     pid_t tgid;
  58. #ifdef CONFIG_CC_STACKPROTECTOR 
  59.     /* Canary value for the -fstack-protector gcc feature */
  60.     unsigned long stack_canary;
  61. #endif 
  62.     /* 
  63.      * pointers to (original) parent process, youngest child, younger sibling,
  64.      * older sibling, respectively.  (p->father can be replaced with 
  65.      * p->parent->pid)
  66.      */
  67.     struct task_struct *real_parent; /* real parent process (when being debugged) */
  68.     struct task_struct *parent; /* parent process */
  69.     /*
  70.      * children/sibling forms the list of my children plus the
  71.      * tasks I'm ptracing.
  72.      */
  73.     struct list_head children;  /* list of my children */
  74.     struct list_head sibling;   /* linkage in my parent's children list */
  75.     struct task_struct *group_leader;   /* threadgroup leader */
  77.     /* PID/PID hash table linkage. */
  78.     struct pid_link pids[PIDTYPE_MAX];
  79.     struct list_head thread_group;
  81.     struct completion *vfork_done;      /* for vfork() */
  82.     int __user *set_child_tid;      /* CLONE_CHILD_SETTID */
  83.     int __user *clear_child_tid;        /* CLONE_CHILD_CLEARTID */
  85.     unsigned long rt_priority;
  86.     cputime_t utime, stime;
  87.     unsigned long nvcsw, nivcsw; /* context switch counts */
  88.     struct timespec start_time;
  89. /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
  90.     unsigned long min_flt, maj_flt;
  92.     cputime_t it_prof_expires, it_virt_expires;
  93.     unsigned long long it_sched_expires;
  94.     struct list_head cpu_timers[3];
  96. /* process credentials */
  97.     uid_t uid,euid,suid,fsuid;
  98.     gid_t gid,egid,sgid,fsgid;
  99.     struct group_info *group_info;
  100.     kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;
  101.     unsigned keep_capabilities:1;
  102.     struct user_struct *user;
  103. #ifdef CONFIG_KEYS 
  104.     struct key *request_key_auth;   /* assumed request_key authority */
  105.     struct key *thread_keyring; /* keyring private to this thread */
  106.     unsigned char jit_keyring;  /* default keyring to attach requested keys to */
  107. #endif 
  108.     /*
  109.      * fpu_counter contains the number of consecutive context switches
  110.      * that the FPU is used. If this is over a threshold, the lazy fpu
  111.      * saving becomes unlazy to save the trap. This is an unsigned char
  112.      * so that after 256 times the counter wraps and the behavior turns
  113.      * lazy again; this to deal with bursty apps that only use FPU for
  114.      * a short time
  115.      */
  116.     unsigned char fpu_counter;
  117.     int oomkilladj; /* OOM kill score adjustment (bit shift). */
  118.     char comm[TASK_COMM_LEN]; /* executable name excluding path
  119.                      - access with [gs]et_task_comm (which lock
  120.                        it with task_lock())
  121.                      - initialized normally by flush_old_exec */
  122. /* file system info */
  123.     int link_count, total_link_count;
  124. #ifdef CONFIG_SYSVIPC 
  125. /* ipc stuff */
  126.     struct sysv_sem sysvsem;
  127. #endif 
  128. /* CPU-specific state of this task */
  129.     struct thread_struct thread;
  130. /* filesystem information */
  131.     struct fs_struct *fs;
  132. /* open file information */
  133.     struct files_struct *files;
  134. /* namespaces */
  135.     struct nsproxy *nsproxy;
  136. /* signal handlers */
  137.     struct signal_struct *signal;
  138.     struct sighand_struct *sighand;
  140.     sigset_t blocked, real_blocked;
  141.     sigset_t saved_sigmask;     /* To be restored with TIF_RESTORE_SIGMASK */
  142.     struct sigpending pending;
  144.     unsigned long sas_ss_sp;
  145.     size_t sas_ss_size;
  146.     int (*notifier)(void *priv);
  147.     void *notifier_data;
  148.     sigset_t *notifier_mask;
  149.     
  150.     void *security;
  151.     struct audit_context *audit_context;
  152.     seccomp_t seccomp;
  154. /* Thread group tracking */
  155.     u32 parent_exec_id;
  156.     u32 self_exec_id;
  157. /* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
  158.     spinlock_t alloc_lock;
  160.     /* Protection of the PI data structures: */
  161.     spinlock_t pi_lock;
  163. #ifdef CONFIG_RT_MUTEXES 
  164.     /* PI waiters blocked on a rt_mutex held by this task */
  165.     struct plist_head pi_waiters;
  166.     /* Deadlock detection and priority inheritance handling */
  167.     struct rt_mutex_waiter *pi_blocked_on;
  168. #endif 
  170. #ifdef CONFIG_DEBUG_MUTEXES 
  171.     /* mutex deadlock detection */
  172.     struct mutex_waiter *blocked_on;
  173. #endif 
  174. #ifdef CONFIG_TRACE_IRQFLAGS 
  175.     unsigned int irq_events;
  176.     int hardirqs_enabled;
  177.     unsigned long hardirq_enable_ip;
  178.     unsigned int hardirq_enable_event;
  179.     unsigned long hardirq_disable_ip;
  180.     unsigned int hardirq_disable_event;
  181.     int softirqs_enabled;
  182.     unsigned long softirq_disable_ip;
  183.     unsigned int softirq_disable_event;
  184.     unsigned long softirq_enable_ip;
  185.     unsigned int softirq_enable_event;
  186.     int hardirq_context;
  187.     int softirq_context;
  188. #endif 
  189. #ifdef CONFIG_LOCKDEP 
  190. # define MAX_LOCK_DEPTH 30UL 
  191.     u64 curr_chain_key;
  192.     int lockdep_depth;
  193.     struct held_lock held_locks[MAX_LOCK_DEPTH];
  194.     unsigned int lockdep_recursion;
  195. #endif 
  197. /* journalling filesystem info */
  198.     void *journal_info;
  200. /* VM state */
  201.     struct reclaim_state *reclaim_state;
  203.     struct backing_dev_info *backing_dev_info;
  205.     struct io_context *io_context;
  207.     unsigned long ptrace_message;
  208.     siginfo_t *last_siginfo; /* For ptrace use.  */
  209. /*
  210.  * current io wait handle: wait queue entry to use for io waits
  211.  * If this thread is processing aio, this points at the waitqueue
  212.  * inside the currently handled kiocb. It may be NULL (i.e. default
  213.  * to a stack based synchronous wait) if its doing sync IO.
  214.  */
  215.     wait_queue_t *io_wait;
  216. #ifdef CONFIG_TASK_XACCT 
  217. /* i/o counters(bytes read/written, #syscalls */
  218.     u64 rchar, wchar, syscr, syscw;
  219. #endif 
  220.     struct task_io_accounting ioac;
  221. #if defined(CONFIG_TASK_XACCT) 
  222.     u64 acct_rss_mem1;  /* accumulated rss usage */
  223.     u64 acct_vm_mem1;   /* accumulated virtual memory usage */
  224.     cputime_t acct_stimexpd;/* stime since last update */
  225. #endif 
  226. #ifdef CONFIG_NUMA 
  227.     struct mempolicy *mempolicy;
  228.     short il_next;
  229. #endif 
  230. #ifdef CONFIG_CPUSETS 
  231.     struct cpuset *cpuset;
  232.     nodemask_t mems_allowed;
  233.     int cpuset_mems_generation;
  234.     int cpuset_mem_spread_rotor;
  235. #endif 
  236.     struct robust_list_head __user *robust_list;
  237. #ifdef CONFIG_COMPAT 
  238.     struct compat_robust_list_head __user *compat_robust_list;
  239. #endif 
  240.     struct list_head pi_state_list;
  241.     struct futex_pi_state *pi_state_cache;
  243.     atomic_t fs_excl;   /* holding fs exclusive resources */
  244.     struct rcu_head rcu;
  246.     /*
  247.      * cache last used pipe for splice
  248.      */
  249.     struct pipe_inode_info *splice_pipe;
  250. #ifdef  CONFIG_TASK_DELAY_ACCT 
  251.     struct task_delay_info *delays;
  252. #endif 
  253. #ifdef CONFIG_FAULT_INJECTION 
  254.     int make_it_fail;
  255. #endif 
  256. };
• struct  list_head

在Linux中list无处不在，如果定义一个结构使之成为链表，只需添加struct list_head结构作为它的一个成员就可以了。该结构定义在include/linux/list.h中。

• 1. typedef struct list_head {
  2.         struct list_head *next, *prev;         //双向链表
  3. } list_t;
  5. #define LIST_HEAD_INIT(name) { &(name), &(name) }       
  7. #define LIST_HEAD(name) /
  8.         struct list_head name = LIST_HEAD_INIT(name)     //定义一个空的链表
  10. #define INIT_LIST_HEAD(ptr) do { /               //初始化一个已定义的列表
  11.         (ptr)->next = (ptr); (ptr)->prev = (ptr); /
  12. } while (0)

• sturct rq

调度程序中最基本的数据结构是运行队列(runqueue)。可执行队列定义于kernel/sched.c中，由结构runqueue表示。可执行队列是给定处理器上的可执行进程的链表，每个处理器一个。每个可投入运行的进程都唯一的归属于一个可执行队列。此外，可执行队列中还包含每个处理器的调度信息。每个运行队列都有两个优先级数组，一个活跃的，一个过期的，如下代码中画红色下划线所示。

• 1. /*
  2.  * This is the main, per-CPU runqueue data structure.
  3.  *
  4.  * Locking rule: those places that want to lock multiple runqueues
  5.  * (such as the load balancing or the thread migration code), lock
  6.  * acquire operations must be ordered by ascending &runqueue.
  7.  */
  8. struct rq {
  9.     spinlock_t lock;
  11.     /*
  12.      * nr_running and cpu_load should be in the same cacheline because
  13.      * remote CPUs use both these fields when doing load calculation.
  14.      */
  15.     unsigned long nr_running;
  16.     unsigned long raw_weighted_load;
  17. #ifdef CONFIG_SMP
  18.     unsigned long cpu_load[3];
  19. #endif
  20.     unsigned long long nr_switches;
  22.     /*
  23.      * This is part of a global counter where only the total sum
  24.      * over all CPUs matters. A task can increase this counter on
  25.      * one CPU and if it got migrated afterwards it may decrease
  26.      * it on another CPU. Always updated under the runqueue lock:
  27.      */
  28.     unsigned long nr_uninterruptible;
  30.     unsigned long expired_timestamp;
  31.     /* Cached timestamp set by update_cpu_clock() */
  32.     unsigned long long most_recent_timestamp;
  33.     struct task_struct *curr, *idle;
  34.     unsigned long next_balance;
  35.     struct mm_struct *prev_mm;
  36.     struct prio_array *active, *expired, arrays[2];
  37.     int best_expired_prio;
  38.     atomic_t nr_iowait;
  40. #ifdef CONFIG_SMP
  41.     struct sched_domain *sd;
  43.     /* For active balancing */
  44.     int active_balance;
  45.     int push_cpu;
  46.     int cpu;        /* cpu of this runqueue */
  48.     struct task_struct *migration_thread;
  49.     struct list_head migration_queue;
  50. #endif
  52. #ifdef CONFIG_SCHEDSTATS
  53.     /* latency stats */
  54.     struct sched_info rq_sched_info;
  56.     /* sys_sched_yield() stats */
  57.     unsigned long yld_exp_empty;
  58.     unsigned long yld_act_empty;
  59.     unsigned long yld_both_empty;
  60.     unsigned long yld_cnt;
  62.     /* schedule() stats */
  63.     unsigned long sched_switch;
  64.     unsigned long sched_cnt;
  65.     unsigned long sched_goidle;
  67.     /* try_to_wake_up() stats */
  68.     unsigned long ttwu_cnt;
  69.     unsigned long ttwu_local;
  70. #endif
  71.     struct lock_class_key rq_lock_key;
  72. };
• struct  prio_array

优先级数组在kernel/sched.c中定义，它是prio_array类型的结构体。优先级数组使可运行处理器的每一种优先级都包含一个相应的队列，这些队列又包含对应优先级上的可执行进程链表。优先级数组拥有一个优先级位图，当需要查找当前系统内优先级最高的可执行程序时，它可提高效率。MAX_PRIO定义了系统拥有的优先级个数，默认值是140。优先级位图数组由宏DECLARE_BITMAP产生。类型为unsigned long长整型，长32位，如果每一个代表一个优先级的话，140个优先级需要5个长整型才能表示，因此bitmap含有5个数组项，总共160位

• 1. /*
  2.  * These are the runqueue data structures:
  3.  */
  5. struct prio_array {
  6.     unsigned int nr_active;
  7.     DECLARE_BITMAP(bitmap, MAX_PRIO+1); /* include 1 bit for delimiter */
  8.     struct list_head queue[MAX_PRIO];
  9. };
  11. #define DECLARE_BITMAP(name,bits) /
       unsigned long name[BITS_TO_LONGS(bits)]
  12. 
      #define BITS_TO_LONGS(bits) /
       (((bits)+BITS_PER_LONG-1)/BITS_PER_LONG)
      

• sched_find_first_bit(array->bitmap)

该函数的功能是在活动优先级数组中找到第一个被设置的位。由下面的代码可以知道，最终实现使用了汇编代码。

• 1. /*
  2.  * Every architecture must define this function. It's the fastest
  3.  * way of searching a 140-bit bitmap where the first 100 bits are
  4.  * unlikely to be set. It's guaranteed that at least one of the 140
  5.  * bits is cleared.
  6.  */
  7. static inline int sched_find_first_bit(unsigned long *b)
  8. {
  9.     return find_first_bit(b, 140);
  10. }
  12. /**
  13.  * find_first_bit - find the first set bit in a memory region
  14.  * @addr: The address to start the search at
  15.  * @size: The maximum size to search
  16.  *
  17.  * Returns the bit-number of the first set bit, not the number of the byte
  18.  * containing a bit.
  19.  */
  20. long find_first_bit(const unsigned long * addr, unsigned long size)
  21. {
  22.     return __find_first_bit(addr,size);
  23. }
  25. static inline long
  26. __find_first_bit(const unsigned long * addr, unsigned long size)
  27. {
  28.     long d0, d1;
  29.     long res;
  31.     /*
  32.      * We must test the size in words, not in bits, because
  33.      * otherwise incoming sizes in the range -63..-1 will not run
  34.      * any scasq instructions, and then the flags used by the jz
  35.      * instruction will have whatever random value was in place
  36.      * before.  Nobody should call us like that, but
  37.      * find_next_bit() does when offset and size are at the same
  38.      * word and it fails to find a one itself.
  39.      */
  40.     size += 63;
  41.     size >>= 6;
  42.     if (!size)
  43.         return 0;
  44.     asm volatile(
  45.         "   repe; scasq/n"
  46.         "   jz 1f/n"
  47.         "   subq $8,%%rdi/n"
  48.         "   bsfq (%%rdi),%%rax/n"
  49.         "1: subq %[addr],%%rdi/n"
  50.         "   shlq $3,%%rdi/n"
  51.         "   addq %%rdi,%%rax"
  52.         :"=a" (res), "=&c" (d0), "=&D" (d1)
  53.         :"0" (0ULL), "1" (size), "2" (addr),
  54.          [addr] "r" (addr) : "memory");
  55.     return res;
  56. }
• list_entry(ptr,type,member)

list_entry作用就是通过list_head型指针ptr换算成其宿主结构的起始地址，该宿主结构是type型的，

而ptr在其宿主结构中定义为member成员。定义在内核源文件include/linux/list.h中。

list_entry(queue->next,struct task_struct,run_list)分析：queue和queue->next都是list_head结构，其宿主结构是struct task_struct，在宿主结构中，包含了一个list_head结构类型变量run_list。这句代码的主要作用是通过queue->next的地址求出它所在的sturct task_struct结构的起始地址。

1. #define hlist_entry(ptr, type, member) container_of(ptr,type,member)