Jawaban Singkat
99 akan menjadi pemenang untuk prioritas waktu nyata.
PR adalah tingkat prioritas (kisaran -100 hingga 39). Semakin rendah PR, semakin tinggi prioritas prosesnya.
PR dihitung sebagai berikut:
- untuk proses normal:PR =20 + NI (NI bagus dan berkisar dari -20 hingga19)
- untuk proses waktu nyata:PR =- 1 - real_time_priority(real_time_priority berkisar dari 1 hingga 99)
Jawaban Panjang
Ada 2 jenis proses, normal satu dan waktu nyata Untuk yang normal (dan hanya untuk itu), nice diterapkan sebagai berikut:
Bagus
Skala "kebaikan" berubah dari -20 menjadi 19, sedangkan -20 adalah prioritas tertinggi dan 19 adalah prioritas terendah. Tingkat prioritas dihitung sebagai berikut:
PR =20 + NI
Dimana NI adalah level yang bagus dan PR adalah level prioritas. Jadi seperti yang bisa kita lihat, -20 sebenarnya memetakan ke 0, sedangkan 19 memetakan ke 39.
Secara default, nilai bagus program adalah 0 bit. Pengguna root dapat menjalankan program dengan nilai bagus tertentu dengan menggunakan perintah berikut:
nice -n <nice_value> ./myProgram
Waktu Nyata
Kita bisa melangkah lebih jauh. Prioritas bagus sebenarnya digunakan untuk program pengguna. Sedangkan prioritas keseluruhan UNIX/LINUX memiliki rentang nilai 140, nilai bagus memungkinkan proses memetakan ke bagian terakhir rentang (dari 100 hingga 139). Persamaan ini membuat nilai dari 0 hingga 99 tidak dapat dijangkau yang akan sesuai dengan tingkat PR negatif (dari -100 hingga -1). Untuk dapat mengakses nilai tersebut, proses harus dinyatakan sebagai "waktu nyata".
Ada 5 kebijakan penjadwalan di lingkungan LINUX yang dapat ditampilkan dengan perintah berikut:
chrt -m
Yang akan menampilkan daftar berikut:
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
Proses penjadwalan dapat dibagi menjadi 2 kelompok, kebijakan penjadwalan normal (1 hingga 3) dan kebijakan penjadwalan waktu nyata (4 dan 5). Proses waktu nyata akan selalu memiliki prioritas di atas proses normal. Proses waktu nyata dapat dipanggil menggunakan perintah berikut (Contohnya adalah cara mendeklarasikan kebijakan SCHED_RR):
chrt --rr <priority between 1-99> ./myProgram
Untuk mendapatkan nilai PR untuk proses real time digunakan persamaan berikut:
PR =-1 - rt_prior
Di mana rt_prior sesuai dengan prioritas antara 1 dan 99. Oleh karena itu, proses yang akan memiliki prioritas lebih tinggi daripada proses lain akan dipanggil dengan nomor 99.
Penting untuk diperhatikan bahwa untuk proses waktu nyata, nilai nice tidak digunakan.
Untuk melihat "kebaikan" dan nilai PR saat ini dari suatu proses, perintah berikut dapat dijalankan:
top
Yang menunjukkan output berikut:
Pada gambar ditampilkan nilai PR dan NI. Ada baiknya untuk mencatat proses dengan nilai PR -51 yang sesuai dengan nilai real time. Ada juga beberapa proses yang nilai PR-nya dinyatakan sebagai "rt". Nilai ini sebenarnya sesuai dengan nilai PR -100.
Komentar di sched.h ini cukup pasti:
/*
* 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.
*/
Perhatikan bagian ini:
Nilai prioritas terbalik:turunkan p->prio nilai berarti prioritas yang lebih tinggi .
Saya melakukan eksperimen untuk menyelesaikannya, sebagai berikut:
-
process1:Prioritas RT =40, afinitas CPU =CPU 0. Proses ini "berputar" selama 10 detik sehingga proses dengan prioritas lebih rendah tidak akan berjalan di CPU 0.
-
process2:Prioritas RT =39, afinitas CPU =CPU 0. Proses ini mencetak pesan ke stdout setiap 0,5 detik, tidur di antaranya. Itu mencetak waktu yang telah berlalu dengan setiap pesan.
Saya menjalankan kernel 2.6.33 dengan tambalan PREEMPT_RT.
Untuk menjalankan percobaan, saya menjalankan proses2 di satu jendela (sebagai root) dan kemudian memulai proses1 (sebagai root) di jendela lain. Hasilnya adalah process1 tampaknya mendahului process2, tidak mengizinkannya berjalan selama 10 detik penuh.
Dalam percobaan kedua, saya mengubah prioritas RT process2 menjadi 41. Dalam hal ini, process2 tidak didahului oleh process1.
Eksperimen ini menunjukkan bahwa lebih besar Nilai prioritas RT di sched_setscheduler() memiliki prioritas yang lebih tinggi. Hal ini tampaknya bertentangan dengan apa yang ditunjukkan oleh Michael Foukarakis dari sched.h, tetapi sebenarnya tidak demikian. Di sched.c di sumber kernel, kami memiliki:
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) melakukan hal berikut:
return task->normal_prio;
Sementara normal_prio() kebetulan melakukan hal berikut:
prio = MAX_RT_PRIO-1 - p->rt_priority; /* <===== notice! */
...
return prio;
Dengan kata lain, kami memiliki (interpretasi saya sendiri):
p->prio = p->normal_prio = MAX_RT_PRIO - 1 - p->rt_priority
Wow! Itu membingungkan! Untuk meringkas:
-
Dengan p->prio, nilai yang lebih kecil mendahului nilai yang lebih besar.
-
Dengan p->rt_priority, nilai yang lebih besar mendahului nilai yang lebih kecil. Ini adalah set prioritas real-time menggunakan
sched_setscheduler().