Která priorita v reálném čase je v Linuxu nejvyšší prioritou

Krátká odpověď

99 bude vítězem pro prioritu v reálném čase.

PR je úroveň priority (rozsah -100 až 39). Čím nižší PR, tím vyšší bude priorita procesu.

PR se vypočítá následovně:

• pro normální procesy:PR =20 + NI (NI je pěkné a pohybuje se od -20 do 19)
• pro procesy v reálném čase:PR =- 1 - real_time_priority (real_time_priority se pohybuje od 1 do 99)

Dlouhá odpověď

Existují 2 typy procesů, normální jedničky a reálný čas Pro ty normální (a pouze pro ty) se nice aplikuje následovně:

Pěkné

Stupnice "slušnosti" se pohybuje od -20 do 19, přičemž -20 je nejvyšší priorita a 19 nejnižší priorita. Úroveň priority se vypočítá následovně:

PR =20 + NI

Kde NI je hezká úroveň a PR je prioritní úroveň. Jak tedy vidíme, -20 se ve skutečnosti zobrazuje na 0, zatímco 19 na 39.

Ve výchozím nastavení je hodnota program nice 0 bitů, takže uživatel root může spustit programy se zadanou hodnotou nice pomocí následujícího příkazu:

nice -n <nice_value> ./myProgram 

V reálném čase

Mohli bychom jít ještě dál. Priorita nice se ve skutečnosti používá pro uživatelské programy. Zatímco celková priorita UNIX/LINUX má rozsah 140 hodnot, hodnota nice umožňuje procesu mapování na poslední část rozsahu (od 100 do 139). Tato rovnice ponechává hodnoty od 0 do 99 nedosažitelné, což bude odpovídat záporné úrovni PR (od -100 do -1). Aby bylo možné k těmto hodnotám přistupovat, měl by být proces uveden jako „v reálném čase“.

V prostředí LINUX existuje 5 zásad plánování, které lze zobrazit pomocí následujícího příkazu:

chrt -m 

Což zobrazí následující seznam:

1. SCHED_OTHER   the standard round-robin time-sharing policy
2. SCHED_BATCH   for "batch" style execution of processes
3. SCHED_IDLE    for running very low priority background jobs.
4. SCHED_FIFO    a first-in, first-out policy
5. SCHED_RR      a round-robin policy

Procesy plánování lze rozdělit do 2 skupin, normální politiky plánování (1 až 3) a politiky plánování v reálném čase (4 a 5). Procesy v reálném čase budou mít vždy přednost před normálními procesy. Proces v reálném čase lze zavolat pomocí následujícího příkazu (Příklad je, jak deklarovat zásadu SCHED_RR):

chrt --rr <priority between 1-99> ./myProgram

Pro získání hodnoty PR pro proces v reálném čase se použije následující rovnice:

PR =-1 - rt_prior

Kde rt_prior odpovídá prioritě mezi 1 a 99. Z tohoto důvodu bude mít proces, který bude mít vyšší prioritu před ostatními procesy, ten, který bude volán s číslem 99.

Je důležité poznamenat, že pro procesy v reálném čase se hodnota nice nepoužívá.

Chcete-li vidět aktuální "příjemnost" a hodnotu PR procesu, můžete provést následující příkaz:

top

Což ukazuje následující výstup:

Na obrázku jsou zobrazeny hodnoty PR a NI. Je dobré zaznamenat proces s hodnotou PR -51, která odpovídá hodnotě v reálném čase. Existují také některé procesy, jejichž hodnota PR je uvedena jako „rt“. Tato hodnota ve skutečnosti odpovídá hodnotě PR -100.

Tento komentář v sched.h je docela definitivní:

/*
 * Priority of a process goes from 0..MAX_PRIO-1, valid RT
 * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
 * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
 * values are inverted: lower p->prio value means higher priority.
 *
 * The MAX_USER_RT_PRIO value allows the actual maximum
 * RT priority to be separate from the value exported to
 * user-space.  This allows kernel threads to set their
 * priority to a value higher than any user task. Note:
 * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
 */

Všimněte si této části:

Hodnoty priority jsou převrácené:nižší p->prio hodnota znamená vyšší prioritu .

Udělal jsem experiment, abych to dokázal takto:

• proces1:RT priorita =40, afinita CPU =CPU 0. Tento proces se "točí" po dobu 10 sekund, takže nedovolí žádnému procesu s nižší prioritou běžet na CPU 0.

• proces2:RT priorita =39, afinita CPU =CPU 0. Tento proces vytiskne zprávu na stdout každých 0,5 sekundy, mezitím spí. U každé zprávy vytiskne uplynulý čas.

Používám jádro 2.6.33 s patchem PREEMPT_RT.

Pro spuštění experimentu spustím process2 v jednom okně (jako root) a poté spustím process1 (jako root) v jiném okně. Výsledkem je, že proces1 zřejmě předjímá proces2 a neumožňuje mu běžet celých 10 sekund.

V druhém experimentu změním prioritu RT procesu 2 na 41. V tomto případě proces 2 není preempted process1.

Tento experiment ukazuje, že větší Hodnota priority RT v sched_setscheduler() má vyšší prioritu. Zdá se, že to odporuje tomu, co Michael Foukarakis poukázal na sched.h, ale ve skutečnosti tomu tak není. V sched.c ve zdrojovém kódu jádra máme:

static void
__setscheduler(struct rq *rq, struct task_struct *p, int policy, int prio)
{
        BUG_ON(p->se.on_rq);

        p->policy = policy;
        p->rt_priority = prio;
        p->normal_prio = normal_prio(p);
        /* we are holding p->pi_lock already */
        p->prio = rt_mutex_getprio(p);
        if (rt_prio(p->prio))
                p->sched_class = &rt_sched_class;
        else
                p->sched_class = &fair_sched_class;
        set_load_weight(p);
}

rt_mutex_getprio(p) provede následující:

return task->normal_prio;

Zatímco normal_prio() náhodou dělá následující:

prio = MAX_RT_PRIO-1 - p->rt_priority;  /* <===== notice! */
...
return prio;

Jinými slovy, máme (můj vlastní výklad):

p->prio = p->normal_prio = MAX_RT_PRIO - 1 - p->rt_priority

Páni! To je matoucí! Abych to shrnul:

• S p->prio menší hodnota předchází větší hodnotě.

• S p->rt_priority větší hodnota předchází menší hodnotě. Toto je priorita v reálném čase nastavená pomocí sched_setscheduler() .