1 /*
 2  * Priority of a process goes from 0..MAX_PRIO-1, valid RT
 3  * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
 4  * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
 5  * values are inverted: lower p->prio value means higher priority.
 6  *
 7  * The MAX_USER_RT_PRIO value allows the actual maximum
 8  * RT priority to be separate from the value exported to
 9  * user-space.  This allows kernel threads to set their
10  * priority to a value higher than any user task. Note:
11  * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
12  */
13 
14 #define MAX_USER_RT_PRIO    100
15 #define MAX_RT_PRIO        MAX_USER_RT_PRIO
16 
17 #define MAX_PRIO        (MAX_RT_PRIO + 40)
18 #define DEFAULT_PRIO        (MAX_RT_PRIO + 20)

1 /*
2  * Convert user-nice values [ -20 ... 0 ... 19 ]
3  * to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
4  * and back.
5  */
6 #define NICE_TO_PRIO(nice)    (MAX_RT_PRIO + (nice) + 20)
7 #define PRIO_TO_NICE(prio)    ((prio) - MAX_RT_PRIO - 20)
8 #define TASK_NICE(p)        PRIO_TO_NICE((p)->static_prio)

 1 /*
 2  * Calculate the current priority, i.e. the priority
 3  * taken into account by the scheduler. This value might
 4  * be boosted by RT tasks, or might be boosted by
 5  * interactivity modifiers. Will be RT if the task got
 6  * RT-boosted. If not then it returns p->normal_prio.
 7  */
 8 static int effective_prio(struct task_struct *p)
 9 {
10     p->normal_prio = normal_prio(p);
11     /*
12      * If we are RT tasks or we were boosted to RT priority,
13      * keep the priority unchanged. Otherwise, update priority
14      * to the normal priority:
15      */
16     if (!rt_prio(p->prio))
17         return p->normal_prio;
18     return p->prio;
19 }

1 static inline int rt_prio(int prio)
2 {
3     if (unlikely(prio < MAX_RT_PRIO))
4         return 1;
5     return 0;
6 }

/*
 * __normal_prio - return the priority that is based on the static prio
 */
static inline int __normal_prio(struct task_struct *p)
{
    return p->static_prio;
}

/*
 * Calculate the expected normal priority: i.e. priority
 * without taking RT-inheritance into account. Might be
 * boosted by interactivity modifiers. Changes upon fork,
 * setprio syscalls, and whenever the interactivity
 * estimator recalculates.
 */
static inline int normal_prio(struct task_struct *p)
{
    int prio;

    if (task_has_rt_policy(p))
        prio = MAX_RT_PRIO-1 - p->rt_priority;
    else
        prio = __normal_prio(p);
    return prio;
}

1 struct load_weight {
2     unsigned long weight, inv_weight;
3 };

 1 /*
 2  * Nice levels are multiplicative, with a gentle 10% change for every
 3  * nice level changed. I.e. when a CPU-bound task goes from nice 0 to
 4  * nice 1, it will get ~10% less CPU time than another CPU-bound task
 5  * that remained on nice 0.
 6  *
 7  * The "10% effect" is relative and cumulative: from _any_ nice level,
 8  * if you go up 1 level, it‘s -10% CPU usage, if you go down 1 level
 9  * it‘s +10% CPU usage. (to achieve that we use a multiplier of 1.25.
10  * If a task goes up by ~10% and another task goes down by ~10% then
11  * the relative distance between them is ~25%.)
12  */
13 static const int prio_to_weight[40] = {
14  /* -20 */     88761,     71755,     56483,     46273,     36291,
15  /* -15 */     29154,     23254,     18705,     14949,     11916,
16  /* -10 */      9548,      7620,      6100,      4904,      3906,
17  /*  -5 */      3121,      2501,      1991,      1586,      1277,
18  /*   0 */      1024,       820,       655,       526,       423,
19  /*   5 */       335,       272,       215,       172,       137,
20  /*  10 */       110,        87,        70,        56,        45,
21  /*  15 */        36,        29,        23,        18,        15,
22 };

1 #define WEIGHT_IDLEPRIO                3
2 #define WMULT_IDLEPRIO         1431655765

 1 static void set_load_weight(struct task_struct *p)
 2 {
 3     if (task_has_rt_policy(p)) {
 4         p->se.load.weight = prio_to_weight[0] * 2;
 5         p->se.load.inv_weight = prio_to_wmult[0] >> 1;
 6         return;
 7     }
 8 
 9     /*
10      * SCHED_IDLE tasks get minimal weight:
11      */
12     if (p->policy == SCHED_IDLE) {
13         p->se.load.weight = WEIGHT_IDLEPRIO;
14         p->se.load.inv_weight = WMULT_IDLEPRIO;
15         return;
16     }
17 
18     p->se.load.weight = prio_to_weight[p->static_prio - MAX_RT_PRIO];
19     p->se.load.inv_weight = prio_to_wmult[p->static_prio - MAX_RT_PRIO];
20 }

 1 /*
 2  * Update delta_exec, delta_fair fields for rq.
 3  *
 4  * delta_fair clock advances at a rate inversely proportional to
 5  * total load (rq->load.weight) on the runqueue, while
 6  * delta_exec advances at the same rate as wall-clock (provided
 7  * cpu is not idle).
 8  *
 9  * delta_exec / delta_fair is a measure of the (smoothened) load on this
10  * runqueue over any given interval. This (smoothened) load is used
11  * during load balance.
12  *
13  * This function is called /before/ updating rq->load
14  * and when switching tasks.
15  */
16 static inline void inc_load(struct rq *rq, const struct task_struct *p)
17 {
18     update_load_add(&rq->load, p->se.load.weight);
19 }
20 
21 static inline void dec_load(struct rq *rq, const struct task_struct *p)
22 {
23     update_load_sub(&rq->load, p->se.load.weight);
24 }
25 
26 static void inc_nr_running(struct task_struct *p, struct rq *rq)
27 {
28     rq->nr_running++;
29     inc_load(rq, p);
30 }