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

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

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)