Chapter 5

Machine Translated by Google
CPU 5BAB
Penjadwalan
Penjadwalan CPU adalah dasar dari sistem operasi multiprogram. Dengan mengalihkan
CPU di antara proses, sistem operasi dapat membuat komputer lebih produktif. Dalam
bab ini, kami memperkenalkan konsep penjadwalan CPU dasar dan menyajikan
beberapa algoritme penjadwalan CPU, termasuk sistem waktu nyata.
Kami juga mempertimbangkan masalah pemilihan algoritma untuk sistem tertentu.
Dalam Bab 4, kami memperkenalkan utas ke model proses. Pada sistem operasi
modern, utas tingkat kernel—bukan proses—yang sebenarnya dijadwalkan oleh sistem
operasi. Namun, istilah "penjadwalan proses" dan "penjadwalan thread" sering
digunakan secara bergantian. Dalam bab ini, kita menggunakan penjadwalan proses
ketika mendiskusikan konsep penjadwalan umum dan penjadwalan thread untuk
merujuk pada ide spesifik thread.
Demikian pula, dalam Bab 1 kami menjelaskan bagaimana inti adalah unit
komputasi dasar CPU, dan bahwa suatu proses dijalankan pada inti CPU . Namun,
dalam banyak contoh dalam bab ini, ketika kami menggunakan terminologi umum
penjadwalan proses untuk "berjalan pada CPU", kami menyiratkan bahwa proses
tersebut berjalan pada inti CPU .
TUJUAN BAB
• Jelaskan berbagai algoritma penjadwalan CPU .

• Menilai algoritma penjadwalan CPU berdasarkan kriteria penjadwalan.
• Jelaskan masalah yang terkait dengan penjadwalan multiprosesor dan
multicore. • Jelaskan berbagai algoritma penjadwalan real-time. • Jelaskan
algoritma penjadwalan yang digunakan di Windows, Linux, dan
Sistem operasi Solaris.
• Terapkan pemodelan dan simulasi untuk mengevaluasi algoritma penjadwalan CPU . •
Rancang program yang mengimplementasikan beberapa algoritma penjadwalan CPU yang berbeda
ritma.
199
200 Bab 5 Penjadwalan CPU
5.1 Konsep Dasar
Dalam sistem dengan satu inti CPU , hanya satu proses yang dapat berjalan pada satu
waktu. Yang lain harus menunggu hingga inti CPU kosong dan dapat dijadwal ulang. Tujuan
dari multiprogramming adalah agar beberapa proses berjalan setiap saat, untuk
memaksimalkan penggunaan CPU . Idenya relatif sederhana. Suatu proses dijalankan
sampai harus menunggu, biasanya untuk penyelesaian beberapa permintaan I/O . Dalam
sistem komputer sederhana, CPU kemudian hanya diam. Semua waktu menunggu ini
terbuang sia-sia; tidak ada pekerjaan yang bermanfaat tercapai. Dengan multiprogramming,
kami mencoba menggunakan waktu ini secara produktif. Beberapa proses disimpan dalam
memori pada satu waktu. Ketika satu proses harus menunggu, sistem operasi mengambil
CPU dari proses itu dan memberikan CPU ke proses lain. Pola ini berlanjut. Setiap kali satu
proses harus menunggu, proses lain dapat mengambil alih penggunaan CPU. Pada sistem
multicore, konsep membuat CPU tetap sibuk ini diperluas ke semua inti pemrosesan pada
sistem.
Penjadwalan semacam ini adalah fungsi sistem operasi yang mendasar.
Hampir semua sumber daya komputer dijadwalkan sebelum digunakan. CPU , tentu saja,
adalah salah satu sumber daya komputer utama . Dengan demikian, penjadwalannya
merupakan pusat desain sistem operasi.
•
•
•
muat toko
tambahkan CPU meledak
toko baca dari file
tunggu I/O I/O meledak
simpan indeks
kenaikan tulis ke file CPU meledak
muat toko
tambahkan CPU meledak
toko baca dari file
•
•
•
Gambar 5.1 Urutan CPU dan I/O burst bergantian.

5.1 Konsep Dasar 201
5.1.1 CPU – I/O Burst Cycle
Keberhasilan penjadwalan CPU tergantung pada properti proses yang diamati: eksekusi
proses terdiri dari siklus eksekusi CPU dan tunggu I/O . Proses bergantian antara dua
keadaan ini. Eksekusi proses dimulai dengan CPU burst.
Itu diikuti oleh ledakan I/O , yang diikuti oleh ledakan CPU lainnya , kemudian ledakan I/
O lainnya, dan seterusnya. Akhirnya, CPU burst terakhir berakhir dengan permintaan
sistem untuk menghentikan eksekusi (Gambar 5.1).
Durasi CPU burst telah diukur secara ekstensif. Meskipun mereka sangat bervariasi
dari proses ke proses dan dari komputer ke komputer, mereka cenderung memiliki kurva
frekuensi yang sama dengan yang ditunjukkan pada Gambar 5.2. Kurva umumnya
dicirikan sebagai eksponensial atau hipereksponensial, dengan sejumlah besar CPU
burst pendek dan sejumlah kecil CPU burst panjang.
Program terikat I/O biasanya memiliki banyak CPU burst singkat. Program terikat-CPU
mungkin memiliki beberapa ledakan CPU yang panjang. Distribusi ini dapat menjadi
penting ketika menerapkan algoritma penjadwalan CPU.
5.1.2 Penjadwal CPU
Setiap kali CPU menjadi idle, sistem operasi harus memilih salah satu proses dalam
antrian siap untuk dieksekusi. Proses pemilihan dilakukan oleh CPU scheduler, yang
memilih proses dari proses di memori yang siap dieksekusi dan mengalokasikan CPU
ke proses tersebut.
Perhatikan bahwa antrian ready belum tentu antrian first-in, first-out (FIFO) .
Seperti yang akan kita lihat ketika kita mempertimbangkan berbagai algoritma
penjadwalan, antrian siap dapat diimplementasikan sebagai antrian FIFO , antrian
prioritas, pohon, atau hanya daftar tertaut yang tidak berurutan. Namun, secara
konseptual, semua proses dalam antrian siap berbaris menunggu kesempatan untuk
dijalankan pada CPU. Catatan dalam antrian umumnya blok kontrol proses (PCB) dari prose
frekuensi
durasi ledakan
Gambar 5.2 Histogram durasi CPU-burst.

5.1.3 Penjadwalan Preemptive dan Nonpreemptive
Keputusan penjadwalan CPU dapat terjadi di bawah empat keadaan berikut:
sikap:
1. Ketika sebuah proses beralih dari status berjalan ke status menunggu (misalnya,
sebagai hasil dari permintaan I/O atau pemanggilan wait() untuk penghentian proses
anak)
2. Saat sebuah proses beralih dari status berjalan ke status siap (misalnya, saat terjadi
interupsi)
3. Ketika suatu proses beralih dari status menunggu ke status siap (misalnya, pada
penyelesaian I/O)
4. Ketika sebuah proses berakhir
Untuk situasi 1 dan 4, tidak ada pilihan dalam hal penjadwalan. Proses baru (jika ada
dalam antrian siap) harus dipilih untuk dieksekusi. Namun, ada pilihan untuk situasi 2 dan
3.
Ketika penjadwalan terjadi hanya dalam keadaan 1 dan 4, kami mengatakan bahwa
skema penjadwalan nonpreemptive atau kooperatif. Jika tidak, itu adalah pre-emptive.
Di bawah penjadwalan nonpreemptive, setelah CPU telah dialokasikan ke suatu proses,
proses tersebut mempertahankan CPU sampai ia melepaskannya baik dengan
menghentikan atau dengan beralih ke status menunggu. Hampir semua sistem operasi
modern termasuk Windows, macOS, Linux, dan UNIX menggunakan algoritma penjadwalan
preemptive.
Sayangnya, penjadwalan preemptive dapat mengakibatkan kondisi balapan ketika
data dibagikan di antara beberapa proses. Pertimbangkan kasus dua proses yang berbagi
data. Saat satu proses memperbarui data, itu didahulukan sehingga proses kedua dapat
berjalan. Proses kedua kemudian mencoba membaca data, yang berada dalam keadaan
tidak konsisten. Masalah ini akan dieksplorasi secara rinci dalam Bab 6.
Preemption juga mempengaruhi desain kernel sistem operasi. Selama pemrosesan

panggilan sistem, kernel mungkin sibuk dengan aktivitas atas nama proses. Kegiatan
tersebut mungkin melibatkan perubahan data kernel penting (misalnya, antrian I/O ). Apa
yang terjadi jika proses didahulukan di tengah perubahan ini dan kernel (atau driver
perangkat) perlu membaca atau memodifikasi struktur yang sama? Kekacauan terjadi.
Seperti yang akan dibahas dalam Bagian 6.2, kernel sistem operasi dapat dirancang
sebagai nonpreemptive atau preemptive. Kernel nonpreemptive akan menunggu panggilan
sistem selesai atau proses diblokir sambil menunggu I/O selesai sebelum melakukan
sakelar konteks. Skema ini memastikan bahwa struktur kernel sederhana, karena kernel
tidak akan mendahului proses saat struktur data kernel berada dalam keadaan tidak
konsisten. Sayangnya, model eksekusi kernel ini adalah model yang buruk untuk
mendukung komputasi real-time, di mana tugas harus menyelesaikan eksekusi dalam
jangka waktu tertentu. Di Bagian 5.6, kami mengeksplorasi tuntutan penjadwalan sistem
waktu nyata. Kernel preemptive memerlukan mekanisme seperti kunci mutex untuk
mencegah kondisi balapan saat mengakses struktur data kernel bersama.
Kebanyakan sistem operasi modern sekarang sepenuhnya preemptive ketika berjalan

dalam mode kernel.
5.1 Konsep Dasar 203
P0
mengeksekusi
simpan status
menjadi PCB0
pengiriman
latensi
memulihkan keadaan
dari PCB1
pelaksanaan P1
Gambar 5.3 Peran petugas operator.
Karena interupsi dapat, menurut definisi, terjadi kapan saja, dan karena interupsi
tidak selalu dapat diabaikan oleh kernel, bagian kode yang terpengaruh oleh
interupsi harus dijaga agar tidak digunakan secara bersamaan. Sistem operasi perlu
menerima interupsi hampir setiap saat. Jika tidak, input mungkin hilang atau output
ditimpa. Agar bagian kode ini tidak diakses secara bersamaan oleh beberapa
proses, mereka menonaktifkan interupsi saat masuk dan mengaktifkan kembali
interupsi saat keluar. Penting untuk dicatat bahwa bagian kode yang menonaktifkan
interupsi tidak sering terjadi dan biasanya berisi beberapa instruksi.
5.1.4 Pengirim
Komponen lain yang terlibat dalam fungsi penjadwalan CPU adalah dispatcher.
Dispatcher adalah modul yang memberikan kendali inti CPU ke proses yang dipilih
oleh penjadwal CPU . Fungsi ini melibatkan hal-hal berikut:
• Beralih konteks dari satu proses ke proses lain •

Beralih ke mode pengguna • Melompat ke lokasi
yang tepat di program pengguna untuk melanjutkan program itu
Dispatcher harus secepat mungkin, karena dipanggil selama setiap sakelar

konteks. Waktu yang diperlukan operator untuk menghentikan satu proses dan
memulai proses lainnya dikenal sebagai latensi pengiriman dan diilustrasikan pada
Gambar 5.3.
Pertanyaan yang menarik untuk dipertimbangkan adalah, seberapa sering
terjadi peralihan konteks? Pada tingkat seluruh sistem, jumlah sakelar konteks
dapat diperoleh dengan menggunakan perintah vmstat yang tersedia di sistem
Linux. Di bawah ini adalah output (yang telah dipangkas) dari perintah
vmstat 1 3
Perintah ini menyediakan 3 baris output selama penundaan 1 detik:
------cpu----- 24 225
339
Baris pertama memberikan jumlah rata-rata sakelar konteks selama 1 detik sejak
sistem di-boot, dan dua baris berikutnya memberikan jumlah sakelar konteks selama dua
interval 1 detik. Sejak mesin ini di-boot, ia memiliki rata-rata 24 sakelar konteks per detik.
Dan di detik terakhir, 225 sakelar konteks dibuat, dengan 339 sakelar konteks di detik
sebelumnya.
Kita juga dapat menggunakan sistem file /proc untuk menentukan jumlah sakelar
konteks untuk proses tertentu. Misalnya, isi file /proc/2166/status akan mencantumkan
berbagai statistik untuk proses dengan pid = 2166. Perintah
cat /proc/2166/status
memberikan output yang dipangkas berikut:
sakelar ctxt sukarela sakelar ctxt 150

tidak sukarela 8
Output ini menunjukkan jumlah switch konteks selama masa proses. Perhatikan perbedaan
antara sakelar konteks sukarela dan non-sukarela. Sebuah sakelar konteks sukarela
terjadi ketika suatu proses telah menyerahkan kendali CPU karena memerlukan sumber
daya yang saat ini tidak tersedia (seperti pemblokiran untuk I/O.) Sakelar konteks non-
sukarela terjadi ketika CPU telah diambil dari suatu proses, seperti saat irisan waktunya
telah kedaluwarsa atau telah didahului oleh proses dengan prioritas lebih tinggi.
5.2 Kriteria Penjadwalan

Algoritme penjadwalan CPU yang berbeda memiliki properti yang berbeda, dan pilihan
algoritme tertentu dapat mendukung satu kelas proses di atas yang lain. Dalam memilih
algoritma mana yang akan digunakan dalam situasi tertentu, kita harus mempertimbangkan
properti dari berbagai algoritma.
Banyak kriteria telah disarankan untuk membandingkan algoritma penjadwalan CPU.
Karakteristik mana yang digunakan untuk perbandingan dapat membuat perbedaan
substansial dalam algoritma mana yang dinilai terbaik. Kriteria tersebut antara lain sebagai
berikut:
• pemanfaatan CPU. Kami ingin membuat CPU sesibuk mungkin. Secara konseptual,
penggunaan CPU dapat berkisar dari 0 hingga 100 persen. Dalam sistem nyata, itu
harus berkisar dari 40 persen (untuk sistem dengan beban ringan) hingga 90 persen
(untuk sistem dengan beban berat). (Pemanfaatan CPU dapat diperoleh dengan
menggunakan perintah teratas pada sistem Linux, macOS, dan UNIX .)
• Keluaran. Jika CPU sibuk menjalankan proses, maka pekerjaan sedang dilakukan.
Salah satu ukuran pekerjaan adalah jumlah proses yang diselesaikan
5.3 Algoritma Penjadwalan 205
per satuan waktu, yang disebut throughput. Untuk proses yang lama, kecepatan ini
mungkin satu proses selama beberapa detik; untuk transaksi pendek, mungkin puluhan
proses per detik. • Waktu penyelesaian. Dari sudut pandang proses tertentu, kriteria
penting adalah berapa lama waktu yang dibutuhkan untuk mengeksekusi proses itu.
Interval dari waktu penyerahan suatu proses sampai dengan waktu penyelesaiannya
adalah waktu turnaround. Turnaround time adalah jumlah periode yang dihabiskan
untuk menunggu di ready queue, dieksekusi di CPU, dan melakukan I/O.
• Waktu tunggu. Algoritma penjadwalan CPU tidak mempengaruhi jumlah waktu selama
proses mengeksekusi atau melakukan I/O. Ini hanya mempengaruhi jumlah waktu
yang dihabiskan proses menunggu dalam antrian siap. Waktu tunggu adalah jumlah
periode yang dihabiskan menunggu dalam antrian siap.
• Waktu respons. Dalam sistem interaktif, waktu penyelesaian mungkin bukan kriteria
terbaik. Seringkali, suatu proses dapat menghasilkan beberapa keluaran cukup awal
dan dapat terus menghitung hasil baru sementara hasil sebelumnya sedang dikeluarkan
ke pengguna. Jadi, ukuran lain adalah waktu dari pengajuan permintaan sampai
tanggapan pertama dihasilkan. Ukuran ini, yang disebut waktu respons, adalah waktu
yang diperlukan untuk mulai merespons, bukan waktu yang diperlukan untuk
mengeluarkan respons.
Diinginkan untuk memaksimalkan pemanfaatan dan throughput CPU dan meminimalkan

waktu penyelesaian, waktu tunggu, dan waktu respons. Dalam kebanyakan kasus, kami
mengoptimalkan ukuran rata-rata. Namun, dalam beberapa keadaan, kami lebih memilih
untuk mengoptimalkan nilai minimum atau maksimum daripada rata-rata. Misalnya, untuk
menjamin semua pengguna mendapatkan layanan yang baik, kami mungkin ingin
meminimalkan waktu respons maksimum.
Penyelidik telah menyarankan bahwa, untuk sistem interaktif (seperti desktop PC atau
sistem laptop), lebih penting untuk meminimalkan varians dalam waktu respons daripada
meminimalkan waktu respons rata-rata. Sistem dengan waktu respons yang masuk akal
dan dapat diprediksi dapat dianggap lebih diinginkan daripada sistem yang rata-rata lebih
cepat tetapi sangat bervariasi. Namun, sedikit pekerjaan yang telah dilakukan pada
algoritma penjadwalan CPU yang meminimalkan varians.
Saat kami membahas berbagai algoritma penjadwalan CPU di bagian berikut, kami
mengilustrasikan operasinya. Sebuah ilustrasi yang akurat harus melibatkan banyak proses,
masing-masing urutan beberapa ratus CPU burst dan I/O burst.
Untuk kesederhanaan, kami mempertimbangkan hanya satu CPU burst (dalam milidetik)
per proses dalam contoh kami. Ukuran perbandingan kami adalah waktu tunggu rata-rata.
Mekanisme evaluasi yang lebih rumit dibahas dalam Bagian 5.8.
5.3 Algoritma Penjadwalan

Penjadwalan CPU berkaitan dengan masalah memutuskan proses mana dalam antrian
siap yang akan dialokasikan ke inti CPU . Ada banyak algoritma penjadwalan CPU yang
berbeda. Pada bagian ini, kami menjelaskan beberapa di antaranya. Meskipun sebagian
besar arsitektur CPU modern memiliki beberapa inti pemrosesan, kami menjelaskan
algoritme penjadwalan ini dalam konteks hanya satu inti pemrosesan yang tersedia. Artinya,
satu CPU yang memiliki inti pemrosesan tunggal, sehingga sistemnya
hanya mampu menjalankan satu proses pada satu waktu. Di Bagian 5.5 kita membahas CPU
penjadwalan dalam konteks sistem multiprosesor.
5.3.1 Penjadwalan First-Come, First-Served

Sejauh ini algoritma penjadwalan CPU yang paling sederhana adalah first-come first-serve
(FCFS) algoritma penjadwalan. Dengan skema ini, proses yang meminta
CPU terlebih dahulu dialokasikan CPU terlebih dahulu. Implementasi kebijakan FCFS adalah
mudah dikelola dengan antrian FIFO . Ketika sebuah proses memasuki antrian siap,
PCB terhubung ke ekor antrian. Ketika CPU bebas, itu dialokasikan untuk
proses di kepala antrian. Proses yang berjalan kemudian dihapus dari
antrian. Kode untuk penjadwalan FCFS mudah ditulis dan dipahami.
Di sisi negatif, waktu tunggu rata-rata di bawah kebijakan FCFS adalah
seringkali cukup lama. Pertimbangkan rangkaian proses berikut yang tiba pada waktu 0,
dengan panjang CPU burst yang diberikan dalam milidetik:
Proses Waktu Meledak
P1 24
P2 3
P3 3
Jika proses tiba dalam urutan P1, P2, P3, dan dilayani dalam urutan FCFS ,
kita mendapatkan hasil yang ditunjukkan pada bagan Gantt berikut, yang merupakan bagan batang yang
menggambarkan jadwal tertentu, termasuk waktu mulai dan selesai masing-masing
proses yang berpartisipasi:
P1 P2 P3
0 24 27 30
Waktu tunggu adalah 0 milidetik untuk proses P1, 24 milidetik untuk proses
P2, dan 27 milidetik untuk proses P3. Jadi, waktu tunggu rata-rata adalah (0
+ 24 + 27)/3 = 17 milidetik. Jika proses tiba dalam urutan P2, P3, P1,
namun, hasilnya akan seperti yang ditunjukkan pada bagan Gantt berikut:
P2 P3 P1
036 30
Waktu tunggu rata-rata sekarang (6 + 0 + 3)/3 = 3 milidetik. Pengurangan ini

substansial. Dengan demikian, waktu tunggu rata-rata di bawah kebijakan FCFS umumnya
tidak minimal dan dapat bervariasi secara substansial jika waktu burst CPU proses bervariasi
sangat.
Selain itu, pertimbangkan kinerja penjadwalan FCFS secara dinamis
situasi. Asumsikan kita memiliki satu proses terikat-CPU dan banyak proses terikat- I/O.
Saat proses mengalir di sekitar sistem, skenario berikut mungkin:
hasil. Proses terikat CPU akan mendapatkan dan menahan CPU. Selama ini, semua
proses lain akan menyelesaikan I/O mereka dan akan pindah ke antrian siap,
menunggu CPU-nya. Sementara proses menunggu dalam antrian siap, I/O
perangkat menganggur. Akhirnya, proses terikat-CPU menyelesaikan ledakan CPU -nya dan
berpindah ke perangkat I/O . Semua proses yang terikat I/O, yang memiliki CPU pendek
meledak, mengeksekusi dengan cepat dan kembali ke antrian I/O . Pada titik ini,
CPU duduk diam. Proses terikat CPU kemudian akan kembali ke antrian siap
dan dialokasikan CPU. Sekali lagi, semua proses I/O berakhir menunggu di
ready queue sampai proses CPU-bound selesai. Ada efek konvoi sebagai
semua proses lainnya menunggu satu proses besar keluar dari CPU. Efek ini
menghasilkan penggunaan CPU dan perangkat yang lebih rendah daripada yang mungkin jika lebih pendek
proses diizinkan untuk pergi lebih dulu.
Perhatikan juga bahwa algoritma penjadwalan FCFS adalah nonpreemptive. sekali
CPU telah dialokasikan ke suatu proses, proses itu menjaga CPU sampai dilepaskan
CPU, baik dengan mengakhiri atau dengan meminta I/O. Algoritma FCFS dengan demikian
sangat merepotkan untuk sistem interaktif, di mana penting bahwa
setiap proses mendapatkan bagian dari CPU secara berkala. Itu akan menjadi bencana
untuk memungkinkan satu proses untuk menjaga CPU untuk waktu yang lama.
5.3.2 Penjadwalan Terpendek-Pekerjaan-Pertama
Pendekatan yang berbeda untuk penjadwalan CPU adalah algoritma penjadwalan shortest-job-firs
(SJF) . Algoritma ini mengasosiasikan dengan setiap proses panjang
CPU burst berikutnya dari proses . Ketika CPU tersedia, itu ditugaskan ke proses
yang memiliki CPU burst terkecil berikutnya . Jika CPU berikutnya meledak dari dua proses adalah
sama, penjadwalan FCFS digunakan untuk memutuskan hubungan. Perhatikan bahwa istilah yang
lebih tepat untuk metode penjadwalan ini adalah ledakan CPU-berikutnya yang terpendek
algoritma, karena penjadwalan tergantung pada panjang CPU burst berikutnya
sebuah proses, bukan panjang totalnya. Kami menggunakan istilah SJF karena kebanyakan orang
dan buku teks menggunakan istilah ini untuk merujuk pada jenis penjadwalan ini.
Sebagai contoh penjadwalan SJF , pertimbangkan rangkaian proses berikut,
dengan panjang CPU burst yang diberikan dalam milidetik:
P1 6
P2 8
P3 7
P4 3
Menggunakan penjadwalan SJF , kami akan menjadwalkan proses ini sesuai dengan:
berikut Gantt chart:
P4 P1 P3 P2
0 3 9 16 24
P2, 9 milidetik untuk proses P3, dan 0 milidetik untuk proses P4. Dengan demikian,
waktu tunggu rata-rata adalah (3 + 16 + 9 + 0)/4 = 7 milidetik. Sebagai perbandingan, jika
kami menggunakan skema penjadwalan FCFS , waktu tunggu rata-rata akan
menjadi 10,25 milidetik.
Algoritma penjadwalan SJF terbukti optimal, karena memberikan waktu tunggu rata-rata
minimum untuk serangkaian proses tertentu. Memindahkan proses singkat
sebelum yang lama mengurangi waktu tunggu dari proses yang pendek lebih dari
itu meningkatkan waktu tunggu dari proses yang panjang. Akibatnya, rata-rata
waktu tunggu berkurang.
Meskipun algoritma SJF optimal, namun tidak dapat diimplementasikan pada level
penjadwalan CPU , karena tidak ada cara untuk mengetahui panjang CPU burst berikutnya.
Salah satu pendekatan untuk masalah ini adalah mencoba memperkirakan penjadwalan SJF . Kita boleh
tidak tahu berapa lama CPU burst berikutnya, tapi kami mungkin bisa memprediksinya
nilai. Kami berharap ledakan CPU berikutnya akan sama panjangnya dengan yang sebelumnya
yang. Dengan menghitung perkiraan panjang CPU burst berikutnya, kami
dapat memilih proses dengan prediksi CPU burst terpendek.
Ledakan CPU berikutnya umumnya diprediksi sebagai rata- rata eksponensial dari
panjang terukur dari CPU burst sebelumnya. Kita dapat mendefinisikan eksponensial
rata-rata dengan rumus berikut. Biarkan tn menjadi panjang CPU burst ke- n ,
dan biarkan n+1 menjadi nilai prediksi kami untuk CPU burst berikutnya. Maka, untuk , 0
1, tentukan
n+1 = tn + (1 )ÿn.
Nilai tn berisi informasi terbaru kami, sementara n menyimpan masa lalu

sejarah. Parameter mengontrol bobot relatif dari sejarah baru-baru ini dan masa lalu
dalam prediksi kami. Jika = 0, maka n+1 = n, dan riwayat terkini tidak berpengaruh
(kondisi saat ini diasumsikan bersifat sementara). Jika = 1, maka n+1 = tn, dan
hanya masalah ledakan CPU terbaru (sejarah dianggap sudah tua dan
tidak relevan). Lebih umum, = 1/2, jadi sejarah terkini dan sejarah masa lalu adalah
berbobot sama. Awal 0 dapat didefinisikan sebagai konstanta atau sebagai keseluruhan
rata-rata sistem. Gambar 5.4 menunjukkan rata-rata eksponensial dengan = 1/2 dan
0 = 10.
12
i 10
dari 6
waktu
CPU meledak (ti ) 6 4 6 4 13 13 13 …
"tebak" (ÿi ) 10 8 6 6 5 9 11 12 …
Gambar 5.4 Prediksi panjang CPU burst berikutnya.
Untuk memahami perilaku rata-rata eksponensial, kita dapat memperluas

rumus untuk n+1 dengan mengganti n untuk menemukan
j n+1
n+1 = tn + (1 )ÿtnÿ1 +···+ (1 ) tnÿj +···+ (1 ) t0.
Biasanya, kurang dari 1. Akibatnya, (1 ) juga lebih kecil dari 1, dan masing-masing
istilah berturut-turut memiliki bobot kurang dari pendahulunya.
Algoritma SJF dapat berupa preemptive atau nonpreemptive. Pilihan
muncul ketika proses baru tiba di antrian siap saat proses sebelumnya masih dijalankan. Ledakan
CPU berikutnya dari proses yang baru tiba mungkin
lebih pendek dari apa yang tersisa dari proses yang sedang dijalankan. Sebuah pencegahan
Algoritma SJF akan mendahului proses yang sedang dieksekusi, sedangkan algoritma SJF non-preemptive
akan mengizinkan proses yang sedang berjalan untuk menyelesaikannya.
CPU meledak. Penjadwalan SJF preemptive kadang-kadang disebut penjadwalan waktu-pertama
terpendek .
Sebagai contoh, perhatikan empat proses berikut, dengan panjang
CPU burst diberikan dalam milidetik :
Proses Jam kedatangan Waktu Meledak
0 8
P1
1 4
P2
2 9
P3
3 5
P4
Jika proses tiba di antrian siap pada waktu yang ditunjukkan dan membutuhkan
menunjukkan waktu burst, maka jadwal SJF preemptive yang dihasilkan adalah seperti yang digambarkan
dalam Gantt chart berikut:
P1 P2 P4 P1 P3
01 5 10 17 26
Proses P1 dimulai pada waktu 0, karena ini adalah satu-satunya proses dalam antrian. Proses
P2 tiba pada waktu 1. Waktu yang tersisa untuk proses P1 (7 milidetik) adalah
lebih besar dari waktu yang dibutuhkan oleh proses P2 (4 milidetik), sehingga proses P1 adalah
didahulukan, dan proses P2 dijadwalkan. Waktu tunggu rata-rata untuk ini
contohnya adalah [(10 1) + (1 1) + (17 2) + (5 3)]/4 = 26/4 = 6,5 milidetik.
Penjadwalan SJF nonpreemptive akan menghasilkan waktu tunggu rata-rata 7,75
milidetik.
5.3.3 Penjadwalan Round-Robin

Algoritma penjadwalan round-robin (RR) mirip dengan penjadwalan FCFS , tetapi
preemption ditambahkan untuk memungkinkan sistem beralih di antara proses. Kecil
satuan waktu, yang disebut kuantum waktu atau irisan waktu, didefinisikan. Sebuah kuantum waktu
umumnya dari 10 sampai 100 milidetik panjangnya. Antrian siap diperlakukan sebagai
antrian melingkar. Penjadwal CPU berjalan di sekitar antrian siap, mengalokasikan
CPU untuk setiap proses untuk interval waktu hingga 1 kali kuantum.
Untuk mengimplementasikan penjadwalan RR , kita kembali memperlakukan antrian siap sebagai FIFO
antrian proses. Proses baru ditambahkan ke ekor antrian siap.
Penjadwal CPU memilih proses pertama dari antrian siap, mengatur timer ke
interupsi setelah 1 kali kuantum, dan mengirimkan proses.
Satu dari dua hal kemudian akan terjadi. Proses mungkin memiliki CPU burst dari
kurang dari 1 kali kuantum. Dalam hal ini, proses itu sendiri akan melepaskan CPU
secara sukarela. Penjadwal kemudian akan melanjutkan ke proses selanjutnya dalam ready
antre. Jika CPU burst dari proses yang sedang berjalan lebih dari 1 kali
kuantum, pengatur waktu akan mati dan akan menyebabkan gangguan pada operasi
sistem. Sakelar konteks akan dijalankan, dan prosesnya akan diletakkan di
ekor antrian siap. Penjadwal CPU kemudian akan memilih proses selanjutnya di
antrian siap.
Rata-rata waktu tunggu di bawah kebijakan RR seringkali lama. Pertimbangkan
rangkaian proses berikut yang tiba pada waktu 0, dengan panjang CPU burst
diberikan dalam milidetik:
P1 24
P2 3
P3 3
Jika kita menggunakan kuantum waktu 4 milidetik, maka proses P1 mendapat 4 . pertama
milidetik. Karena membutuhkan 20 milidetik lagi, itu didahului setelah
kuantum pertama kali, dan CPU diberikan ke proses berikutnya dalam antrian,
proses P2. Proses P2 tidak membutuhkan 4 milidetik, sehingga berhenti sebelum waktunya
kuantum berakhir. CPU kemudian diberikan ke proses selanjutnya, proses P3. Satu kali
setiap proses telah menerima 1 kali kuantum, CPU dikembalikan ke proses P1
untuk kuantum waktu tambahan. Jadwal RR yang dihasilkan adalah sebagai berikut:
P1 P2 P3 P1 P1 P1 P1 P1
0 4 7 10 14 18 22 26 30
Mari kita hitung waktu tunggu rata-rata untuk jadwal ini. P1 menunggu selama 6 milidetik (10 4),
P2 menunggu selama 4 milidetik, dan P3 menunggu selama 7 milidetik.
Jadi, waktu tunggu rata-rata adalah 17/3 = 5,66 milidetik.
Dalam algoritma penjadwalan RR , tidak ada proses yang mengalokasikan CPU lebih banyak
dari 1 kali kuantum berturut-turut (kecuali itu adalah satu-satunya proses yang dapat dijalankan). Jika sebuah
CPU burst proses melebihi 1 kali kuantum, proses itu didahulukan dan adalah
dimasukkan kembali ke dalam antrian siap. Algoritma penjadwalan RR dengan demikian bersifat preemptive.
Jika ada n proses dalam antrian ready dan kuantum waktunya adalah q, maka
setiap proses mendapat 1/n waktu CPU dalam potongan paling banyak q unit waktu. Setiap
proses harus menunggu tidak lebih lama dari (n 1) × q unit waktu sampai waktu kuantum
berikutnya. Misalnya, dengan lima proses dan kuantum waktu 20 milidetik,
setiap proses akan mendapatkan hingga 20 milidetik setiap 100 milidetik.
Kinerja algoritma RR sangat bergantung pada ukuran
kuantum waktu. Pada satu ekstrem, jika kuantum waktu sangat besar,
Kebijakan RR sama dengan kebijakan FCFS . Sebaliknya, jika kuantum waktu adalah
sangat kecil (katakanlah, 1 milidetik), pendekatan RR dapat menghasilkan
waktu proses = 10 kuantum konteks

sakelar
12 0
0 10
6 1
0 10
6
1 9
01 2 3 4 5 6 7 8 9 10
Gambar 5.5 Bagaimana kuantum waktu yang lebih kecil meningkatkan sakelar konteks.
jumlah sakelar konteks. Asumsikan, misalnya, bahwa kita hanya memiliki satu
proses 10 satuan waktu. Jika kuantum adalah 12 satuan waktu, proses selesai
dalam kuantum waktu kurang dari 1, tanpa overhead. Jika kuantum adalah 6 satuan waktu,
namun, prosesnya membutuhkan 2 kuanta, yang menghasilkan sakelar konteks. jika
kuantum waktu adalah 1 unit waktu, maka sembilan sakelar konteks akan terjadi, memperlambat
pelaksanaan proses yang sesuai (Gambar 5.5).
Jadi, kami ingin kuantum waktu menjadi besar sehubungan dengan waktu sakelar konteks.
Jika waktu sakelar konteks kira-kira 10 persen dari
kuantum waktu, maka sekitar 10 persen dari waktu CPU akan dihabiskan dalam konteks
beralih. Dalam praktiknya, sebagian besar sistem modern memiliki kuanta waktu mulai dari
10 hingga 100 milidetik. Waktu yang diperlukan untuk sakelar konteks biasanya lebih sedikit
dari 10 mikrodetik; dengan demikian, waktu sakelar konteks adalah sebagian kecil dari
takut berapa
Waktu penyelesaian juga tergantung pada ukuran kuantum waktu. Seperti yang kita
dapat dilihat dari Gambar 5.6, waktu penyelesaian rata-rata dari serangkaian proses
tidak selalu meningkat seiring dengan bertambahnya ukuran kuantum waktu. Secara umum,
waktu penyelesaian rata-rata dapat ditingkatkan jika sebagian besar proses menyelesaikannya
CPU berikutnya meledak dalam kuantum waktu tunggal. Misalnya, diberikan tiga proses
dari 10 unit waktu masing-masing dan kuantum 1 unit waktu, perputaran rata-rata
waktu adalah 29. Jika kuantum waktu adalah 10, bagaimanapun, waktu penyelesaian rata-rata
turun menjadi 20. Jika waktu sakelar konteks ditambahkan, waktu penyelesaian rata-rata
meningkat bahkan lebih untuk kuantum waktu yang lebih kecil, karena lebih banyak konteks beralih
diperlukan.
Meskipun kuantum waktu harus besar dibandingkan dengan waktu sakelar konteks, itu tidak
boleh terlalu besar. Seperti yang kami tunjukkan sebelumnya, jika waktunya
kuantum terlalu besar, penjadwalan RR merosot ke kebijakan FCFS . Aturan dari
jempol adalah bahwa 80 persen dari ledakan CPU harus lebih pendek dari waktu
kuantum.
5.3.4 Penjadwalan Prioritas

Algoritma SJF adalah kasus khusus dari algoritma penjadwalan prioritas umum.
Prioritas dikaitkan dengan setiap proses, dan CPU dialokasikan ke
waktu proses
12.5
P1 6
12.0 P2 3
P3 1
11.5 P4 7
11.0
penyelesaian
waktu
rata-
rata
10.5
10.0
9.5
9.0
1 234 567
takut berapa
Gambar 5.6 Bagaimana waktu penyelesaian bervariasi dengan kuantum waktu.
proses dengan prioritas tertinggi. Proses dengan prioritas yang sama dijadwalkan dalam
pesanan FCFS . Sebuah algoritma SJF hanyalah sebuah algoritma prioritas dimana prioritas
(p) adalah kebalikan dari (diprediksi) CPU burst berikutnya. Semakin besar CPU burst,
semakin rendah prioritasnya, dan sebaliknya.
Perhatikan bahwa kita membahas penjadwalan dalam hal prioritas tinggi dan prioritas rendah .
Prioritas umumnya ditunjukkan oleh beberapa rentang angka tetap, seperti 0
sampai 7 atau 0 sampai 4.095. Namun, tidak ada kesepakatan umum tentang apakah 0 adalah
prioritas tertinggi atau terendah. Beberapa sistem menggunakan angka rendah untuk mewakili angka rendah
prioritas; yang lain menggunakan angka rendah untuk prioritas tinggi. Perbedaan ini dapat menyebabkan
kebingungan. Dalam teks ini, kami berasumsi bahwa angka rendah mewakili prioritas tinggi.
Sebagai contoh, pertimbangkan rangkaian proses berikut, yang diasumsikan memiliki:
tiba pada waktu 0 dengan urutan P1, P2, ···, P5, dengan panjang CPU burst
Proses Waktu Meledak Prioritas

P1 10 3
P2 1 1
P3 2 4
P4 1 5
P5 5 2
Menggunakan penjadwalan prioritas, kami akan menjadwalkan proses ini sesuai dengan
berikut Gantt chart:
P2 P5 P1 P4 P3
01 6 16 1918
Waktu tunggu rata-rata adalah 8,2 milidetik.

Prioritas dapat ditentukan baik secara internal maupun eksternal. Didefinisikan secara internal
prioritas menggunakan beberapa kuantitas atau kuantitas terukur untuk menghitung prioritas
dari sebuah proses. Misalnya, batas waktu, kebutuhan memori, jumlah
membuka file, dan rasio rata-rata ledakan I/O terhadap ledakan CPU rata-rata telah
digunakan dalam komputasi prioritas. Prioritas eksternal ditetapkan oleh kriteria di luar
sistem operasi, seperti pentingnya proses, jenis dan jumlah
dana yang dibayarkan untuk penggunaan komputer, departemen yang mensponsori pekerjaan,
dan faktor lainnya, seringkali politik.
Penjadwalan prioritas dapat berupa preemptive atau nonpreemptive. Ketika sebuah
proses tiba di antrian siap, prioritasnya dibandingkan dengan prioritas
proses yang sedang berjalan. Sebuah algoritma penjadwalan prioritas preemptive akan
mendahului CPU jika prioritas proses yang baru tiba lebih tinggi dari
prioritas proses yang sedang berjalan. Penjadwalan prioritas nonpreemptive
algoritma hanya akan menempatkan proses baru di kepala antrian siap.
Masalah utama dengan algoritma penjadwalan prioritas adalah pemblokiran tidak terbatas,
atau kelaparan. Proses yang siap dijalankan tetapi menunggu CPU dapat
dianggap diblokir. Algoritme penjadwalan prioritas dapat membuat beberapa proses dengan prioritas
rendah menunggu tanpa batas waktu. Dalam sistem komputer yang sarat muatan, a
aliran stabil dari proses dengan prioritas lebih tinggi dapat mencegah proses dengan prioritas rendah
dari pernah mendapatkan CPU. Umumnya, satu dari dua hal akan terjadi. Salah satu
proses akhirnya akan dijalankan (jam 2 pagi hari Minggu, ketika sistem akhirnya
dimuat dengan ringan), atau sistem komputer pada akhirnya akan macet dan kehilangan semua
proses prioritas rendah yang belum selesai. (Rumor mengatakan bahwa ketika mereka mematikan IBM
7094 di MIT pada tahun 1973, mereka menemukan proses dengan prioritas rendah yang telah diajukan
pada tahun 1967 dan belum dijalankan.)
Solusi untuk masalah penyumbatan tak terbatas dari proses berprioritas rendah adalah
penuaan. Penuaan melibatkan secara bertahap meningkatkan prioritas proses yang menunggu
dalam sistem untuk waktu yang lama. Misalnya, jika prioritas berkisar dari 127 (rendah)
ke 0 (tinggi), kita dapat secara berkala (katakanlah, setiap detik) meningkatkan prioritas
proses menunggu dengan 1. Akhirnya, bahkan proses dengan prioritas awal
127 akan memiliki prioritas tertinggi dalam sistem dan akan dieksekusi. Di
faktanya, dibutuhkan lebih dari 2 menit untuk proses prioritas-127 untuk menua menjadi a
proses prioritas-0.
Pilihan lain adalah menggabungkan round-robin dan penjadwalan prioritas sedemikian rupa
cara sistem mengeksekusi proses dengan prioritas tertinggi dan menjalankan proses
dengan prioritas yang sama menggunakan penjadwalan round-robin. Mari kita ilustrasikan dengan
contoh menggunakan rangkaian proses berikut, dengan waktu burst dalam milidetik:

P1 4 3
P2 5 2
P3 8 2
P4 7 1
P5 3 3
Menggunakan penjadwalan prioritas dengan round-robin untuk proses dengan prioritas yang sama,
kami akan menjadwalkan proses ini sesuai dengan bagan Gantt berikut:
menggunakan kuantum waktu 2 milidetik:
P4 P2 P3 P2 P3 P2 P3 P1 P5 P1 P5
0 7 9 11 13 15 16 20 22 24 26 27
Dalam contoh ini, proses P4 memiliki prioritas tertinggi, sehingga akan berjalan hingga selesai.
Proses P2 dan P3 memiliki prioritas tertinggi berikutnya, dan mereka akan dieksekusi dalam
mode round-robin. Perhatikan bahwa ketika proses P2 selesai pada waktu 16, proses
P3 adalah proses dengan prioritas tertinggi, sehingga akan berjalan sampai selesai dieksekusi.
Sekarang, hanya proses P1 dan P5 yang tersisa, dan karena mereka memiliki prioritas yang sama, mereka
akan mengeksekusi dalam urutan round-robin sampai mereka selesai.
5.3.5 Penjadwalan Antrian Bertingkat

Dengan penjadwalan prioritas dan round-robin, semua proses dapat ditempatkan
dalam satu antrian, dan penjadwal kemudian memilih proses dengan yang tertinggi
prioritas untuk dijalankan. Bergantung pada bagaimana antrian dikelola, pencarian O(n)
mungkin diperlukan untuk menentukan proses dengan prioritas tertinggi. Dalam prakteknya adalah
seringkali lebih mudah untuk memiliki antrian terpisah untuk setiap prioritas dan prioritas yang berbeda
penjadwalan hanya menjadwalkan proses dalam antrian dengan prioritas tertinggi. Ini
diilustrasikan pada Gambar 5.7. Pendekatan ini—dikenal sebagai antrian bertingkat—
juga bekerja dengan baik ketika penjadwalan prioritas digabungkan dengan round-robin: if
ada beberapa proses dalam antrian prioritas tertinggi, mereka dieksekusi di
urutan round-robin. Dalam bentuk paling umum dari pendekatan ini, prioritasnya adalah
ditugaskan secara statis untuk setiap proses, dan sebuah proses tetap berada dalam antrian yang sama
selama runtime-nya.
prioritas = 0 T0 T1 T2 T3 T4
prioritas = 1 T5 T6 T7
prioritas = 2 Q8 T9 T10 T11
prioritas = n terima kasih

Ty Tzo
Gambar 5.7 Antrian terpisah untuk setiap prioritas.

prioritas utama
proses waktu nyata
proses sistem
proses interaktif
proses batch
prioritas terendah
Gambar 5.8 Penjadwalan antrian bertingkat.
Algoritme penjadwalan antrian bertingkat juga dapat digunakan untuk mempartisi

proses menjadi beberapa antrian terpisah berdasarkan jenis proses (Gambar 5.8).
Misalnya, pembagian umum dibuat antara proses latar depan (interaktif) dan proses
latar belakang (batch). Kedua jenis proses ini memiliki persyaratan waktu respons
yang berbeda sehingga mungkin memiliki kebutuhan penjadwalan yang berbeda.
Selain itu, proses latar depan mungkin memiliki prioritas (didefinisikan secara eksternal)
di atas proses latar belakang. Antrian terpisah dapat digunakan untuk proses latar
depan dan latar belakang, dan setiap antrian mungkin memiliki algoritma
penjadwalannya sendiri. Antrian latar depan mungkin dijadwalkan oleh algoritma RR ,
misalnya, sedangkan antrian latar belakang dijadwalkan oleh algoritma FCFS .
Selain itu, harus ada penjadwalan antar antrian, yang umumnya diimplementasikan
sebagai penjadwalan preemptive prioritas tetap. Misalnya, antrian real-time mungkin
memiliki prioritas mutlak atas antrian interaktif.
Mari kita lihat contoh algoritma penjadwalan antrian bertingkat dengan empat
antrian, tercantum di bawah ini dalam urutan prioritas:
1. Proses waktu nyata 2.
Proses sistem 3. Proses
interaktif 4. Proses batch
Setiap antrian memiliki prioritas mutlak atas antrian dengan prioritas lebih rendah.
Tidak ada proses dalam antrian batch, misalnya, yang dapat berjalan kecuali antrian
untuk proses waktu nyata, proses sistem, dan proses interaktif semuanya kosong. Jika
proses interaktif memasuki antrian siap saat proses batch sedang berjalan, proses
batch akan didahulukan.
Kemungkinan lain adalah membagi waktu di antara antrian. Di sini, setiap antrian
mendapatkan bagian tertentu dari waktu CPU , yang kemudian dapat dijadwalkan di
antara berbagai prosesnya. Misalnya, dalam contoh antrian latar depan – latar
belakang, antrian latar depan dapat diberikan 80 persen dari waktu CPU untuk penjadwala
di antara proses-prosesnya, sedangkan antrian latar belakang menerima 20 persen CPU untuk
diberikan kepada proses-prosesnya berdasarkan FCFS .
5.3.6 Penjadwalan Antrian Umpan Balik Bertingkat

Biasanya, ketika algoritma penjadwalan antrian bertingkat digunakan, proses secara permanen
ditugaskan ke antrian ketika mereka memasuki sistem. Jika ada antrian terpisah untuk proses
latar depan dan latar belakang, misalnya, proses tidak berpindah dari satu antrian ke antrian
lainnya, karena proses tidak mengubah sifat latar depan atau latar belakangnya. Pengaturan ini
memiliki keuntungan dari overhead penjadwalan yang rendah, tetapi tidak fleksibel.
Algoritma penjadwalan antrian umpan balik bertingkat , sebaliknya, memungkinkan suatu

proses untuk berpindah antar antrian. Idenya adalah untuk memisahkan proses sesuai dengan
karakteristik semburan CPU mereka. Jika suatu proses menggunakan terlalu banyak waktu CPU ,
proses tersebut akan dipindahkan ke antrian dengan prioritas lebih rendah. Skema ini
meninggalkan I/O-bound dan proses interaktif—yang biasanya ditandai dengan CPU burst singkat
—dalam antrian dengan prioritas lebih tinggi. Selain itu, proses yang menunggu terlalu lama
dalam antrian dengan prioritas lebih rendah dapat dipindahkan ke antrian dengan prioritas yang
lebih tinggi. Bentuk penuaan ini mencegah kelaparan.
Misalnya, pertimbangkan penjadwal antrian umpan balik bertingkat dengan tiga antrian,
diberi nomor dari 0 hingga 2 (Gambar 5.9). Scheduler terlebih dahulu mengeksekusi semua
proses dalam antrian 0. Hanya ketika antrian 0 kosong maka akan mengeksekusi proses dalam
antrian 1. Demikian pula, proses dalam antrian 2 akan dieksekusi hanya jika antrian 0 dan 1
kosong. Sebuah proses yang datang untuk antrian 1 akan mendahului proses dalam antrian 2.
Sebuah proses dalam antrian 1 pada gilirannya akan didahului oleh proses yang datang untuk
antrian 0.
Sebuah proses yang masuk dimasukkan ke dalam antrian 0. Sebuah proses dalam antrian
0 diberikan kuantum waktu 8 milidetik. Jika tidak selesai dalam waktu ini, maka akan dipindahkan
ke ekor antrian 1. Jika antrian 0 kosong, proses di kepala antrian 1 diberikan kuantum 16 milidetik.
Jika tidak selesai, akan di-preempt dan dimasukkan ke dalam antrian 2. Proses dalam antrian 2
dijalankan pada basis FCFS tetapi dijalankan hanya ketika antrian 0 dan 1 kosong. Untuk
mencegah kelaparan, proses yang menunggu terlalu lama dalam antrian dengan prioritas lebih
rendah dapat secara bertahap dipindahkan ke antrian dengan prioritas yang lebih tinggi.
kuantum = 8
kuantum = 16
FCFS
Gambar 5.9 Antrian umpan balik bertingkat.

5.4 Penjadwalan Utas 217
Algoritma penjadwalan ini memberikan prioritas tertinggi untuk setiap proses dengan CPU
ledakan 8 milidetik atau kurang. Proses seperti itu akan cepat mendapatkan CPU, selesai
CPU -nya meledak, dan beralih ke ledakan I/O berikutnya . Proses yang membutuhkan lebih dari
8 tetapi kurang dari 24 milidetik juga disajikan dengan cepat, meskipun dengan lebih rendah
prioritas daripada proses yang lebih pendek. Proses panjang secara otomatis tenggelam ke antrian
2 dan disajikan dalam urutan FCFS dengan siklus CPU yang tersisa dari antrian 0
dan 1.
Secara umum, penjadwal antrian umpan balik multilevel ditentukan oleh parameter berikut:
• Jumlah antrian
• Algoritma penjadwalan untuk setiap antrian
• Metode yang digunakan untuk menentukan kapan harus mengupgrade proses ke yang lebih tinggi
antrian prioritas
• Metode yang digunakan untuk menentukan kapan menurunkan suatu proses ke yang lebih rendah
antrian prioritas
• Metode yang digunakan untuk menentukan antrian mana yang akan dimasuki suatu proses saat itu
proses membutuhkan layanan
Definisi penjadwal antrian umpan balik multilevel menjadikannya yang terbaik

algoritma penjadwalan CPU umum . Hal ini dapat dikonfigurasi untuk mencocokkan tertentu
sistem di bawah desain. Sayangnya, ini juga merupakan algoritma yang paling kompleks,
karena mendefinisikan penjadwal terbaik memerlukan beberapa cara untuk memilih nilai
untuk semua parameter.
5.4 Penjadwalan Utas

Di Bab 4, kami memperkenalkan utas ke model proses, membedakan
antara utas tingkat pengguna dan tingkat kernel . Pada sebagian besar sistem operasi modern, utas
tingkat kernel—bukan proses— yang dijadwalkan oleh
sistem operasi. Utas tingkat pengguna dikelola oleh pustaka utas, dan
kernel tidak menyadarinya. Untuk berjalan pada CPU, utas tingkat pengguna pada akhirnya harus
dipetakan ke utas tingkat kernel terkait, meskipun pemetaan ini
mungkin tidak langsung dan dapat menggunakan proses ringan (LWP). Di bagian ini, kita
jelajahi masalah penjadwalan yang melibatkan utas tingkat pengguna dan tingkat kernel dan
menawarkan contoh spesifik penjadwalan untuk Pthreads.
5.4.1 Lingkup Perdebatan

Satu perbedaan antara utas tingkat pengguna dan tingkat kernel terletak pada bagaimana mereka
dijadwalkan. Pada sistem yang menerapkan banyak-ke-satu (Bagian 4.3.1)
dan model banyak-ke-banyak (Bagian 4.3.3), pustaka utas menjadwalkan utas tingkat pengguna
untuk dijalankan pada LWP yang tersedia. Skema ini dikenal sebagai process contention scope
(PCS), karena persaingan untuk CPU terjadi di antara
utas milik proses yang sama. (Ketika kami mengatakan bahwa pustaka utas menjadwalkan utas
pengguna ke LWP yang tersedia, kami tidak bermaksud bahwa utas tersebut
benar -benar berjalan pada CPU karena lebih lanjut membutuhkan sistem operasi untuk
jadwalkan utas kernel LWP ke inti CPU fisik .) Untuk memutuskan mana
utas tingkat kernel untuk menjadwalkan ke CPU, kernel menggunakan cakupan sistem-
pertentangan (SCS). Persaingan untuk CPU dengan penjadwalan SCS terjadi di antara
semua utas dalam sistem. Sistem yang menggunakan model satu-ke-satu (Bagian 4.3.2),
seperti Windows dan Linux menjadwalkan utas hanya menggunakan SCS.
Biasanya, PCS dilakukan berdasarkan prioritas—penjadwal memilih thread yang dapat
dijalankan dengan prioritas tertinggi untuk dijalankan. Prioritas utas tingkat pengguna
ditetapkan oleh pemrogram dan tidak disesuaikan oleh pustaka utas, meskipun beberapa
pustaka utas memungkinkan pemrogram untuk mengubah prioritas utas. Penting untuk
dicatat bahwa PCS biasanya akan mendahului utas yang sedang berjalan demi utas dengan
prioritas lebih tinggi; namun, tidak ada jaminan untuk membagi waktu (Bagian 5.3.3) di
antara utas dengan prioritas yang sama.
5.4.2 Penjadwalan Pthread Kami
menyediakan contoh program POSIX Pthread di Bagian 4.4.1, bersama dengan pengenalan
pembuatan thread dengan Pthreads. Sekarang, kami menyoroti POSIX Pthread API yang
memungkinkan penentuan PCS atau SCS selama pembuatan thread. Pthreads
mengidentifikasi nilai-nilai cakupan pertentangan berikut:
• PTHREAD SCOPE PROCESS menjadwalkan thread menggunakan penjadwalan PCS .
• PTHREAD SCOPE SYSTEM menjadwalkan thread menggunakan penjadwalan SCS .
Pada sistem yang menerapkan model banyak-ke-banyak, kebijakan PROSES LINGKUP

PTHREAD menjadwalkan thread tingkat pengguna ke LWP yang tersedia . Jumlah LWP
dipertahankan oleh pustaka utas, mungkin menggunakan aktivasi penjadwal (Bagian 4.6.5).
Kebijakan penjadwalan SCOPE SCOPE PTHREAD akan membuat dan mengikat LWP
untuk setiap utas tingkat pengguna pada sistem banyak-ke-banyak, secara efektif memetakan
utas menggunakan kebijakan satu-ke-satu.
Pthread IPC (Interprocess Communication) menyediakan dua fungsi untuk:
pengaturan—dan mendapatkan— kebijakan ruang lingkup pertentangan:
• pthread attr setscope(attr pthread t *attr, int scope) • pthread attr

getscope(pthread attr t *attr, int *scope)
Parameter pertama untuk kedua fungsi berisi pointer ke set atribut untuk utas. Parameter
kedua untuk fungsi pthread attr setscope() dilewatkan baik PTHREAD SCOPE SYSTEM
atau nilai PTHREAD SCOPE PROCESS , yang menunjukkan bagaimana ruang lingkup
pertentangan harus ditetapkan. Dalam kasus pthread attr getscope(), parameter kedua ini
berisi penunjuk ke nilai int yang disetel ke nilai saat ini dari cakupan pertikaian. Jika terjadi
kesalahan, masing-masing fungsi ini mengembalikan nilai bukan nol.
Pada Gambar 5.10, kami mengilustrasikan API penjadwalan Pthread . Program

pertama-tama menentukan ruang lingkup pertentangan yang ada dan menetapkannya ke
SISTEM LINGKUP PTHREAD. Kemudian membuat lima utas terpisah yang akan berjalan
menggunakan kebijakan penjadwalan SCS . Perhatikan bahwa pada beberapa sistem,
hanya nilai ruang lingkup pertentangan tertentu yang diizinkan. Misalnya, sistem Linux dan
macOS hanya mengizinkan SISTEM LINGKUP PTHREAD.
5.4 Penjadwalan Utas 219
#include <pthread.h>
#include <stdio.h> #define
NUM THREADS 5
int main(int argc, char *argv[]) {
int i, ruang
lingkup; pthread t tid[NUM
THREADS]; pthread attr t attr;
/* mendapatkan atribut default */ pthread

attr init(&attr);
/* pertama-tama tanyakan pada lingkup saat ini */ if

(pthread attr getscope(&attr, &scope) != 0) fprintf(stderr,
"Tidak dapat mendapatkan lingkup penjadwalanÿn"); else { if (lingkup
== PROSES LINGKUP PTHREAD) printf("PROSES LINGKUP
PTHREAD"); else if (lingkup == PTHREAD SCOPE SYSTEM)
printf("SCOPE PTHREAD SCOPE"); else fprintf(stderr, "Nilai
cakupan ilegal.ÿn");
/* atur algoritma penjadwalan ke PCS atau SCS */ pthread attr

setscope(&attr, PTHREAD SCOPE SYSTEM);
/* buat utas */ for (i = 0; i < NUM

THREADS; i++) pthread
create(&tid[i],&attr,runner,NULL);
/* sekarang gabung di setiap utas */

for (i = 0; i < NUM THREADS; i++) pthread
join(tid[i], NULL);
}
/* Setiap thread akan memulai kontrol dalam fungsi ini */ void

*runner(void *param) {
/* lakukan beberapa pekerjaan ... */
pthread keluar(0);
}
Gambar 5.10 API penjadwalan Pthread.

5.5 Penjadwalan Multi-Prosesor
Diskusi kita sejauh ini berfokus pada masalah penjadwalan CPU dalam sistem dengan inti
pemrosesan tunggal. Jika beberapa CPU tersedia, berbagi beban, di mana beberapa utas dapat
berjalan secara paralel, menjadi mungkin, namun masalah penjadwalan menjadi lebih kompleks.
Banyak kemungkinan telah dicoba; dan seperti yang kita lihat dengan penjadwalan CPU dengan
CPU inti tunggal , tidak ada satu solusi terbaik.
Secara tradisional, istilah multiprosesor mengacu pada sistem yang menyediakan beberapa
prosesor fisik, di mana setiap prosesor berisi satu CPU inti tunggal. Namun, definisi multiprosesor
telah berkembang secara signifikan, dan pada sistem komputasi modern, multiprosesor sekarang
berlaku untuk arsitektur sistem berikut:
• CPU Multicore
• Inti multithreaded
• Sistem NUMA
• Multiprosesor heterogen
Di sini, kami membahas beberapa masalah dalam penjadwalan multiprosesor dalam konteks
arsitektur yang berbeda ini. Dalam tiga contoh pertama, kami berkonsentrasi pada sistem di mana
prosesornya identik—homogen—dalam hal fungsionalitasnya. Kami kemudian dapat menggunakan
CPU apa pun yang tersedia untuk menjalankan proses apa pun dalam antrian. Dalam contoh
terakhir kami mengeksplorasi sistem di mana prosesor tidak identik dalam kemampuannya.
5.5.1 Pendekatan Penjadwalan Multiprosesor Salah satu pendekatan penjadwalan
CPU dalam sistem multiprosesor memiliki semua keputusan penjadwalan, pemrosesan I/O , dan
aktivitas sistem lainnya yang ditangani oleh satu prosesor — server master. Prosesor lain hanya
mengeksekusi kode pengguna.
Multiprocessing asimetris ini sederhana karena hanya satu inti yang mengakses struktur data
sistem, sehingga mengurangi kebutuhan untuk berbagi data. Kelemahan dari pendekatan ini adalah
server master menjadi hambatan potensial di mana kinerja sistem secara keseluruhan dapat
dikurangi.
Pendekatan standar untuk mendukung multiprosesor adalah symmetric mul tiprocessing
(SMP), di mana setiap prosesor menjadwalkan sendiri. Penjadwalan berlangsung dengan meminta
penjadwal untuk setiap prosesor memeriksa antrian siap dan memilih utas untuk dijalankan.
Perhatikan bahwa ini memberikan dua kemungkinan strategi untuk mengatur rangkaian pesan
yang memenuhi syarat untuk dijadwalkan:
1. Semua utas mungkin berada dalam antrian siap yang umum.
2. Setiap prosesor mungkin memiliki antrian utas pribadinya sendiri.
Kedua strategi ini dikontraskan pada Gambar 5.11. Jika kami memilih opsi pertama, kami
memiliki kemungkinan kondisi balapan pada antrian siap pakai bersama dan oleh karena itu harus
memastikan bahwa dua prosesor terpisah tidak memilih untuk menjadwalkan utas yang sama dan
bahwa utas tidak hilang dari antrian. Seperti yang dibahas dalam
221
Machine Translated by Google 5.5 Penjadwalan Multi-Prosesor
T0
T1 T0
T0 T1 T2 ... Tn
T2 T0 T1
T3 T1 T2
inti0 inti1 ... inti inti0 inti1 inti ...

antrian siap umum (a) antrian run per-core
(b)
Gambar 5.11 Organisasi antrian siap pakai.
Bab 6, kita bisa menggunakan beberapa bentuk penguncian untuk melindungi antrian siap umum
dari kondisi balapan ini. Penguncian akan sangat ditentang, karena semua akses ke antrian akan
memerlukan kepemilikan kunci, dan mengakses antrian bersama kemungkinan akan menjadi
hambatan kinerja. Opsi kedua memungkinkan setiap prosesor untuk menjadwalkan utas dari
antrian proses pribadinya dan oleh karena itu tidak mengalami masalah kinerja yang mungkin
terkait dengan antrian proses bersama. Dengan demikian, ini adalah pendekatan yang paling
umum pada sistem yang mendukung SMP. Selain itu, seperti yang dijelaskan dalam Bagian 5.5.4,
memiliki antrian pribadi, per prosesor yang berjalan sebenarnya dapat menyebabkan penggunaan
memori cache yang lebih efisien.
Ada masalah dengan antrean yang dijalankan per prosesor—terutama, beban kerja dengan
berbagai ukuran. Namun, seperti yang akan kita lihat, algoritme penyeimbangan dapat digunakan
untuk menyamakan beban kerja di antara semua prosesor.
Hampir semua sistem operasi modern mendukung SMP, termasuk Windows, Linux, dan
macOS serta sistem seluler termasuk Android dan iOS. Di sisa bagian ini, kita membahas isu-isu
mengenai sistem SMP ketika merancang algoritma penjadwalan CPU .
5.5.2 Prosesor Multicore

Secara tradisional, sistem SMP memungkinkan beberapa proses berjalan secara paralel dengan
menyediakan beberapa prosesor fisik. Namun, sebagian besar perangkat keras komputer
kontemporer sekarang menempatkan beberapa core komputasi pada chip fisik yang sama,
menghasilkan prosesor multicore. Setiap inti mempertahankan status arsitekturnya dan dengan
demikian tampak bagi sistem operasi sebagai CPU logis yang terpisah.
Sistem SMP yang menggunakan prosesor multicore lebih cepat dan mengkonsumsi lebih sedikit
daya daripada sistem di mana setiap CPU memiliki chip fisiknya sendiri.
Prosesor multicore dapat memperumit masalah penjadwalan. Mari kita pertimbangkan
bagaimana ini bisa terjadi. Para peneliti telah menemukan bahwa ketika prosesor mengakses
memori, ia menghabiskan banyak waktu menunggu data tersedia. Situasi ini, yang dikenal sebagai
memory stall, terjadi terutama karena prosesor modern beroperasi pada kecepatan yang jauh
lebih cepat daripada memori. Namun, memory stall juga bisa terjadi karena cache miss (mengakses
data yang tidak ada di cache memory). Gambar 5.12 mengilustrasikan kios memori. Dalam
skenario ini, prosesor dapat menghabiskan hingga 50 persen waktunya menunggu data tersedia
dari memori.
C siklus komputasi M siklus memori terhenti
benang
C M CMC M cm
waktu
Gambar 5.12 Memori macet.
Untuk memperbaiki situasi ini, banyak desain perangkat keras baru-baru ini telah
mengimplementasikan inti pemrosesan multithreaded di mana dua (atau lebih) perangkat keras
utas ditugaskan ke setiap inti. Dengan begitu, jika satu utas perangkat keras terhenti saat
menunggu memori, inti dapat beralih ke utas lain. Gambar 5.13 mengilustrasikan inti
pemrosesan ulir ganda di mana eksekusi utas 0 dan
eksekusi utas 1 disisipkan. Dari perspektif sistem operasi, setiap utas perangkat keras
mempertahankan status arsitekturnya, seperti instruksi
pointer dan set register, dan dengan demikian muncul sebagai CPU logis yang tersedia untuk
menjalankan utas perangkat lunak. Teknik ini—dikenal sebagai chip multithreading (CMT)
—diilustrasikan pada Gambar 5.14. Di sini, prosesor berisi empat komputasi
inti, dengan setiap inti berisi dua utas perangkat keras. Dari perspektif
dari sistem operasi, ada delapan CPU logis.
Prosesor Intel menggunakan istilah hyper-threading (juga dikenal sebagai simultane
ous multithreading atau SMT) untuk menggambarkan penetapan beberapa utas perangkat keras ke
inti pemrosesan tunggal. Prosesor Intel kontemporer—seperti i7—mendukung port dua utas
per inti, sedangkan prosesor Oracle Sparc M7 mendukung delapan
utas per inti, dengan delapan inti per prosesor, sehingga menyediakan operasi
sistem dengan 64 CPU logis.
Secara umum, ada dua cara untuk melakukan multithread pada inti pemrosesan:
multithreading berbutir kasar dan berbutir halus . Dengan multithread berbutir kasar, utas
dieksekusi pada inti hingga peristiwa latensi panjang seperti memori
kios terjadi. Karena penundaan yang disebabkan oleh peristiwa latensi panjang, inti
harus beralih ke utas lain untuk memulai eksekusi. Namun, biaya peralihan antar utas tinggi,
karena pipa instruksi harus dibilas
sebelum utas lainnya dapat memulai eksekusi pada inti prosesor. Sekali ini
utas baru memulai eksekusi, ia mulai mengisi pipa dengan instruksinya.
Multithreading berbutir halus (atau interleaved) beralih di antara utas pada a
tingkat granularitas yang jauh lebih baik— biasanya pada batas instruksi
utas1
C M C M C M C
benang0
CMC M C M C
waktu
Gambar 5.13 Sistem multicore multithread.

5.5 Penjadwalan Multi-Prosesor 223
prosesor
inti 0 inti 1
benang perangkat keras benang perangkat keras
inti 2 inti 3
tampilan sistem operasi

CPU
CPU0 CPU1 CPU2 3
CPU4 CPU5 CPU6 CPU7
Gambar 5.14 Chip multithreading.
siklus. Namun, desain arsitektur sistem berbutir halus mencakup logika

untuk pergantian benang. Akibatnya, biaya peralihan antar utas menjadi kecil.
Penting untuk dicatat bahwa sumber daya inti fisik (seperti cache
dan saluran pipa) harus dibagi di antara utas perangkat kerasnya, dan karenanya a
inti pemrosesan hanya dapat mengeksekusi satu utas perangkat keras pada satu waktu. Akibatnya,
prosesor multithreaded, multicore sebenarnya membutuhkan dua tingkat yang berbeda
penjadwalan, seperti yang ditunjukkan pada Gambar 5.15, yang mengilustrasikan inti pemrosesan
utas ganda.
Pada satu tingkat adalah keputusan penjadwalan yang harus dibuat oleh sistem operasi karena
memilih utas perangkat lunak mana yang akan dijalankan pada setiap perangkat keras.
utas ( CPU logis). Untuk semua tujuan praktis, keputusan tersebut telah menjadi
fokus utama bab ini. Oleh karena itu, untuk tingkat penjadwalan ini, sistem operasi dapat memilih
algoritma penjadwalan apa pun, termasuk yang dijelaskan
di Bagian 5.3.
Penjadwalan tingkat kedua menentukan bagaimana setiap inti memutuskan utas perangkat
keras mana yang akan dijalankan. Ada beberapa strategi yang harus diambil dalam situasi ini. Satu
pendekatannya adalah dengan menggunakan algoritma round-robin sederhana untuk menjadwalkan perangkat keras
utas ke inti pemrosesan. Ini adalah pendekatan yang diadopsi oleh UltraSPARC
T3. Pendekatan lain digunakan oleh Intel Itanium, prosesor dual-core dengan
dua utas yang dikelola perangkat keras per inti. Ditugaskan ke setiap utas perangkat keras adalah
nilai urgensi dinamis mulai dari 0 hingga 7, dengan 0 mewakili yang terendah
urgensi dan 7 tertinggi. Itanium mengidentifikasi lima peristiwa berbeda yang mungkin
utas perangkat lunak
tingkat 1
utas perangkat keras
(prosesor logis)
level 2
pengolahan
inti
Gambar 5.15 Dua tingkat penjadwalan.
memicu sakelar ulir. Ketika salah satu peristiwa ini terjadi, logika thread-switching
membandingkan urgensi dari dua thread dan memilih thread dengan nilai urgensi tertinggi
untuk dieksekusi pada inti prosesor.
Perhatikan bahwa dua tingkat penjadwalan yang berbeda yang ditunjukkan pada Gambar
5.15 tidak selalu eksklusif satu sama lain. Bahkan, jika penjadwal sistem operasi (tingkat
pertama) disadarkan akan pembagian sumber daya prosesor, ini dapat membuat keputusan
penjadwalan yang lebih efektif. Sebagai contoh, asumsikan bahwa CPU memiliki dua inti
pemrosesan, dan setiap inti memiliki dua utas perangkat keras. Jika dua utas perangkat lunak
berjalan pada sistem ini, mereka dapat berjalan pada inti yang sama atau pada inti yang
terpisah. Jika keduanya dijadwalkan untuk berjalan pada inti yang sama, mereka harus berbagi
sumber daya prosesor dan dengan demikian cenderung berjalan lebih lambat daripada jika
dijadwalkan pada inti yang terpisah. Jika sistem operasi mengetahui tingkat pembagian
sumber daya prosesor, ia dapat menjadwalkan utas perangkat lunak ke prosesor logis yang
tidak berbagi sumber daya.
5.5.3 Penyeimbangan Beban
Pada sistem SMP , penting untuk menjaga keseimbangan beban kerja di antara semua
prosesor untuk sepenuhnya memanfaatkan manfaat memiliki lebih dari satu prosesor. Jika
tidak, satu atau lebih prosesor dapat menganggur sementara prosesor lain memiliki beban
kerja yang tinggi, bersama dengan antrian thread yang siap menunggu CPU. Penyeimbangan
beban berupaya untuk menjaga agar beban kerja terdistribusi secara merata di semua
prosesor dalam sistem SMP . Penting untuk dicatat bahwa penyeimbangan beban biasanya
hanya diperlukan pada sistem di mana setiap prosesor memiliki antrian utas yang memenuhi
syarat untuk dieksekusi secara pribadi. Pada sistem dengan antrian yang berjalan umum,
penyeimbangan beban tidak diperlukan, karena begitu prosesor menjadi tidak aktif, prosesor
segera mengekstrak utas yang dapat dijalankan dari antrian siap yang umum.
Ada dua pendekatan umum untuk load balancing: migrasi dorong dan migrasi tarik.
Dengan migrasi push, tugas tertentu secara berkala memeriksa beban pada setiap prosesor
dan—jika menemukan ketidakseimbangan—mendistribusikan beban secara merata dengan
memindahkan (atau mendorong) utas dari prosesor yang kelebihan beban ke prosesor yang
tidak aktif atau kurang sibuk. Migrasi tarik terjadi ketika prosesor yang menganggur menarik
tugas yang menunggu dari prosesor yang sibuk. Migrasi push dan pull tidak perlu saling
eksklusif dan, pada kenyataannya, sering diimplementasikan secara paralel pada sistem load-balanc
5.5 Penjadwalan Multi-Prosesor 225
sebagai contoh, penjadwal CFS Linux (dijelaskan dalam Bagian 5.7.1) dan penjadwal
ULE yang tersedia untuk sistem FreeBSD menerapkan kedua teknik tersebut.
Konsep "beban seimbang" mungkin memiliki arti yang berbeda. Satu tampilan dari
beban yang seimbang mungkin hanya memerlukan bahwa semua antrian memiliki
jumlah thread yang kira-kira sama. Atau, keseimbangan mungkin memerlukan distribusi
prioritas thread yang sama di semua antrian. Selain itu, dalam situasi tertentu, tak satu
pun dari strategi ini mungkin cukup. Memang, mereka mungkin bekerja melawan tujuan
dari algoritma penjadwalan. (Kami meninggalkan pertimbangan lebih lanjut tentang ini
sebagai latihan.)
5.5.4 Afinitas Prosesor
Pertimbangkan apa yang terjadi pada memori cache ketika sebuah thread telah berjalan
pada prosesor tertentu. Data yang terakhir diakses oleh utas mengisi cache untuk
prosesor. Akibatnya, akses memori yang berurutan oleh utas sering kali dipenuhi dalam
memori cache (dikenal sebagai "cache hangat"). Sekarang pertimbangkan apa yang
terjadi jika utas bermigrasi ke prosesor lain—misalnya, karena penyeimbangan beban.
Isi memori cache harus dibatalkan untuk prosesor pertama, dan cache untuk prosesor
kedua harus diisi ulang. Karena tingginya biaya pembatalan dan pengisian ulang cache,
sebagian besar sistem operasi dengan dukungan SMP mencoba untuk menghindari
migrasi thread dari satu prosesor ke prosesor lainnya dan sebagai gantinya mencoba
untuk menjaga thread tetap berjalan pada prosesor yang sama dan memanfaatkan
cache hangat. Ini dikenal sebagai affinit prosesor — yaitu, suatu proses memiliki
afinitas untuk prosesor yang sedang berjalan.
Dua strategi yang dijelaskan dalam Bagian 5.5.1 untuk mengatur antrian utas yang
tersedia untuk penjadwalan memiliki implikasi untuk afinitas prosesor. Jika kita
mengadopsi pendekatan antrian siap umum, thread dapat dipilih untuk dieksekusi oleh
prosesor apa pun. Jadi, jika utas dijadwalkan pada prosesor baru, cache prosesor
tersebut harus diisi ulang. Dengan antrean siap pakai per-prosesor pribadi, sebuah utas
selalu dijadwalkan pada prosesor yang sama dan oleh karena itu dapat mengambil
manfaat dari konten cache hangat. Pada dasarnya, antrian siap per-prosesor memberikan
afinitas prosesor secara gratis!
Afinitas prosesor mengambil beberapa bentuk. Ketika sistem operasi memiliki
kebijakan untuk mencoba menjaga proses tetap berjalan pada prosesor yang sama—
tetapi tidak menjamin akan melakukannya—kita memiliki situasi yang dikenal sebagai soft a
Di sini, sistem operasi akan mencoba untuk menjaga proses pada satu prosesor, tetapi
proses dapat berpindah antar prosesor selama penyeimbangan beban. Sebaliknya,
beberapa sistem menyediakan panggilan sistem yang mendukung hard affinit , sehingga
memungkinkan suatu proses
dijalankannya. Banyakuntuk menentukan
sistem subset
memberikan prosesor
afinitas lunak yang dapat Misalnya,
dan keras.
Linux mengimplementasikan afinitas lunak, tetapi juga menyediakan panggilan sistem
sched setaffinity() , yang mendukung afinitas keras dengan mengizinkan utas untuk
menentukan set CPU yang memenuhi syarat untuk dijalankan.
Arsitektur memori utama suatu sistem juga dapat memengaruhi masalah afinitas
prosesor. Gambar 5.16 mengilustrasikan arsitektur yang menampilkan akses memori
non-seragam (NUMA) di mana ada dua chip prosesor fisik masing-masing dengan CPU
dan memori lokalnya sendiri. Meskipun interkoneksi sistem memungkinkan semua CPU
dalam sistem NUMA untuk berbagi satu ruang alamat fisik, CPU memiliki akses lebih
cepat ke memori lokalnya daripada ke memori lokal ke CPU lain. Jika penjadwal CPU
dan algoritme penempatan memori sistem operasi sadar akan NUMA
CPU CPU
akses
akses cepat lambat akses cepat
Penyimpanan Penyimpanan
interkoneksi
Gambar 5.16 Penjadwalan NUMA dan CPU.
dan bekerja sama, maka thread yang telah dijadwalkan ke CPU tertentu dapat dialokasikan
memori yang paling dekat dengan tempat CPU berada, sehingga memberikan thread akses
memori secepat mungkin.
Menariknya, penyeimbangan beban sering kali berlawanan dengan manfaat afinitas
prosesor. Artinya, manfaat dari menjalankan thread pada prosesor yang sama adalah
bahwa thread dapat memanfaatkan datanya yang berada di memori cache prosesor
tersebut. Menyeimbangkan beban dengan memindahkan utas dari satu prosesor ke
prosesor lainnya menghilangkan manfaat ini. Demikian pula, migrasi utas antar prosesor
dapat dikenakan penalti pada sistem NUMA , di mana utas dapat dipindahkan ke prosesor
yang membutuhkan waktu akses memori yang lebih lama. Dengan kata lain, ada
ketegangan alami antara load balancing dan meminimalkan waktu akses memori. Dengan
demikian, algoritma penjadwalan untuk sistem NUMA multicore modern menjadi sangat
kompleks. Di Bagian 5.7.1, kami memeriksa algoritma penjadwalan CFS Linux dan
mengeksplorasi bagaimana menyeimbangkan tujuan yang bersaing ini.
5.5.5 Multiprosesor Heterogen Dalam contoh yang

telah kita diskusikan sejauh ini, semua prosesor identik dalam hal kemampuannya,
sehingga memungkinkan setiap utas untuk berjalan pada inti pemrosesan apa pun.
Satu-satunya perbedaan adalah bahwa waktu akses memori dapat bervariasi berdasarkan
penyeimbangan beban dan kebijakan afinitas prosesor, serta pada sistem NUMA .
Meskipun sistem mobile sekarang termasuk arsitektur multicore, beberapa sistem
sekarang dirancang menggunakan core yang menjalankan set instruksi yang sama, namun
bervariasi dalam hal kecepatan clock dan manajemen daya, termasuk kemampuan untuk
menyesuaikan konsumsi daya inti ke titik pemalasan inti. Sistem seperti ini dikenal sebagai
multiprocessing heterogen (HMP). Perhatikan bahwa ini bukan bentuk multiprosesor
asimetris seperti yang dijelaskan dalam Bagian 5.5.1 karena tugas sistem dan pengguna
dapat berjalan pada inti apa pun. Sebaliknya, maksud di balik HMP adalah untuk mengelola
konsumsi daya dengan lebih baik dengan menetapkan tugas ke inti tertentu berdasarkan
tuntutan tugas tertentu.
Untuk prosesor ARM yang mendukungnya, jenis arsitektur ini dikenal sebagai
big.LITTLE di mana big core berperforma tinggi digabungkan dengan core LITTLE hemat
energi . Core besar mengkonsumsi energi yang lebih besar dan karenanya harus
5.6 Penjadwalan CPU Real-Time 227
hanya digunakan untuk waktu yang singkat. Demikian juga, inti kecil menggunakan lebih sedikit energi
dan karenanya dapat digunakan untuk waktu yang lebih lama.
Ada beberapa keuntungan dari pendekatan ini. Dengan menggabungkan sejumlah inti yang lebih
lambat dengan yang lebih cepat, penjadwal CPU dapat menetapkan tugas yang tidak memerlukan
kinerja tinggi, tetapi mungkin perlu dijalankan untuk waktu yang lebih lama, (seperti tugas latar belakang)
ke inti kecil, sehingga membantu menghemat daya baterai .
Demikian pula, aplikasi interaktif yang membutuhkan lebih banyak kekuatan pemrosesan, tetapi dapat
berjalan untuk jangka waktu yang lebih pendek, dapat ditugaskan ke inti besar. Selain itu, jika perangkat
seluler dalam mode hemat daya, inti besar yang intensif energi dapat dinonaktifkan dan sistem hanya
dapat mengandalkan inti kecil yang hemat energi. Win dows 10 mendukung penjadwalan HMP dengan
mengizinkan utas untuk memilih kebijakan penjadwalan yang paling mendukung tuntutan manajemen
dayanya.
5.6 Penjadwalan CPU Real-Time

Penjadwalan CPU untuk sistem operasi waktu nyata melibatkan masalah khusus. Secara umum, kita
dapat membedakan antara sistem waktu nyata lunak dan sistem waktu nyata keras. Sistem soft real-
time tidak memberikan jaminan kapan proses real-time kritis akan dijadwalkan. Mereka hanya menjamin
bahwa proses akan lebih diutamakan daripada proses yang tidak kritis. Sistem hard real-time memiliki
persyaratan yang lebih ketat. Sebuah tugas harus diselesaikan pada tenggat waktunya; layanan setelah
batas waktu berakhir sama dengan tidak ada layanan sama sekali. Di bagian ini, kami mengeksplorasi
beberapa masalah yang terkait dengan penjadwalan proses di sistem operasi waktu nyata lunak dan
keras.
5.6.1 Meminimalkan Latensi Pertimbangkan
sifat event-driven dari sistem real-time. Sistem biasanya menunggu peristiwa secara real time terjadi.
Peristiwa dapat muncul baik dalam perangkat lunak —seperti saat pengatur waktu habis masa berlakunya
—atau dalam perangkat keras—seperti ketika kendaraan yang dikendalikan dari jarak jauh mendeteksi
bahwa ia mendekati penghalang. Ketika suatu peristiwa terjadi, sistem harus merespon dan melayaninya
secepat mungkin. Kami mengacu pada latensi peristiwa sebagai jumlah waktu yang berlalu dari saat
peristiwa terjadi hingga saat dilayani (Gambar 5.17).
peristiwa E pertama terjadi
latensi acara
t0 t1
sistem waktu nyata merespons E
Waktu
Gambar 5.17 Latensi peristiwa.

Biasanya, peristiwa yang berbeda memiliki persyaratan latensi yang berbeda. Misalnya,
persyaratan latensi untuk sistem rem anti penguncian mungkin 3 hingga 5 milidetik. Artinya,
dari saat roda pertama kali mendeteksi bahwa ia meluncur, sistem yang mengendalikan
rem anti penguncian memiliki waktu 3 hingga 5 milidetik untuk merespons dan
mengendalikan situasi. Setiap respons yang memakan waktu lebih lama dapat
mengakibatkan mobil berbelok di luar kendali. Sebaliknya, sistem kendali radar tertanam di
pesawat mungkin mentolerir periode latensi beberapa detik.
Dua jenis latency mempengaruhi kinerja sistem real-time:
1. Latensi interupsi 2.
Latensi pengiriman
Latensi interupsi mengacu pada periode waktu dari kedatangan interupsi di CPU
hingga awal rutinitas yang melayani interupsi. Ketika interupsi terjadi, sistem operasi harus
terlebih dahulu menyelesaikan instruksi yang dijalankannya dan menentukan jenis interupsi
yang terjadi. Itu kemudian harus menyimpan status proses saat ini sebelum melayani
interupsi menggunakan rutin layanan interupsi khusus (ISR). Total waktu yang diperlukan
untuk melakukan tugas-tugas ini adalah latensi interupsi (Gambar 5.18).
Jelas, sangat penting bagi sistem operasi waktu nyata untuk meminimalkan latensi
interupsi untuk memastikan bahwa tugas waktu nyata mendapat perhatian segera. Memang,
untuk sistem waktu nyata yang sulit, latensi interupsi tidak boleh begitu saja diminimalkan,
tetapi harus dibatasi untuk memenuhi persyaratan ketat sistem ini.
Salah satu faktor penting yang berkontribusi terhadap latensi interupsi adalah jumlah
waktu interupsi dapat dinonaktifkan saat struktur data kernel diperbarui. Sistem operasi
waktu nyata mengharuskan interupsi dinonaktifkan hanya untuk periode waktu yang sangat
singkat.
Jumlah waktu yang diperlukan untuk penjadwalan dispatcher untuk menghentikan satu
proses dan memulai yang lain dikenal sebagai dispatch latency. Menyediakan waktu nyata
mengganggu
tentukan jenis
tugas T berjalan interupsi
sakelar
konteks
ISR
mengganggu
latensi
waktu
Gambar 5.18 Latensi interupsi.

peristiwa tanggapan terhadap acara
interval respons
proses yang
pemrosesan tersedia
interupsi
pengiriman latensi
waktu sebenarnya
eksekusi
proses
konflik menugaskan
waktu
Gambar 5.19 Latensi pengiriman.
tugas dengan akses langsung ke CPU mengamanatkan bahwa operasi waktu nyata
sistem meminimalkan latensi ini juga. Teknik paling efektif untuk menjaga
pengiriman latency rendah adalah untuk menyediakan kernel preemptive. Untuk waktu nyata yang sulit
sistem, latensi pengiriman biasanya diukur dalam beberapa mikrodetik.
Pada Gambar 5.19, kami membuat diagram susunan latensi pengiriman. konflik _
fase latensi pengiriman memiliki dua komponen:
1. Preemption dari setiap proses yang berjalan di kernel
2. Rilis dengan proses prioritas rendah dari sumber daya yang dibutuhkan oleh prioritas tinggi
proses
Setelah fase konflik, fase pengiriman menjadwalkan prioritas tinggi

proses ke CPU yang tersedia.
5.6.2 Penjadwalan Berbasis Prioritas

Fitur paling penting dari sistem operasi waktu nyata adalah untuk segera merespons proses
waktu nyata segera setelah proses itu membutuhkan CPU. Sebagai
Akibatnya, penjadwal untuk sistem operasi real-time harus mendukung algoritma berbasis
prioritas dengan preemption. Ingat bahwa algoritma penjadwalan berbasis prioritas menetapkan
setiap proses prioritas berdasarkan kepentingannya; lebih penting
tugas diberi prioritas lebih tinggi daripada yang dianggap kurang penting. jika
scheduler juga mendukung preemption, sebuah proses yang sedang berjalan di CPU
akan didahulukan jika proses dengan prioritas lebih tinggi tersedia untuk dijalankan.
Preemptive, algoritma penjadwalan berbasis prioritas dibahas secara rinci di
Bagian 5.3.4, dan Bagian 5.7 menyajikan contoh fitur penjadwalan real-time lunak dari sistem
operasi Linux, Windows, dan Solaris. Setiap
sistem ini memberikan proses real-time prioritas penjadwalan tertinggi. Untuk
ppp
d d d
t t t
Waktu
periode 1 periode2 periode3
Gambar 5.20 Tugas periodik.
contoh, Windows memiliki 32 tingkat prioritas yang berbeda. Level tertinggi—nilai prioritas 16
hingga 31—dicadangkan untuk proses waktu nyata. Solaris dan Linux memiliki skema prioritas
yang serupa.
Perhatikan bahwa menyediakan penjadwal berbasis prioritas preemtif hanya menjamin
fungsionalitas waktu nyata yang lembut. Sistem hard real-time selanjutnya harus menjamin
bahwa tugas real-time akan dilayani sesuai dengan persyaratan tenggat waktu mereka, dan
membuat jaminan tersebut memerlukan fitur penjadwalan tambahan. Di sisa bagian ini, kami
membahas algoritme penjadwalan yang sesuai untuk sistem waktu nyata yang sulit.
Namun, sebelum kita melanjutkan dengan rincian penjadwal individu, kita harus
menentukan karakteristik tertentu dari proses yang akan dijadwalkan.
Pertama, proses dianggap periodik. Artinya, mereka membutuhkan CPU pada interval
(periode) yang konstan. Setelah proses periodik memperoleh CPU, ia memiliki waktu
pemrosesan tetap t, tenggat waktu d yang harus dilayani oleh CPU, dan periode p. Hubungan
waktu pemrosesan, tenggat waktu, dan periode dapat dinyatakan sebagai 0 t d p . Tingkat
tugas periodik adalah 1 ÿp.
Gambar 5.20 mengilustrasikan pelaksanaan proses periodik dari waktu ke waktu. Penjadwal
dapat memanfaatkan karakteristik ini dan menetapkan prioritas sesuai dengan tenggat waktu
proses atau persyaratan tingkat.
Apa yang tidak biasa tentang bentuk penjadwalan ini adalah bahwa suatu proses mungkin
harus mengumumkan persyaratan tenggat waktu kepada penjadwal. Kemudian, menggunakan
teknik yang dikenal sebagai algoritma kontrol masuk , penjadwal melakukan salah satu dari
dua hal. Itu baik mengakui proses, menjamin bahwa proses akan selesai tepat waktu, atau
menolak permintaan sebagai tidak mungkin jika tidak dapat menjamin bahwa tugas akan
dilayani oleh tenggat waktu.
5.6.3 Penjadwalan Tingkat Monotonik

Algoritma penjadwalan rate-monotonic menjadwalkan tugas-tugas periodik menggunakan
kebijakan prioritas statis dengan preemption. Jika proses dengan prioritas lebih rendah sedang
dijalankan dan proses dengan prioritas lebih tinggi tersedia untuk dijalankan, proses dengan
prioritas lebih rendah akan mendahuluinya. Saat memasuki sistem, setiap tugas periodik
diberikan prioritas secara terbalik berdasarkan periodenya. Semakin pendek periodenya,
semakin tinggi prioritasnya; semakin lama periodenya, semakin rendah prioritasnya. Alasan di
balik kebijakan ini adalah untuk menetapkan prioritas yang lebih tinggi untuk tugas-tugas yang
membutuhkan CPU lebih sering. Selanjutnya, penjadwalan tingkat-monoton mengasumsikan bahwa p
tenggat waktu P1 P1, P2
P2 P1
0 10 20 30 40 50 60 70 80 90 100 110 120
Gambar 5.21 Penjadwalan tugas ketika P2 memiliki prioritas lebih tinggi dari P1.
waktu proses periodik adalah sama untuk setiap CPU burst. Artinya, setiap kali suatu proses
memperoleh CPU, durasi CPU burst-nya sama.
Mari kita pertimbangkan sebuah contoh. Kami memiliki dua proses, P1 dan P2. Periode untuk
P1 dan P2 berturut-turut adalah 50 dan 100— yaitu, p1 = 50 dan p2 = 100. Waktu pemrosesan adalah
t1 = 20 untuk P1 dan t2 = 35 untuk P2. Batas waktu untuk setiap proses mengharuskannya
menyelesaikan CPU burst-nya pada awal periode berikutnya.
Pertama-tama kita harus bertanya pada diri sendiri apakah mungkin untuk menjadwalkan tugas-
tugas ini sehingga masing-masing memenuhi tenggat waktunya. Jika kita mengukur utilisasi CPU dari
sebuah proses Pi sebagai rasio ledakannya terhadap periodenya—ti pi— utilisasi CPU dari P1 adalah
20ÿ50 = 0,40 dan P2 adalah 35ÿ100 = 0,35, untuk total CPU pemanfaatan 75 persen. Oleh karena
itu, tampaknya kita dapat menjadwalkan tugas-tugas ini sedemikian rupa sehingga keduanya
memenuhi tenggat waktu dan masih meninggalkan CPU dengan siklus yang tersedia.
Misalkan kita menetapkan P2 prioritas yang lebih tinggi dari P1. Eksekusi P1 dan P2 dalam
situasi ini ditunjukkan pada Gambar 5.21. Seperti yang dapat kita lihat, P2 memulai eksekusi terlebih
dahulu dan selesai pada waktu 35. Pada titik ini, P1 dimulai; ia menyelesaikan CPU burst-nya pada
waktu 55. Namun, batas waktu pertama untuk P1 adalah pada waktu 50, sehingga penjadwal telah
menyebabkan P1 melewatkan batas waktunya.
Sekarang anggaplah kita menggunakan penjadwalan tingkat-monotonik, di mana kita
menetapkan P1 prioritas yang lebih tinggi daripada P2 karena periode P1 lebih pendek dari P2.
Eksekusi proses ini dalam situasi ini ditunjukkan pada Gambar 5.22. P1 mulai lebih dulu dan
menyelesaikan CPU burst-nya pada waktu 20, sehingga memenuhi tenggat waktu pertama. P2 mulai
berjalan pada titik ini dan berjalan hingga waktu 50. Pada saat ini, ia didahului oleh P1, meskipun
masih memiliki 5 milidetik tersisa dalam CPU burst-nya.
P1 menyelesaikan CPU burst pada waktu 70, di mana penjadwal melanjutkan P2.
P2 menyelesaikan CPU burst pada waktu 75, juga memenuhi tenggat waktu pertama. Sistem idle
sampai waktu 100, ketika P1 dijadwalkan lagi.
Penjadwalan rate-monotonic dianggap optimal jika satu set proses tidak dapat dijadwalkan oleh
algoritma ini, tidak dapat dijadwalkan oleh algoritma lain yang menetapkan prioritas statis. Selanjutnya
mari kita periksa sekumpulan proses yang tidak dapat dijadwalkan menggunakan algoritma rate-
monotonic.
Asumsikan bahwa proses P1 memiliki periode p1 = 50 dan CPU burst t1 = 25.
Untuk P2, nilai yang sesuai adalah p2 = 80 dan t2 = 35. Tingkat-monotonik
tenggat waktu P1 P1, P2 P1 P1, P2
P1 P2 P1 P2 P1 P2 P1 P2
0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 170 180 190 200
Gambar 5.22 Penjadwalan tingkat-monotonik.

tenggat waktu P1 P2 P1 P1, P2
P1 P2 P1 P2
0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160
Gambar 5.23 Tenggat waktu yang hilang dengan penjadwalan tingkat monoton.
penjadwalan akan menetapkan proses P1 prioritas yang lebih tinggi, karena memiliki periode
yang lebih pendek. Total penggunaan CPU dari kedua proses adalah (25ÿ50) + (35ÿ80) =
0,94, dan oleh karena itu tampaknya logis bahwa kedua proses dapat dijadwalkan dan
masih meninggalkan CPU dengan 6 persen waktu yang tersedia. Gambar 5.23 menunjukkan
penjadwalan proses P1 dan P2. Awalnya, P1 berjalan hingga CPU burst -nya selesai pada
waktu 25. Proses P2 kemudian mulai berjalan dan berjalan hingga waktu 50, ketika didahului
oleh P1. Pada titik ini, P2 masih memiliki 10 milidetik tersisa dalam CPU burst-nya. Proses
P1 berjalan sampai waktu 75; akibatnya, P2 menyelesaikan ledakannya pada waktu 85,
setelah batas waktu penyelesaian ledakan CPU pada waktu 80.
Meskipun optimal, penjadwalan tingkat-monotonik memiliki keterbatasan: penggunaan
CPU dibatasi, dan tidak selalu mungkin untuk memaksimalkan sumber daya CPU
sepenuhnya. Pemanfaatan CPU kasus terburuk untuk menjadwalkan proses N adalah
N(21ÿN 1).
Dengan satu proses dalam sistem, pemanfaatan CPU adalah 100 persen, tetapi turun
menjadi sekitar 69 persen karena jumlah proses mendekati tak terbatas. Dengan dua
proses, pemanfaatan CPU dibatasi sekitar 83 persen. Penggunaan CPU gabungan untuk
dua proses yang dijadwalkan pada Gambar 5.21 dan Gambar 5.22 adalah 75 persen; oleh
karena itu, algoritma penjadwalan tingkat-monoton dijamin untuk menjadwalkannya sehingga
mereka dapat memenuhi tenggat waktu mereka. Untuk dua proses yang dijadwalkan pada
Gambar 5.23, penggunaan CPU gabungan kira-kira 94 persen; oleh karena itu, penjadwalan
tingkat monoton tidak dapat menjamin bahwa mereka dapat dijadwalkan sehingga mereka
memenuhi tenggat waktu mereka.
5.6.4 Penjadwalan Tenggat-Pertama-Pertama Penjadwalan
Tenggat-Pertama ( EDF) menetapkan prioritas secara dinamis sesuai dengan tenggat

waktu. Semakin awal tenggat waktu, semakin tinggi prioritasnya; semakin lambat tenggat
waktunya, semakin rendah prioritasnya. Di bawah kebijakan EDF , ketika suatu proses
menjadi dapat dijalankan, ia harus mengumumkan persyaratan tenggat waktu ke sistem.
Prioritas mungkin harus disesuaikan untuk mencerminkan tenggat waktu proses yang baru dapat d
Perhatikan bagaimana ini berbeda dari penjadwalan tingkat-monoton, di mana prioritas
ditetapkan.
Untuk mengilustrasikan penjadwalan EDF , kami kembali menjadwalkan proses yang
ditunjukkan pada Gambar 5.23, yang gagal memenuhi persyaratan tenggat waktu di bawah
penjadwalan tingkat-monotonik. Ingat bahwa P1 memiliki nilai p1 = 50 dan t1 = 25 dan
bahwa P2 memiliki nilai p2 = 80 dan t2 = 35. Penjadwalan EDF dari proses ini ditunjukkan
pada Gambar 5.24. Proses P1 memiliki tenggat waktu paling awal, sehingga prioritas
awalnya lebih tinggi daripada proses P2. Proses P2 mulai berjalan di akhir CPU burst untuk
P1. Namun, sedangkan penjadwalan tingkat-monoton memungkinkan P1 untuk mendahului P2
tenggat waktu P1 P2 P1 P1 P2
P1 P2 P1 P2 P1 P2
0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160
Gambar 5.24 Penjadwalan paling awal-tenggat waktu-pertama.
pada awal periode berikutnya pada waktu 50, penjadwalan EDF memungkinkan proses P2
untuk terus berjalan. P2 sekarang memiliki prioritas lebih tinggi daripada P1 karena tenggat
waktu berikutnya (pada waktu 80) lebih awal dari P1 (pada waktu 100). Dengan demikian,
baik P1 dan P2 memenuhi tenggat waktu pertama mereka. Proses P1 kembali mulai berjalan
pada waktu 60 dan menyelesaikan CPU burst kedua pada waktu 85, juga memenuhi tenggat
waktu kedua pada waktu 100. P2 mulai berjalan pada titik ini, hanya untuk didahului oleh P1
pada awal periode berikutnya pada waktu 100 .P2 didahulukan karena P1 memiliki tenggat
waktu lebih awal (waktu 150) daripada P2 (waktu 160). Pada waktu 125, P1 menyelesaikan
CPU burst dan P2 melanjutkan eksekusi, selesai pada waktu 145 dan memenuhi tenggat
waktunya juga. Sistem idle sampai waktu 150, ketika P1 dijadwalkan untuk dijalankan sekali lagi
Berbeda dengan algoritma rate-monotonic, penjadwalan EDF tidak mengharuskan
proses menjadi periodik, atau proses membutuhkan jumlah waktu CPU yang konstan per
burst. Satu-satunya persyaratan adalah bahwa suatu proses mengumumkan tenggat waktu
ke penjadwal ketika menjadi runnable. Daya tarik penjadwalan EDF adalah secara teoritis
optimal— secara teoritis, ia dapat menjadwalkan proses sehingga setiap proses dapat
memenuhi persyaratan tenggat waktu dan penggunaan CPU akan menjadi 100 persen.
Namun, dalam praktiknya, tidak mungkin untuk mencapai tingkat penggunaan CPU ini
karena biaya peralihan konteks antara proses dan penanganan interupsi.
5.6.5 Penjadwalan Bagian Proporsional Penjadwal
pembagian proporsional beroperasi dengan mengalokasikan bagian T di antara semua

aplikasi. Sebuah aplikasi dapat menerima N bagian waktu, sehingga memastikan bahwa
aplikasi tersebut akan memiliki NÿT dari total waktu prosesor. Sebagai contoh, asumsikan
bahwa total T = 100 saham akan dibagi di antara tiga proses, A, B, dan C. A diberikan 50
saham, B ditugaskan 15 saham, dan C ditugaskan 20 saham.
Skema ini memastikan bahwa A akan memiliki 50 persen dari total waktu prosesor, B akan
memiliki 15 persen, dan C akan memiliki 20 persen.
Penjadwal pembagian proporsional harus bekerja sama dengan kebijakan kontrol
penerimaan untuk menjamin bahwa aplikasi menerima pembagian waktu yang dialokasikan.
Kebijakan kontrol penerimaan akan menerima klien yang meminta sejumlah saham tertentu
hanya jika tersedia cukup banyak. Dalam contoh kami saat ini, kami telah mengalokasikan
50 + 15 + 20 = 85 saham dari total 100 saham. Jika proses baru D meminta 30 pembagian,
pengontrol penerimaan akan menolak D masuk ke sistem.
5.6.6 Penjadwalan POSIX Real-Time

Standar POSIX juga menyediakan ekstensi untuk komputasi waktu nyata— POSIX.1b. Di
sini, kami membahas beberapa API POSIX yang terkait dengan penjadwalan utas waktu-
nyata. POSIX mendefinisikan dua kelas penjadwalan untuk utas waktu nyata:
• FIFO TERJADWAL
• JADWAL RR
SCHED FIFO menjadwalkan thread menurut kebijakan yang datang lebih dulu, dilayani lebih dulu
menggunakan antrian FIFO sebagaimana diuraikan dalam Bagian 5.3.1. Namun, tidak ada pembagian waktu di
antara utas dengan prioritas yang sama. Oleh karena itu, utas real-time dengan prioritas tertinggi di depan
antrian FIFO akan diberikan CPU sampai diakhiri atau diblokir. SCHED RR menggunakan kebijakan round-
robin. Ini mirip dengan SCHED FIFO kecuali bahwa ia menyediakan pemotongan waktu di antara utas dengan
prioritas yang sama. POSIX menyediakan kelas penjadwalan tambahan—SCHED OTHER—tetapi
implementasinya tidak ditentukan dan sistemnya spesifik; mungkin berperilaku berbeda pada sistem yang
berbeda.
POSIX API menetapkan dua fungsi berikut untuk mendapatkan dan menyetel
kebijakan penjadwalan:
• pthread attr getchedpolicy(pthread attr t *attr, int

*aturan)
• pthread attr setschedpolicy(pthread attr t *attr, int
aturan)
Parameter pertama untuk kedua fungsi adalah penunjuk ke set atribut untuk utas.
Parameter kedua adalah (1) penunjuk ke bilangan bulat yang disetel ke kebijakan
penjadwalan saat ini (untuk pthread attr getched policy()) atau (2) nilai integer (SCHED
FIFO, SCHED RR, atau SCHED OTHER) untuk pthread attr menyetel fungsi policy().
Kedua fungsi mengembalikan nilai bukan nol jika terjadi kesalahan.
Pada Gambar 5.25, kami mengilustrasikan program POSIX Pthread menggunakan API ini. Program ini
pertama-tama menentukan kebijakan penjadwalan saat ini dan kemudian menetapkan algoritma penjadwalan
ke SCHED FIFO.
5.7 Contoh Sistem Operasi

Kami beralih ke deskripsi kebijakan penjadwalan sistem operasi Linux, Windows, dan
Solaris. Penting untuk dicatat bahwa kami menggunakan istilah penjadwalan proses
dalam pengertian umum di sini. Sebenarnya, kami menjelaskan penjadwalan utas kernel
dengan sistem Solaris dan Windows dan tugas dengan penjadwal Linux.
5.7.1 Contoh: Penjadwalan Linux

Penjadwalan proses di Linux memiliki sejarah yang menarik. Sebelum Versi 2.5, kernel
Linux menjalankan variasi dari algoritma penjadwalan UNIX tradisional.
Namun, karena algoritme ini tidak dirancang dengan mempertimbangkan sistem SMP ,
algoritme ini tidak cukup mendukung sistem dengan banyak prosesor. Selain itu, ini
menghasilkan kinerja yang buruk untuk sistem dengan sejumlah besar proses yang dapat
dijalankan. Dengan kernel Versi 2.5, penjadwal dirombak untuk menyertakan algoritme
penjadwalan—dikenal sebagai O(1)—yang berjalan dalam waktu yang konstan dengan
memperhatikan jumlah tugas dalam sistem yang lebih sedikit. Penjadwal O(1) juga menyediaka
5.7 Contoh Sistem Operasi 235
#include <pthread.h>
#include <stdio.h> #define
NUM THREADS 5
int main(int argc, char *argv[]) {
int i, kebijakan;
pthread t tid[NUM THREADS];
pthread attr t attr;
/* mendapatkan atribut default */ pthread

attr init(&attr);
/* dapatkan kebijakan penjadwalan saat ini */ if

(pthread attr getschedpolicy(&attr, &policy) != 0) fprintf(stderr,
"Unable to get policy.ÿn"); else { if (kebijakan == DIJADWALKAN
LAINNYA) printf("DIJADIKAN LAINNYA"); else if (kebijakan ==
SCHED RR) printf("SCHED RRÿn"); else if (kebijakan ==
SCHED FIFO) printf("SCHED FIFOÿn");
/* menyetel kebijakan penjadwalan - FIFO, RR, atau LAINNYA */ if

(pthread attr setschedpolicy(&attr, SCHED FIFO) != 0) fprintf(stderr,
"Tidak dapat menyetel kebijakan.ÿn");
/* buat utas */ for (i = 0; i < NUM

THREADS; i++) pthread
create(&tid[i],&attr,runner,NULL);
/* sekarang gabung di setiap utas */

for (i = 0; i < NUM THREADS; i++) pthread
join(tid[i], NULL);
}
/* Setiap thread akan memulai kontrol dalam fungsi ini */ void

*runner(void *param) {
/* lakukan beberapa pekerjaan ... */
pthread keluar(0);
}
Gambar 5.25 API penjadwalan real-time POSIX.

peningkatan dukungan untuk sistem SMP , termasuk afinitas prosesor dan penyeimbangan beban
antar prosesor. Namun, dalam praktiknya, meskipun penjadwal O(1) memberikan kinerja yang sangat
baik pada sistem SMP , hal itu menyebabkan waktu respons yang buruk untuk proses interaktif yang
umum pada banyak sistem komputer desktop. Selama pengembangan kernel 2.6, penjadwal kembali
direvisi; dan dalam rilis 2.6.23 kernel, Completely Fair Scheduler (CFS) menjadi algoritma
penjadwalan Linux default.
Penjadwalan di sistem Linux didasarkan pada kelas penjadwalan. Setiap kelas diberi prioritas
tertentu. Dengan menggunakan kelas penjadwalan yang berbeda, kernel dapat mengakomodasi
algoritma penjadwalan yang berbeda berdasarkan kebutuhan sistem dan prosesnya. Kriteria
penjadwalan untuk server Linux, misalnya, mungkin berbeda dari kriteria untuk perangkat seluler
yang menjalankan Linux. Untuk memutuskan tugas mana yang akan dijalankan selanjutnya,
penjadwal memilih tugas dengan prioritas tertinggi yang termasuk dalam kelas penjadwalan dengan
prioritas tertinggi. Kernel Linux standar mengimplementasikan dua kelas penjadwalan: (1) kelas
penjadwalan default menggunakan algoritma penjadwalan CFS dan (2) kelas penjadwalan waktu
nyata. Kami membahas masing-masing kelas ini di sini. Kelas penjadwalan baru tentu saja dapat
ditambahkan.
Daripada menggunakan aturan ketat yang mengaitkan nilai prioritas relatif dengan panjang
kuantum waktu, penjadwal CFS menetapkan proporsi waktu pemrosesan CPU untuk setiap tugas.
Proporsi ini dihitung berdasarkan nilai bagus yang diberikan untuk setiap tugas. Nilai bagus berkisar
dari 20 hingga +19, di mana nilai bagus yang lebih rendah secara numerik menunjukkan prioritas
relatif yang lebih tinggi. Tugas dengan nilai bagus yang lebih rendah menerima proporsi waktu
pemrosesan CPU yang lebih tinggi daripada tugas dengan nilai bagus yang lebih tinggi. Nilai default
bagus adalah 0. (Istilah bagus berasal dari gagasan bahwa jika suatu tugas meningkatkan nilai
bagusnya dari, katakanlah, 0 ke +10, itu bagus untuk tugas lain dalam sistem dengan menurunkan
prioritas relatifnya. Di lain kata-kata, proses bagus selesai terakhir!) CFS tidak menggunakan nilai
diskrit dari irisan waktu dan sebagai gantinya mengidentifikasi latensi yang ditargetkan, yang
merupakan interval waktu di mana setiap tugas yang dapat dijalankan harus dijalankan setidaknya
sekali. Proporsi waktu CPU dialokasikan dari nilai latensi yang ditargetkan. Selain memiliki nilai
default dan minimum, latensi yang ditargetkan dapat meningkat jika jumlah tugas aktif dalam sistem
tumbuh melampaui ambang batas tertentu.
Penjadwal CFS tidak secara langsung menetapkan prioritas. Sebaliknya, ini mencatat berapa
lama setiap tugas telah berjalan dengan mempertahankan waktu berjalan virtual dari setiap tugas
menggunakan variabel per-tugas vruntime. Waktu berjalan virtual dikaitkan dengan faktor peluruhan
berdasarkan prioritas tugas: tugas dengan prioritas lebih rendah memiliki tingkat peluruhan yang
lebih tinggi daripada tugas dengan prioritas lebih tinggi. Untuk tugas dengan prioritas normal (nilai
bagus 0), waktu berjalan virtual identik dengan waktu berjalan fisik sebenarnya. Jadi, jika tugas
dengan prioritas default berjalan selama 200 milidetik, waktu prosesnya juga akan menjadi 200
milidetik. Namun, jika tugas dengan prioritas lebih rendah berjalan selama 200 milidetik, waktu
prosesnya akan lebih tinggi dari 200 milidetik. Demikian pula, jika tugas dengan prioritas lebih tinggi
berjalan selama 200 milidetik, waktu prosesnya akan kurang dari 200 milidetik.
Untuk memutuskan tugas mana yang akan dijalankan selanjutnya, penjadwal cukup memilih tugas
yang memiliki nilai vruntime terkecil . Selain itu, tugas dengan prioritas lebih tinggi yang tersedia
untuk dijalankan dapat mendahului tugas dengan prioritas lebih rendah.
Mari kita periksa penjadwal CFS beraksi: Asumsikan bahwa dua tugas memiliki nilai bagus yang
sama. Satu tugas terikat I/O, dan tugas lainnya terikat CPU.
Biasanya, tugas terikat-I/O akan berjalan hanya untuk waktu yang singkat sebelum memblokir untuk
I/O tambahan, dan tugas terikat-CPU akan menghabiskan periode waktunya setiap kali ada
kesempatan untuk dijalankan pada prosesor. Oleh karena itu, nilai vruntime akan
KINERJA CFS
Penjadwal CFS Linux menyediakan algoritme yang efisien untuk memilih tugas mana yang
akan dijalankan selanjutnya. Daripada menggunakan struktur data antrian standar, setiap
tugas yang dapat dijalankan ditempatkan di pohon merah-hitam — pohon pencarian biner
seimbang yang kuncinya didasarkan pada nilai vruntime. Pohon ini ditunjukkan di bawah ini.
T0
tugas dengan nilai

T1 T2
vruntime terkecil
T3 T4 T5 T6
T7 Q8 T9
lebih kecil lebih besar

nilai vruntime
Saat tugas menjadi dapat dijalankan, tugas itu ditambahkan ke pohon. Jika
tugas di pohon tidak dapat dijalankan (misalnya, jika diblokir saat menunggu I/
O), tugas tersebut akan dihapus. Secara umum, tugas yang diberi waktu
pemrosesan lebih sedikit (nilai vruntime lebih kecil) mengarah ke sisi kiri pohon,
dan tugas yang diberi waktu pemrosesan lebih banyak berada di sisi kanan.
Menurut properti pohon pencarian biner, simpul paling kiri memiliki nilai kunci
terkecil, yang demi penjadwal CFS berarti itu adalah tugas dengan prioritas
tertinggi. Karena pohon merah-hitam seimbang, menavigasinya untuk menemukan
simpul paling kiri akan membutuhkan operasi O(log N) (di mana N adalah jumlah
simpul di pohon). Namun, untuk alasan efisiensi, penjadwal Linux menyimpan
nilai ini dalam variabel rb paling kiri, dan dengan demikian menentukan tugas
mana yang akan dijalankan selanjutnya hanya memerlukan pengambilan nilai yang di-c
akhirnya menjadi lebih rendah untuk tugas terikat-I/O daripada tugas terikat- CPU,
memberikan tugas terikat- I/O prioritas lebih tinggi daripada tugas terikat-CPU. Pada saat
itu, jika tugas terikat-CPU dijalankan ketika tugas terikat- I/O memenuhi syarat untuk
dijalankan (misalnya, ketika I/O tugas yang menunggu tersedia), tugas terikat-I/O akan
mendahului tugas terikat CPU.
Linux juga mengimplementasikan penjadwalan real-time menggunakan standar POSIX
seperti yang dijelaskan dalam Bagian 5.6.6. Setiap tugas yang dijadwalkan menggunakan
SCHED FIFO atau kebijakan SCHED RR real-time berjalan pada prioritas yang lebih tinggi
daripada tugas normal (non-real time). Linux menggunakan dua rentang prioritas terpisah,
satu untuk tugas waktu nyata dan yang kedua untuk tugas normal. Tugas waktu nyata diberi
prioritas statis dalam kisaran 0 hingga 99, dan tugas normal diberi prioritas dari 100 hingga 139.
Kedua rentang ini dipetakan ke dalam skema prioritas global di mana nilai numerik yang
lebih rendah menunjukkan prioritas relatif yang lebih tinggi. Tugas normal diberikan prioritas
waktu sebenarnya normal
0 99 100 139
lebih tinggi lebih rendah
prioritas
Gambar 5.26 Penjadwalan prioritas pada sistem Linux.
berdasarkan nilai bagusnya, di mana nilai 20 memetakan ke prioritas 100 dan nilai bagus
dari +19 peta hingga 139. Skema ini ditunjukkan pada Gambar 5.26.
Penjadwal CFS juga mendukung penyeimbangan beban, menggunakan teknik
canggih yang menyetarakan beban di antara inti pemrosesan namun juga NUMA sadar
dan meminimalkan migrasi utas. CFS mendefinisikan beban setiap utas sebagai kombinasi
dari prioritas utas dan tingkat rata-rata penggunaan CPU . Oleh karena itu, utas yang
memiliki prioritas tinggi, namun sebagian besar terikat I/O dan membutuhkan sedikit
penggunaan CPU , umumnya memiliki beban yang rendah, mirip dengan beban utas
berprioritas rendah yang memiliki utilisasi CPU yang tinggi. Dengan menggunakan metrik
ini, beban antrian adalah jumlah beban semua utas dalam antrian, dan penyeimbangan
hanya memastikan bahwa semua antrian memiliki beban yang kira-kira sama.
Akan tetapi, seperti yang disorot dalam Bagian 5.5.4, memigrasikan utas dapat
mengakibatkan penalti akses memori karena harus membatalkan konten cache atau, pada
sistem NUMA , menimbulkan waktu akses memori yang lebih lama. Untuk mengatasi
masalah ini, Linux mengidentifikasi sistem hierarki domain penjadwalan.
Sebuah domain penjadwalan adalah satu set inti CPU yang dapat diseimbangkan satu
sama lain. Ide ini diilustrasikan pada Gambar 5.27. Inti di setiap domain penjadwalan
dikelompokkan menurut cara mereka berbagi sumber daya sistem.
Misalnya, meskipun setiap inti yang ditunjukkan pada Gambar 5.27 mungkin memiliki
cache level 1 (L1) sendiri , pasangan inti berbagi cache level 2 (L2) dan dengan demikian
diatur ke dalam domain0 dan domain1 yang terpisah. Demikian juga, kedua domain ini
dapat berbagi cache level 3 (L3) , dan oleh karena itu diatur ke dalam domain level
prosesor (juga dikenal sebagai node NUMA ). Mengambil satu langkah lebih jauh ini, pada sistem
domain prosesor fisik

(NUMA node)
domain0 domain1
inti0 inti2
L2 L2
inti1 inti3
L3
Gambar 5.27 Penyeimbangan beban sadar NUMA dengan penjadwal CFS Linux.
domain tingkat sistem yang lebih besar akan menggabungkan node NUMA tingkat prosesor yang
terpisah.
Strategi umum di balik CFS adalah menyeimbangkan beban dalam domain, mulai dari
tingkat hierarki terendah. Menggunakan Gambar 5.27 sebagai contoh, awalnya sebuah thread
hanya akan bermigrasi antara core pada domain yang sama (yaitu dalam domain0 atau domain1.)
Load balancing pada tingkat berikutnya akan terjadi antara domain0 dan domain1. CFS enggan
untuk memigrasikan utas antara node NUMA yang terpisah jika utas akan dipindahkan lebih jauh
dari memori lokalnya, dan migrasi tersebut hanya akan terjadi di bawah ketidakseimbangan beban
yang parah. Sebagai aturan umum, jika keseluruhan sistem sibuk, CFS tidak akan memuat
keseimbangan di luar domain lokal ke setiap inti untuk menghindari hukuman latensi memori
sistem NUMA .
5.7.2 Contoh: Penjadwalan Windows Windows menjadwalkan
utas menggunakan algoritma penjadwalan preemptive berbasis prioritas. Penjadwal Windows

memastikan bahwa utas dengan prioritas tertinggi akan selalu berjalan. Bagian dari kernel
Windows yang menangani penjadwalan disebut dispatcher. Sebuah utas yang dipilih untuk
dijalankan oleh petugas operator akan berjalan hingga didahului oleh utas dengan prioritas lebih
tinggi, hingga berakhir, hingga kuantum waktunya berakhir, atau hingga memanggil panggilan
sistem pemblokiran, seperti untuk I/O. Jika utas waktu nyata dengan prioritas lebih tinggi menjadi
siap saat utas dengan prioritas lebih rendah sedang berjalan, utas dengan prioritas lebih rendah
akan didahulukan. Preemption ini memberikan akses preferensi utas waktu-nyata ke CPU ketika
utas membutuhkannya
mengakses.
Dispatcher menggunakan skema prioritas 32 tingkat untuk menentukan urutan eksekusi

thread. Prioritas dibagi menjadi dua kelas. Kelas variabel berisi utas yang memiliki prioritas dari 1
hingga 15, dan kelas waktu nyata berisi utas dengan prioritas mulai dari 16 hingga 31. (Ada juga
utas yang berjalan pada prioritas 0 yang digunakan untuk manajemen memori.) Dispatcher
menggunakan a antrian untuk setiap prioritas penjadwalan dan melintasi kumpulan antrian dari
tertinggi ke terendah hingga menemukan utas yang siap dijalankan. Jika tidak ada utas siap yang
ditemukan, petugas operator akan menjalankan utas khusus yang disebut utas idle.
Ada hubungan antara prioritas numerik dari kernel Windows dan Windows API. Windows API
mengidentifikasi enam kelas prioritas berikut yang menjadi milik suatu proses:
• KELAS PRIORITAS IDLE
• DI BAWAH KELAS PRIORITAS NORMAL
• KELAS PRIORITAS NORMAL
• KELAS PRIORITAS DI ATAS NORMAL
• KELAS PRIORITAS TINGGI
• KELAS PRIORITAS REALTIME
Proses biasanya anggota KELAS PRIORITAS NORMAL. Suatu proses termasuk dalam kelas ini
kecuali jika induk dari proses tersebut adalah anggota dari KELAS PRIORITAS IDLE atau kecuali
jika kelas lain ditentukan saat proses dibuat. Selain itu, kelas prioritas dari suatu proses dapat
diubah dengan
fungsi SetPriorityClass() di Windows API. Prioritas di semua kelas kecuali REALTIME
PRIORITY CLASS adalah variabel, artinya prioritas thread milik salah satu kelas ini
dapat berubah.
Sebuah thread dalam kelas prioritas yang diberikan juga memiliki prioritas relatif.
Nilai untuk prioritas relatif meliputi:
• IDLE
• TERENDAH
• DI BAWAH NORMAL
• NORMAL
• DI ATAS NORMAL
• TERTINGGI
• WAKTU KRITIS
Prioritas setiap utas didasarkan pada kelas prioritas yang dimilikinya dan prioritas
relatifnya di dalam kelas itu. Hubungan ini ditunjukkan pada Gambar 5.28. Nilai dari
kelas prioritas muncul di baris atas. Kolom kiri berisi nilai untuk prioritas relatif. Misalnya,
jika prioritas relatif dari sebuah utas di KELAS PRIORITAS DI ATAS NORMAL adalah
NORMAL, prioritas numerik dari utas itu adalah 10.
Selanjutnya, setiap utas memiliki prioritas dasar yang mewakili nilai dalam rentang
prioritas untuk kelas tempat utas tersebut berada. Secara default, prioritas dasar adalah
nilai prioritas relatif NORMAL untuk kelas tersebut. Prioritas dasar untuk setiap kelas
prioritas adalah sebagai berikut:
• KELAS PRIORITAS REALTIME—24
• KELAS PRIORITAS TINGGI—13
• DI ATAS KELAS PRIORITAS NORMAL—10
• KELAS PRIORITAS NORMAL—8
waktu diatas dibawah prioritas

tinggi normal
sebenarnya normal normal menganggur
waktu kritis 31 15 15 15 15 15
paling tinggi 26 15 12 10 8 6
diatas normal 25 14 11 9 7 5
normal 24 13 10 8 6 4
dibawah normal 23 12 9 7 5 3
terendah 22 11 8 6 4 2
menganggur 16 1 1 1 1 1
Gambar 5.28 Prioritas utas Windows.

• DI BAWAH KELAS PRIORITAS NORMAL—6
• KELAS PRIORITAS IDLE—4
Prioritas awal utas biasanya merupakan prioritas dasar dari proses yang dimiliki utas,
meskipun fungsi SetThreadPriority() di Windows API juga dapat digunakan untuk
mengubah prioritas dasar utas.
Ketika kuantum waktu utas habis, utas itu terputus. Jika utas berada di kelas
prioritas variabel, prioritasnya diturunkan. Namun, prioritas tidak pernah diturunkan di
bawah prioritas dasar. Menurunkan prioritas cenderung membatasi konsumsi CPU dari
thread yang terikat komputasi. Ketika utas prioritas variabel dilepaskan dari operasi
tunggu, petugas operator meningkatkan prioritas. Jumlah dorongan tergantung pada
apa yang ditunggu oleh utas.
Misalnya, utas yang menunggu I/O keyboard akan mendapatkan peningkatan yang
besar, sedangkan utas yang menunggu operasi disk akan mendapatkan yang sedang.
Strategi ini cenderung memberikan waktu respon yang baik untuk thread interaktif yang
menggunakan mouse dan windows. Ini juga memungkinkan utas terikat-I/O untuk
membuat perangkat I/O tetap sibuk sementara mengizinkan utas terikat-komputasi
untuk menggunakan siklus CPU cadangan di latar belakang. Strategi ini digunakan oleh
beberapa sistem operasi, termasuk UNIX. Selain itu, jendela tempat pengguna
berinteraksi saat ini menerima peningkatan prioritas untuk meningkatkan waktu responsnya
Ketika pengguna menjalankan program interaktif, sistem perlu memberikan kinerja
yang sangat baik. Untuk alasan ini, Windows memiliki aturan penjadwalan khusus untuk
proses di KELAS PRIORITAS NORMAL. Windows membedakan antara proses latar
depan yang saat ini dipilih di layar dan proses latar belakang yang saat ini tidak dipilih.
Ketika sebuah proses bergerak ke latar depan, Windows meningkatkan kuantum
penjadwalan dengan beberapa faktor— biasanya sebesar 3. Peningkatan ini memberikan
proses latar depan tiga kali lebih lama untuk dijalankan sebelum preemption pembagian
waktu terjadi.
Windows 7 memperkenalkan penjadwalan mode pengguna (UMS), yang
memungkinkan aplikasi membuat dan mengelola utas secara independen dari kernel.
Dengan demikian, aplikasi dapat membuat dan menjadwalkan banyak utas tanpa
melibatkan penjadwal kernel Windows. Untuk aplikasi yang membuat sejumlah besar
utas, penjadwalan utas dalam mode pengguna jauh lebih efisien daripada penjadwalan
utas mode kernel, karena tidak diperlukan intervensi kernel.
Versi Windows sebelumnya menyediakan fitur serupa yang dikenal sebagai serat ,
yang memungkinkan beberapa utas mode pengguna (serat) dipetakan ke utas kernel
tunggal. Namun, serat memiliki penggunaan praktis yang terbatas. Serat tidak dapat
melakukan panggilan ke Windows API karena semua serat harus berbagi blok
lingkungan utas (TEB) dari utas tempat mereka berjalan. Hal ini menimbulkan masalah
jika fungsi Windows API menempatkan informasi status ke dalam TEB untuk satu serat,
hanya agar informasi tersebut ditimpa oleh serat yang berbeda.
UMS mengatasi kendala ini dengan menyediakan setiap thread mode pengguna dengan konteks
threadnya sendiri.
Selain itu, tidak seperti fiber, UMS tidak dimaksudkan untuk digunakan langsung
oleh programmer. Detail penulisan penjadwal mode pengguna bisa sangat menantang,
dan UMS tidak menyertakan penjadwal seperti itu. Sebaliknya, penjadwal berasal dari
perpustakaan bahasa pemrograman yang dibangun di atas UMS. Misalnya, Microsoft
menyediakan Concurrency Runtime (ConcRT), kerangka kerja pemrograman
bersamaan untuk C++ yang dirancang untuk paralelisme berbasis tugas
(Bagian 4.2) pada prosesor multicore. ConcRT menyediakan penjadwal mode pengguna
bersama dengan fasilitas untuk menguraikan program menjadi tugas, yang kemudian dapat
dijadwalkan pada inti pemrosesan yang tersedia.
Windows juga mendukung penjadwalan pada sistem multiprosesor seperti yang dijelaskan
dalam Bagian 5.5 dengan mencoba menjadwalkan utas pada inti pemrosesan paling optimal
untuk utas itu, yang mencakup pemeliharaan pilihan utas serta prosesor terbaru. Salah satu
teknik yang digunakan oleh Windows adalah membuat set prosesor logis (dikenal sebagai set
SMT ). Pada sistem SMT hyper-threaded , utas perangkat keras milik inti CPU yang sama
juga akan menjadi milik set SMT yang sama . Prosesor logis diberi nomor, mulai dari 0.
Sebagai contoh, sistem dual-threaded/quad-core akan berisi delapan prosesor logis, yang
terdiri dari empat set SMT : {0, 1}, {2, 3}, {4, 5}, dan {6, 7}. Untuk menghindari hukuman akses
memori cache yang disorot dalam Bagian 5.5.4, penjadwal mencoba untuk mempertahankan
utas yang berjalan pada prosesor logis dalam set SMT yang sama .
Untuk mendistribusikan beban di prosesor logis yang berbeda, setiap utas diberi prosesor
yang ideal, yang merupakan nomor yang mewakili prosesor pilihan utas. Setiap proses
memiliki nilai benih awal yang mengidentifikasi CPU ideal untuk utas yang termasuk dalam
proses itu. Benih ini bertambah untuk setiap utas baru yang dibuat oleh proses itu, sehingga
mendistribusikan beban ke berbagai prosesor logis. Pada sistem SMT , peningkatan untuk
prosesor ideal berikutnya ada di set SMT berikutnya. Misalnya, pada sistem dual-threaded/
quad-core, prosesor yang ideal untuk thread dalam proses tertentu akan diberi 0, 2, 4, 6, 0,
2, .... Untuk menghindari situasi di mana thread pertama untuk setiap proses diberi prosesor
0, proses diberi nilai benih yang berbeda, sehingga mendistribusikan beban utas di semua inti
pemrosesan fisik dalam sistem. Melanjutkan contoh kita di atas, jika benih untuk proses kedua
adalah 1, prosesor yang ideal akan ditempatkan dalam urutan 1, 3, 5, 7, 1, 3, dan seterusnya.
5.7.3 Contoh: Penjadwalan Solaris Solaris

menggunakan penjadwalan thread berbasis prioritas. Setiap utas milik salah satu
dari enam kelas:
1. Pembagian waktu (TS)

2. Interaktif (IA)
3. Waktu nyata (RT)
4. Sistem (SYS)
5. Bagian yang adil (FSS)
6. Prioritas tetap (FP)
Dalam setiap kelas ada prioritas yang berbeda dan algoritma penjadwalan yang berbeda.
Kelas penjadwalan default untuk suatu proses adalah pembagian waktu. Kebijakan
penjadwalan untuk kelas pembagian waktu secara dinamis mengubah prioritas dan menetapkan
irisan waktu dengan panjang yang berbeda menggunakan antrean umpan balik bertingkat.
Secara default, ada hubungan terbalik antara prioritas dan irisan waktu. Semakin tinggi
takut kuantum
prioritas berapa waktu kedaluwarsa kembali dari tidur
0 200 0 50
5 200 0 50
10 160 0 51
15 160 5 51
20 120 10 52
25 120 15 52
30 80 20 53
35 80 25 54
40 40 30 55
45 40 35 56
50 40 40 58
55 40 45 58
59 20 49 59
Gambar 5.29 Tabel pengiriman Solaris untuk berbagi waktu dan utas interaktif.
prioritas, semakin kecil irisan waktu; dan semakin rendah prioritas, semakin besar irisan
waktu. Proses interaktif biasanya memiliki prioritas yang lebih tinggi; Proses terikat CPU,
prioritas lebih rendah. Kebijakan penjadwalan ini memberikan waktu respons yang baik untuk
proses interaktif dan throughput yang baik untuk proses terikat CPU. Kelas interaktif
menggunakan kebijakan penjadwalan yang sama dengan kelas pembagian waktu, tetapi
memberikan aplikasi windowing—seperti yang dibuat oleh manajer jendela KDE atau GNOME
—prioritas yang lebih tinggi untuk kinerja yang lebih baik.
Gambar 5.29 menunjukkan tabel pengiriman yang disederhanakan untuk penjadwalan
pembagian waktu dan utas interaktif. Kedua kelas penjadwalan ini mencakup 60 tingkat
prioritas, tetapi untuk singkatnya, kami hanya menampilkan sedikit. (Untuk melihat tabel
pengiriman lengkap pada sistem Solaris atau VM, jalankan dispadmin -c TS -g.) Tabel
pengiriman yang ditunjukkan pada Gambar 5.29 berisi bidang berikut:
• Prioritas. Prioritas tergantung kelas untuk berbagi waktu dan interaktif

kelas. Angka yang lebih tinggi menunjukkan prioritas yang lebih tinggi.
• Kuantum waktu. Kuantum waktu untuk prioritas terkait. Ini menggambarkan hubungan
terbalik antara prioritas dan kuanta waktu: prioritas terendah (prioritas 0) memiliki
kuantum waktu tertinggi (200 milidetik), dan prioritas tertinggi (prioritas 59) memiliki
kuantum waktu terendah (20 milidetik).
• Kuantum waktu berakhir. Prioritas baru utas yang telah menggunakan kuantum sepanjang
waktu tanpa pemblokiran. Utas seperti itu dianggap intensif CPU . Seperti yang
ditunjukkan pada tabel, utas ini memiliki prioritas rendah.
• Kembali dari tidur. Prioritas utas yang kembali dari tidur (seperti dari menungguI /O).
Seperti yang diilustrasikan tabel, ketika I/O tersedia untuk utas tunggu, prioritasnya
ditingkatkan menjadi antara 50 dan 59, mendukung kebijakan penjadwalan untuk
menyediakan waktu respons yang baik untuk proses interaktif.
Utas di kelas waktu nyata diberi prioritas tertinggi. Proses real-time akan berjalan sebelum
proses di kelas lain. Penugasan ini memungkinkan proses waktu nyata untuk mendapatkan
respons yang dijamin dari sistem dalam periode waktu yang dibatasi. Namun, secara umum,
beberapa proses termasuk dalam kelas waktu nyata.
Solaris menggunakan kelas sistem untuk menjalankan utas kernel, seperti penjadwal dan
daemon paging. Setelah prioritas utas sistem ditetapkan, itu tidak berubah. Kelas sistem
dicadangkan untuk penggunaan kernel (proses pengguna yang berjalan dalam mode kernel
tidak berada di kelas sistem).
Kelas prioritas tetap dan pembagian adil diperkenalkan dengan Solaris 9.
Utas di kelas prioritas tetap memiliki rentang prioritas yang sama dengan yang ada di kelas
berbagi waktu; namun, prioritas mereka tidak disesuaikan secara dinamis.
Kelas pembagian adil menggunakan pembagian CPU alih-alih prioritas untuk membuat
keputusan penjadwalan. Pembagian CPU menunjukkan hak atas sumber daya CPU yang tersedia da
dialokasikan ke satu set proses (dikenal sebagai proyek).
Setiap kelas penjadwalan mencakup serangkaian prioritas. Namun, penjadwal mengubah
prioritas khusus kelas menjadi prioritas global dan memilih utas dengan prioritas global tertinggi
untuk dijalankan. Utas yang dipilih berjalan pada CPU sampai (1) memblokir, (2) menggunakan
irisan waktunya, atau (3) didahului oleh utas dengan prioritas lebih tinggi. Jika ada beberapa
utas dengan prioritas yang sama, penjadwal menggunakan antrian round-robin. Gambar 5.30
mengilustrasikan bagaimana enam kelas penjadwalan berhubungan satu sama lain dan
bagaimana mereka dipetakan ke prioritas global. Perhatikan bahwa kernel memelihara sepuluh
utas untuk melayani interupsi. Utas ini bukan milik kelas penjadwalan apa pun dan dijalankan
pada prioritas tertinggi (160-169).
Seperti disebutkan, Solaris secara tradisional menggunakan model banyak-ke-banyak (Bagian
4.3.3) tetapi beralih ke model satu-ke-satu (Bagian 4.3.2) yang dimulai dengan Solaris 9.
5.8 Evaluasi Algoritma

Bagaimana kita memilih algoritma penjadwalan CPU untuk sistem tertentu? Seperti yang kita
lihat di Bagian 5.3, ada banyak algoritma penjadwalan, masing-masing dengan parameternya
sendiri. Akibatnya, memilih algoritma bisa jadi sulit.
Masalah pertama adalah mendefinisikan kriteria yang akan digunakan dalam memilih
suatu algoritma. Seperti yang kita lihat di Bagian 5.2, kriteria sering didefinisikan dalam hal
penggunaan CPU , waktu respons, atau throughput. Untuk memilih suatu algoritma, pertama-
tama kita harus mendefinisikan kepentingan relatif dari elemen-elemen ini. Kriteria kami dapat
mencakup beberapa ukuran, seperti ini:
• Memaksimalkan penggunaan CPU dengan batasan waktu respons maksimum adalah 300
milidetik
5.8 Evaluasi Algoritma 245
prioritas penjadwalan
global pesanan
169
paling tinggi pertama
mengganggu utas
160
159
utas waktu nyata (RT)
100
99
sistem (SYS) utas
60
59
utas pembagian yang adil (FSS)
utas prioritas tetap (FX)
utas timeshare (TS)
utas interaktif (IA)

terendah 0 terakhir
Gambar 5.30 Penjadwalan Solaris.
• Memaksimalkan throughput sehingga waktu penyelesaian (rata-rata)

berbanding lurus dengan total waktu eksekusi
Setelah kriteria seleksi telah ditentukan, kami ingin mengevaluasi algoritma yang sedang
dipertimbangkan. Kami selanjutnya menjelaskan berbagai metode evaluasi
kita bisa menggunakan.
5.8.1 Pemodelan Deterministik

Salah satu kelas utama dari metode evaluasi adalah evaluasi analitik. Evaluasi analitik
menggunakan algoritme yang diberikan dan beban kerja sistem untuk menghasilkan rumus atau
angka untuk mengevaluasi kinerja algoritme untuk beban kerja tersebut.
Pemodelan deterministik adalah salah satu jenis evaluasi analitik. Metode ini mengambil
beban kerja tertentu yang telah ditentukan sebelumnya dan mendefinisikan kinerja setiap algoritma
untuk beban kerja tersebut. Misalnya, asumsikan bahwa kita memiliki beban kerja yang ditunjukkan
di bawah ini. Kelima proses tiba pada waktu 0, dalam urutan yang diberikan, dengan panjang CPU
burst diberikan dalam milidetik:
P1 10
P2 29
P3 3
P4 7
P5 12
Pertimbangkan algoritma penjadwalan FCFS, SJF, dan RR (kuantum = 10 milidetik) untuk

rangkaian proses ini. Algoritma mana yang akan memberikan nilai minimum
waktu tunggu rata-rata?
Untuk algoritma FCFS , kami akan menjalankan proses sebagai
P1 P2 P3 P4 P5
0 10 39 42 49 61
P2, 39 milidetik untuk proses P3, 42 milidetik untuk proses P4, dan 49
milidetik untuk proses P5. Jadi, waktu tunggu rata-rata adalah (0 + 10 + 39 +
42 + 49)/5 = 28 milidetik.
Dengan penjadwalan SJF nonpreemptive , kami menjalankan proses sebagai
P3 P4 P1 P5 P2
03 10 20 32 61
P2, 0 milidetik untuk proses P3, 3 milidetik untuk proses P4, dan 20 milidetik untuk proses P5.
Jadi, waktu tunggu rata-rata adalah (10 + 32 + 0 + 3 + 20)/5
= 13 milidetik.
Dengan algoritma RR , kami menjalankan proses sebagai
P1 P2 P3 P4 P5 P2 P5 P2
0 10 20 23 30 40 50 52 61
P2, 20 milidetik untuk proses P3, 23 milidetik untuk proses P4, dan 40
milidetik untuk proses P5. Jadi, waktu tunggu rata-rata adalah (0 + 32 + 20 +
23 + 40)/5 = 23 milidetik.
Kita dapat melihat bahwa, dalam hal ini, waktu tunggu rata-rata yang diperoleh dengan SJF
kebijakan kurang dari setengah yang diperoleh dengan penjadwalan FCFS ; algoritma RR _
memberi kita nilai menengah.
Pemodelan deterministik sederhana dan cepat. Ini memberi kita angka pasti, memungkinkan
kita untuk membandingkan algoritme. Namun, itu membutuhkan angka yang tepat untuk input,
dan jawabannya hanya berlaku untuk kasus-kasus itu. Penggunaan utama deterministik
pemodelan dalam menggambarkan algoritma penjadwalan dan memberikan contoh.
Dalam kasus di mana kita menjalankan program yang sama berulang-ulang dan dapat
mengukur kebutuhan pemrosesan program dengan tepat, kita mungkin dapat

menggunakan pemodelan deterministik untuk memilih algoritma penjadwalan. Lebih
jauh, melalui serangkaian contoh, pemodelan deterministik dapat menunjukkan tren
yang kemudian dapat dianalisis dan dibuktikan secara terpisah. Misalnya, dapat
ditunjukkan bahwa, untuk lingkungan yang dijelaskan (semua proses dan waktunya
tersedia pada waktu 0), kebijakan SJF akan selalu menghasilkan waktu tunggu minimum.
5.8.2 Model Antrian Pada banyak
sistem, proses yang dijalankan bervariasi dari hari ke hari, sehingga tidak ada kumpulan
proses (atau waktu) statis yang digunakan untuk pemodelan deterministik. Apa yang
dapat ditentukan, bagaimanapun, adalah distribusi CPU dan I/O burst. Distribusi ini
dapat diukur dan kemudian diperkirakan atau hanya diperkirakan. Hasilnya adalah
rumus matematika yang menggambarkan kemungkinan ledakan CPU tertentu.
Umumnya, distribusi ini eksponensial dan dijelaskan oleh rata-ratanya.
Demikian pula, kita dapat menggambarkan distribusi waktu ketika proses tiba di sistem
(distribusi waktu kedatangan). Dari kedua distribusi ini, dimungkinkan untuk menghitung
throughput rata-rata, utilisasi, waktu tunggu, dan seterusnya untuk sebagian besar
algoritma.
Sistem komputer digambarkan sebagai jaringan server. Setiap server memiliki
antrian proses menunggu. CPU adalah server dengan antrian siap, seperti sistem I/O
dengan antrian perangkatnya. Mengetahui tingkat kedatangan dan tingkat layanan, kita
dapat menghitung utilisasi, panjang antrian rata-rata, waktu tunggu rata-rata, dan sebagainy
Bidang studi ini disebut analisis jaringan antrian.
Sebagai contoh, misalkan n adalah rata-rata panjang antrian jangka panjang (tidak
termasuk proses yang dilayani), misalkan W adalah waktu tunggu rata-rata dalam
antrian, dan misalkan adalah laju kedatangan rata-rata untuk proses baru dalam antrian
(seperti tiga proses per detik). Kami berharap bahwa selama W proses menunggu, × W
proses baru akan tiba di antrian. Jika sistem dalam keadaan tunak, maka jumlah proses
yang keluar dari antrian harus sama dengan jumlah proses yang datang. Dengan
demikian,
n = × W.
Persamaan ini, yang dikenal sebagai rumus Little, sangat berguna karena valid untuk
semua algoritma penjadwalan dan distribusi kedatangan. Misalnya n bisa menjadi
jumlah pelanggan di toko.
Kita dapat menggunakan rumus Little untuk menghitung salah satu dari tiga variabel
jika kita mengetahui dua variabel lainnya. Misalnya, jika kita mengetahui bahwa 7
proses tiba setiap detik (rata-rata) dan biasanya ada 14 proses dalam antrian, maka kita
dapat menghitung waktu tunggu rata-rata per proses sebagai 2 detik.
Analisis antrian dapat berguna dalam membandingkan algoritma penjadwalan,
tetapi juga memiliki keterbatasan. Saat ini, kelas algoritma dan distribusi yang dapat
ditangani cukup terbatas. Matematika dari algoritma dan distribusi yang rumit bisa jadi
sulit untuk dikerjakan. Dengan demikian, distribusi kedatangan dan layanan sering
didefinisikan dengan cara yang dapat dilacak secara matematis—tetapi tidak realistis
—. Secara umum juga perlu untuk membuat sejumlah asumsi independen, yang
mungkin tidak akurat. Sebagai akibat dari kesulitan-kesulitan ini, model antrian seringkali
hanya merupakan perkiraan dari sistem nyata, dan keakuratan hasil yang dihitung
mungkin dipertanyakan.
248
Bab 5 Penjadwalan CPU
5.8.3 Simulasi
Untuk mendapatkan evaluasi algoritma penjadwalan yang lebih akurat, kita dapat
menggunakan simulasi. Menjalankan simulasi melibatkan pemrograman model sistem
komputer. Struktur data perangkat lunak mewakili komponen utama sistem. Simulator
memiliki variabel yang mewakili jam. Saat nilai variabel ini meningkat, simulator
memodifikasi status sistem untuk mencerminkan aktivitas perangkat, proses, dan
penjadwal. Saat simulasi dijalankan, statistik yang menunjukkan kinerja algoritme
dikumpulkan dan dicetak.
Data untuk menjalankan simulasi dapat dihasilkan dalam beberapa cara. Metode
yang paling umum menggunakan generator nomor acak yang diprogram untuk
menghasilkan proses, waktu burst CPU , kedatangan, keberangkatan, dan sebagainya,
sesuai dengan distribusi probabilitas. Distribusi dapat didefinisikan secara matematis
(seragam, eksponensial, Poisson) atau secara empiris. Jika distribusi harus
didefinisikan secara empiris, pengukuran sistem aktual yang sedang dipelajari diambil.
Hasil mendefinisikan distribusi peristiwa dalam sistem nyata; distribusi ini kemudian
dapat digunakan untuk menjalankan simulasi.
Namun, simulasi berbasis distribusi mungkin tidak akurat, karena hubungan
antara peristiwa yang berurutan dalam sistem nyata. Distribusi frekuensi hanya
menunjukkan berapa banyak kejadian dari setiap kejadian yang terjadi; itu tidak
menunjukkan apa pun tentang urutan kemunculannya. Untuk memperbaiki masalah
ini, kita dapat menggunakan file jejak. Kami membuat jejak dengan memantau sistem
nyata dan merekam urutan kejadian aktual (Gambar 5.31). Kami kemudian
menggunakan urutan ini untuk menjalankan simulasi. File jejak menyediakan cara
terbaik untuk membandingkan dua algoritme pada set input nyata yang persis sama.
Metode ini dapat menghasilkan hasil yang akurat untuk inputnya.
Simulasi bisa mahal, seringkali membutuhkan berjam-jam waktu komputer.
Simulasi yang lebih rinci memberikan hasil yang lebih akurat, tetapi juga
statistik
simulasi kinerja
untuk FCFS
FCFS
•••
CPU 10
I/O 213
eksekusi CPU 12 statistik
proses I/O 112 simulasi kinerja
yang sebenarnya CPU 2 untuk SJF
I/O 147 SJF
CPU 173
•••
rekaman jejak
statistik
simulasi kinerja
untuk RR (q = 14)
RR (q = 14)
Gambar 5.31 Evaluasi penjadwal CPU dengan simulasi.

membutuhkan lebih banyak waktu komputer. Selain itu, file jejak dapat membutuhkan ruang
penyimpanan yang besar. Akhirnya, desain, pengkodean, dan debugging simulator bisa
menjadi tugas utama.
5.8.4 Implementasi
Bahkan simulasi memiliki akurasi yang terbatas. Satu-satunya cara yang sepenuhnya akurat
untuk mengevaluasi algoritme penjadwalan adalah dengan mengkodekannya, memasukkannya
ke dalam sistem operasi, dan melihat cara kerjanya. Pendekatan ini menempatkan algoritma
aktual dalam sistem nyata untuk evaluasi di bawah kondisi operasi nyata.
Cara ini bukannya tanpa biaya. Biaya dikeluarkan dalam pengkodean algoritma dan
memodifikasi sistem operasi untuk mendukungnya (bersama dengan struktur data yang
diperlukan). Ada juga biaya dalam menguji perubahan, biasanya di mesin virtual daripada di
perangkat keras khusus. Pengujian regresi menegaskan bahwa perubahan tersebut tidak
memperburuk keadaan, dan tidak menyebabkan bug baru atau menyebabkan bug lama dibuat
ulang (misalnya karena algoritme yang diganti memecahkan beberapa bug dan mengubahnya
menyebabkan bug tersebut muncul kembali).
Kesulitan lain adalah bahwa lingkungan di mana algoritma digunakan akan berubah.
Lingkungan akan berubah tidak hanya dengan cara biasa, karena program baru ditulis dan
jenis masalah berubah, tetapi juga sebagai akibat dari kinerja penjadwal. Jika proses pendek
diprioritaskan, maka pengguna dapat memecah proses yang lebih besar menjadi kumpulan
proses yang lebih kecil. Jika proses interaktif diprioritaskan daripada proses noninteraktif, maka
pengguna dapat beralih ke penggunaan interaktif. Masalah ini biasanya diatasi dengan
menggunakan alat atau skrip yang merangkum rangkaian tindakan lengkap, berulang kali
menggunakan alat tersebut, dan menggunakan alat tersebut saat mengukur hasil (dan
mendeteksi masalah apa pun yang ditimbulkannya di lingkungan baru).
Tentu saja perilaku manusia atau program dapat mencoba untuk menghindari algoritma
penjadwalan. Sebagai contoh, peneliti merancang satu sistem yang mengklasifikasikan proses
interaktif dan noninteraktif secara otomatis dengan melihat jumlah terminal I/O. Jika suatu
proses tidak memasukkan atau mengeluarkan ke terminal dalam interval 1 detik, proses
tersebut diklasifikasikan sebagai noninteraktif dan dipindahkan ke antrian dengan prioritas
lebih rendah. Menanggapi kebijakan ini, seorang programmer memodifikasi programnya untuk
menulis karakter arbitrer ke terminal secara berkala kurang dari 1 detik. Sistem memberikan
programnya prioritas tinggi, meskipun keluaran terminal sama sekali tidak berarti.
Secara umum, algoritma penjadwalan yang paling fleksibel adalah yang dapat diubah
oleh manajer sistem atau oleh pengguna sehingga dapat disesuaikan untuk aplikasi atau
kumpulan aplikasi tertentu. Workstation yang menjalankan aplikasi grafis kelas atas, misalnya,
mungkin memiliki kebutuhan penjadwalan yang berbeda dari server web atau server file.
Beberapa sistem operasi—khususnya beberapa versi UNIX—memungkinkan manajer sistem
untuk menyempurnakan parameter penjadwalan untuk konfigurasi sistem tertentu. Misalnya,
Solaris menyediakan perintah dispadmin untuk mengizinkan administrator sistem memodifikasi
parameter kelas penjadwalan yang dijelaskan dalam Bagian 5.7.3.
Pendekatan lain adalah dengan menggunakan API yang dapat mengubah prioritas proses
atau utas. Java, POSIX, dan Windows API menyediakan fungsi tersebut. Kelemahan dari
pendekatan ini adalah bahwa kinerja-tuning sistem atau aplikasi paling sering tidak
menghasilkan peningkatan kinerja dalam situasi yang lebih umum.
5.9 Ringkasan
• Penjadwalan CPU adalah tugas memilih proses menunggu dari antrian siap dan mengalokasikan
CPU ke dalamnya. CPU dialokasikan ke proses yang dipilih oleh operator.
• Algoritma penjadwalan dapat berupa preemptive (di mana CPU dapat diambil dari suatu proses)
atau nonpreemptive (di mana suatu proses harus secara sukarela melepaskan kendali dari
CPU). Hampir semua sistem operasi modern bersifat preemptive.
• Algoritma penjadwalan dapat dievaluasi menurut lima kriteria berikut: (1) pemanfaatan CPU , (2)
throughput, (3) waktu penyelesaian, (4) waktu tunggu, dan (5) waktu respons.
• Penjadwalan first-come, first-served (FCFS) adalah algoritma penjadwalan yang paling

sederhana, tetapi dapat menyebabkan proses yang pendek menunggu proses yang sangat lama.
• Penjadwalan shortest-job-first (SJF) terbukti optimal, memberikan waktu tunggu rata-rata

terpendek. Namun, menerapkan penjadwalan SJF sulit, karena memprediksi panjang CPU
burst berikutnya sulit.
• Penjadwalan round-robin (RR) mengalokasikan CPU ke setiap proses untuk kuantum waktu.
Jika proses tidak melepaskan CPU sebelum kuantum waktunya berakhir, proses akan
didahulukan, dan proses lain dijadwalkan untuk berjalan untuk kuantum waktu.
• Penjadwalan prioritas menetapkan setiap proses sebagai prioritas, dan CPU dialokasikan ke
proses dengan prioritas tertinggi. Proses dengan prioritas yang sama dapat dijadwalkan dalam
urutan FCFS atau menggunakan penjadwalan RR . • Penjadwalan antrian multilevel mempartisi
proses menjadi beberapa antrian terpisah yang diatur berdasarkan prioritas, dan penjadwal
mengeksekusi proses dalam antrian dengan prioritas tertinggi. Algoritma penjadwalan yang
berbeda dapat digunakan dalam setiap antrian.
• Antrian umpan balik bertingkat mirip dengan antrian bertingkat, kecuali bahwa suatu proses
dapat bermigrasi antara antrian yang berbeda. • Prosesor multicore menempatkan satu atau
lebih CPU pada chip fisik yang sama, dan setiap CPU mungkin memiliki lebih dari satu utas
perangkat keras. Dari perspektif sistem operasi, setiap utas perangkat keras tampaknya
merupakan CPU logis.
• Penyeimbangan beban pada sistem multiinti menyetarakan beban antar inti CPU , meskipun
migrasi utas antar inti untuk menyeimbangkan beban dapat membatalkan konten cache dan
oleh karena itu dapat meningkatkan waktu akses memori. • Penjadwalan waktu nyata yang
lembut memberikan prioritas pada tugas waktu nyata daripada tugas waktu nyata. Penjadwalan
waktu nyata yang sulit memberikan jaminan waktu untuk tugas waktu nyata,
• Penjadwalan real-time rate-monotonic menjadwalkan tugas-tugas periodik menggunakan a

kebijakan prioritas statis dengan preemption.
Latihan Latihan 251
• Penjadwalan tenggat waktu paling awal (EDF) menetapkan prioritas sesuai dengan
tenggat waktu. Semakin awal tenggat waktu, semakin tinggi prioritasnya; nanti
batas waktu, semakin rendah prioritasnya.
• Penjadwalan share proporsional mengalokasikan T share di antara semua aplikasi. Jika

aplikasi dialokasikan N bagian waktu, dipastikan memiliki NÿT dari
total waktu prosesor.
• Linux menggunakan penjadwal yang benar-benar adil (CFS), yang memberikan proporsi
waktu pemrosesan CPU untuk setiap tugas. Proporsi didasarkan pada virtual
runtime (vruntime) nilai yang terkait dengan setiap tugas.
• Penjadwalan Windows menggunakan skema prioritas 32 tingkat preemptive untuk

menentukan urutan penjadwalan thread.
• Solaris mengidentifikasi enam kelas penjadwalan unik yang dipetakan ke global
prioritas. Utas intensif CPU umumnya diberi prioritas yang lebih rendah
(dan kuantum waktu yang lebih lama), dan utas terikat I/O biasanya ditetapkan
prioritas yang lebih tinggi (dengan kuantum waktu yang lebih pendek.)
• Pemodelan dan simulasi dapat digunakan untuk mengevaluasi algoritma penjadwalan CPU
irama.
Latihan Latihan
5.1 Algoritme penjadwalan CPU menentukan urutan eksekusi

proses terjadwal. Diberikan n proses yang dijadwalkan pada satu proses, berapa banyak
jadwal berbeda yang mungkin? Berikan rumus dalam bentuk
dari n.
5.2 Jelaskan perbedaan antara jadwal preemptive dan nonpreemptive

pada.
5.3 Misalkan proses berikut tiba untuk dieksekusi pada waktu:

ditunjukkan. Setiap proses akan berjalan selama jumlah waktu yang tercantum. Dalam
menjawab pertanyaan, gunakan penjadwalan nonpreemptive, dan dasarkan semua keputusan
pada informasi yang Anda miliki pada saat keputusan harus dibuat.
Proses Jam kedatangan Waktu Meledak
P1 0,0 8
P2 0,4 4
P3 1,0 1
sebuah. Berapa waktu penyelesaian rata-rata untuk proses ini dengan

Algoritma penjadwalan FCFS ?
b. Berapa waktu penyelesaian rata-rata untuk proses ini dengan

Algoritma penjadwalan SJF ?
c. Algoritma SJF seharusnya meningkatkan kinerja, tetapi perhatikan

bahwa kami memilih untuk menjalankan proses P1 pada waktu 0 karena kami tidak tahu
bahwa dua proses yang lebih pendek akan segera tiba. Hitung apa
waktu penyelesaian rata-rata adalah jika CPU dibiarkan menganggur untuk yang pertama
1 unit dan kemudian penjadwalan SJF digunakan. Ingat proses itu
P1 dan P2 sedang menunggu selama waktu idle ini, jadi waktu tunggu mereka
dapat meningkat. Algoritma ini bisa dikenal sebagai pengetahuan masa depan
penjadwalan.
5.4 Pertimbangkan rangkaian proses berikut, dengan panjang CPU burst

waktu yang diberikan dalam milidetik:

2 2
P1
1 1
P2
8 4
P3
4 2
P4
5 3
P5
Proses diasumsikan telah tiba dalam urutan P1, P2, P3, P4, P5,
semua pada waktu 0.
sebuah. Gambarkan empat bagan Gantt yang mengilustrasikan eksekusi proses ini
menggunakan algoritma penjadwalan berikut: FCFS, SJF, prioritas non-preemptive
(angka prioritas yang lebih besar menyiratkan semakin tinggi
prioritas), dan RR (kuantum = 2).
b. Berapa waktu penyelesaian setiap proses untuk masing-masing?

algoritma penjadwalan di bagian a?
c. Berapa waktu tunggu dari setiap proses untuk masing-masing algoritma penjadwalan ini?
d. Manakah dari algoritma yang menghasilkan rata-rata menunggu minimum?

waktu (atas semua proses)?
5.5 Proses berikut sedang dijadwalkan menggunakan algoritma penjadwalan round robin preemptive.
Proses Prioritas Meletus Kedatangan
40 30 20 0
P1
30 35 25 25
P2
5 10 25 30
P3
15 60
P4
10 100
P5
10 105
P6
Setiap proses diberi prioritas numerik, dengan angka yang lebih tinggi menunjukkan prioritas
relatif yang lebih tinggi. Selain proses yang tercantum di bawah ini,
sistem juga memiliki tugas menganggur (yang tidak menggunakan sumber daya CPU dan
diidentifikasi sebagai Pidle). Tugas ini memiliki prioritas 0 dan dijadwalkan ketika sistem tidak
memiliki proses lain yang tersedia untuk dijalankan. panjang dari
Latihan Latihan 253
kuantum waktu adalah 10 satuan. Jika suatu proses didahului oleh proses dengan prioritas
lebih tinggi, proses yang didahulukan ditempatkan di akhir antrian.
sebuah. Tunjukkan urutan penjadwalan proses menggunakan bagan Gantt. b. Apa
waktu penyelesaian untuk setiap proses? c. Berapa waktu tunggu untuk setiap proses?
d. Berapa tingkat pemanfaatan CPU ?
5.6 Apa keuntungan memiliki ukuran kuantum waktu yang berbeda pada tingkat yang berbeda
dari sistem antrian bertingkat?
5.7 Banyak algoritma penjadwalan CPU yang diparameterisasi. Misalnya, algoritma RR

membutuhkan parameter untuk menunjukkan irisan waktu. Antrian umpan balik bertingkat
memerlukan parameter untuk menentukan jumlah antrian, algoritma penjadwalan untuk
setiap antrian, kriteria yang digunakan untuk memindahkan proses antar antrian, dan
sebagainya.
Oleh karena itu, algoritme ini benar-benar kumpulan algoritme (misalnya, himpunan
algoritme RR untuk semua irisan waktu, dan seterusnya). Satu set algoritme dapat
menyertakan yang lain (misalnya, algoritme FCFS adalah algoritme RR dengan kuantum
waktu tak terhingga). Apa (jika ada) hubungan antara pasangan set algoritma berikut?
sebuah. Prioritas dan
SJF b. Antrian umpan balik bertingkat dan FCFS c.
Prioritas dan FCFS d. RR dan SJF
5.8 Misalkan algoritma penjadwalan CPU mendukung proses-proses yang telah menggunakan
waktu prosesor paling sedikit di masa lalu. Mengapa algoritme ini mendukung program
terikat-I/O namun tidak secara permanen membuat program terikat-CPU kelaparan?
5.9 Bedakan antara penjadwalan PCS dan SCS .
5.10 Penjadwal UNIX tradisional memberlakukan hubungan terbalik antara nomor prioritas dan
prioritas: semakin tinggi angkanya, semakin rendah prioritasnya. Penjadwal menghitung
ulang prioritas proses sekali per detik menggunakan fungsi berikut:
Prioritas = ( penggunaan CPU baru-baru ini / 2) + basis
di mana basis = 60 dan penggunaan CPU terbaru mengacu pada nilai yang menunjukkan
seberapa sering suatu proses telah menggunakan CPU sejak prioritas terakhir dihitung ulang.
Asumsikan bahwa penggunaan CPU baru-baru ini untuk proses P1 adalah 40, untuk
proses P2 adalah 18, dan untuk proses P3 adalah 10. Apa prioritas baru untuk ketiga proses
ini ketika prioritas dihitung ulang? Berdasarkan informasi ini, apakah penjadwal UNIX
tradisional menaikkan atau menurunkan prioritas relatif dari proses terikat-CPU?
Bacaan lebih lanjut
Kebijakan penjadwalan yang digunakan dalam UNIX FreeBSD 5.2 disajikan

oleh [McKusick et al. (2015)]; Penjadwal CFS Linux dijelaskan lebih lanjut di
https://www.ibm.com/developerworks/library/l-completely-fair-scheduler/.
Penjadwalan Solaris dijelaskan oleh [Mauro dan McDougall (2007)]. [Russi
novich dkk. (2017)] membahas penjadwalan di internal Windows. [Butenhof
(1997)] dan [Lewis dan Berg (1998)] menjelaskan penjadwalan dalam sistem Pthread
Penjadwalan multicore diperiksa di [McNairy dan Bhatia (2005)], [Kongetira et
al. (2005)], dan [Siddha et al. (2007)] .
Bibliografi
[Butenhof (1997)] D. Butenhof, Pemrograman dengan Thread POSIX, tambahan

Wesley (1997).
[Kongetira dkk. (2005)] P. Kongetira, K. Aingaran, dan K. Olukotun, “Niagara:
Prosesor SPARC 32-Way Multithreaded,” Majalah Mikro IEEE, Volume 25, Nomor
2 (2005), halaman 21–29.
[Lewis dan Berg (1998)] B. Lewis dan D. Berg, Pemrograman Multithreaded dengan
Pthreads, Sun Microsystems Press (1998).
[Mauro dan McDougall (2007)] J. Mauro dan R. McDougall, Solaris Internal:
Arsitektur Inti Kernel, Prentice Hall (2007).
[McKusick dkk. (2015)] MK McKusick, GV Neville-Neil, dan RNM Wat son, Desain
dan Implementasi Sistem Operasi UNIX FreeBSD –Edisi Kedua, Pearson (2015).
[McNairy dan Bhatia (2005)] C. McNairy dan R. Bhatia, “Montecito: Prosesor Itanium
Inti Ganda, Berulir Ganda”, Majalah Mikro IEEE, Volume 25, Nomor 2 (2005),
halaman 10–20.
[Russinovich dkk. (2017)] M. Russinovich, DA Solomon, dan A. Ionescu, Win
dows Internal –Bagian 1, Edisi Ketujuh, Microsoft Press (2017).
[Siddha dkk. (2007)] S. Siddha, V. Pallipadi, dan A. Mallick, “Tantangan Penjadwalan
Proses di Era Prosesor Multi-Core”, Jurnal Teknologi Intel, Volume 11, Nomor 4
(2007).
Latihan EX-12
Bab 5 Latihan
5.11 Dari dua jenis program ini:
sebuah. I/O-terikat
b. terikat CPU
mana yang lebih mungkin memiliki sakelar konteks sukarela, dan mana yang lebih
mungkin memiliki sakelar konteks non-sukarela? Jelaskan Anda
menjawab.
5.12 Diskusikan bagaimana pasangan kriteria penjadwalan berikut ini saling bertentangan
pengaturan.
sebuah. Utilisasi CPU dan waktu respons
b. Waktu penyelesaian rata-rata dan waktu tunggu maksimum

c. Pemanfaatan perangkat I/O dan pemanfaatan CPU
5.13 Salah satu teknik untuk menerapkan penjadwalan lotere bekerja dengan menetapkan
proses tiket lotre, yang digunakan untuk mengalokasikan waktu CPU . Kapan pun
keputusan penjadwalan harus dibuat, tiket lotre dipilih secara acak, dan proses yang
memegang tiket itu mendapatkan CPU. Sistem operasi BTV menerapkan penjadwalan
lotre dengan mengadakan lotre 50 kali setiap detik, dengan setiap pemenang lotre
mendapatkan 20 milidetik waktu CPU (20 milidetik × 50 = 1 detik). Jelaskan bagaimana
penjadwal BTV dapat memastikan bahwa utas dengan prioritas lebih tinggi menerima
lebih banyak perhatian dari CPU daripada utas dengan prioritas lebih rendah.
5.14 Sebagian besar algoritme penjadwalan mempertahankan antrian proses, yang

mencantumkan proses yang memenuhi syarat untuk dijalankan pada prosesor. Pada
sistem multicore, ada dua opsi umum: (1) setiap inti pemrosesan memiliki antrian run
sendiri, atau (2) antrian run tunggal dibagi oleh semua inti pemrosesan. Apa kelebihan
dan kekurangan dari masing-masing pendekatan tersebut?
5.15 Pertimbangkan rumus rata-rata eksponensial yang digunakan untuk memprediksi panjang
CPU burst berikutnya. Apa implikasi dari menetapkan nilai berikut ke parameter yang
digunakan oleh algoritme?
sebuah. = 0 dan 0 = 100 milidetik
b. = 0,99 dan 0 = 10 milidetik
5.16 Sebuah variasi dari penjadwal round-robin adalah penjadwal round-robin regresif . Penjadwal
ini menetapkan setiap proses kuantum waktu dan prioritas. Nilai awal kuantum waktu
adalah 50 milidetik. Namun, setiap kali sebuah proses telah dialokasikan CPU dan
menggunakan seluruh kuantum waktunya (tidak memblokir untuk I/O), 10 milidetik
ditambahkan ke kuantum waktunya, dan tingkat prioritasnya ditingkatkan. (Kuantum waktu
untuk suatu proses dapat ditingkatkan hingga maksimum 100 milidetik.) Ketika sebuah
proses memblokir sebelum menggunakan seluruh kuantum waktunya, kuantum waktunya
berkurang 5 milidetik, tetapi prioritasnya tetap sama. Jenis proses apa (terikat CPU atau
terikat I/O) yang disukai penjadwal round-robin regresif? Menjelaskan.
EX-13
5.17 Pertimbangkan rangkaian proses berikut, dengan panjang CPU burst

P1 5 4
P2 3 1
P3 1 2
P4 7 2
P5 4 3
Proses diasumsikan telah tiba dalam urutan P1, P2, P3, P4, P5,
semua pada waktu 0.
sebuah. Gambarkan empat bagan Gantt yang mengilustrasikan eksekusi proses

ini menggunakan algoritma penjadwalan berikut: FCFS, SJF, prioritas non-
preemptive (angka prioritas yang lebih besar menyiratkan semakin tinggi
prioritas), dan RR (kuantum = 2).
b. Berapa waktu penyelesaian setiap proses untuk masing-masing?

algoritma penjadwalan di bagian a?
c. Berapa waktu tunggu dari setiap proses untuk masing-masing algoritma

penjadwalan ini?
d. Manakah dari algoritma yang menghasilkan rata-rata menunggu minimum?

waktu (atas semua proses)?
5.18 Proses berikut sedang dijadwalkan menggunakan preemptive,

algoritma penjadwalan round-robin berbasis prioritas.
Proses Prioritas Meletus Kedatangan
P1 8 15 0
P2 3 20 0
P3 4 20 20
P4 4 20 25
P5 5 545
P6 5 15 55
Setiap proses diberi prioritas numerik, dengan angka yang lebih tinggi menunjukkan
prioritas relatif yang lebih tinggi. Penjadwal akan menjalankan proses dengan
prioritas tertinggi. Untuk proses dengan prioritas yang sama, round-robin
scheduler akan digunakan dengan kuantum waktu 10 unit. Jika suatu proses adalah
didahului oleh proses dengan prioritas lebih tinggi, proses yang didahulukan ditempatkan
di akhir antrian.
sebuah. Tunjukkan urutan penjadwalan proses menggunakan bagan Gantt.
b. Apa waktu penyelesaian untuk setiap proses?
c. Berapa waktu tunggu untuk setiap proses?
5.19 Perintah Nice digunakan untuk mengatur nilai bagus dari suatu proses di Linux,
serta pada sistem UNIX lainnya. Jelaskan mengapa beberapa sistem memungkinkan
setiap pengguna untuk menetapkan proses nilai yang bagus >= 0 namun hanya mengizinkan root (atau
administrator) pengguna untuk menetapkan nilai yang bagus < 0.
Latihan EX-14
5.20 Manakah dari algoritma penjadwalan berikut yang dapat menyebabkan kelaparan?
sebuah. Pertama datang, pertama
dilayanib. Pekerjaan terpendek dulu
c. Usul
d. Prioritas
5.21 Pertimbangkan varian dari algoritma penjadwalan RR di mana entri dalam antrian siap
adalah pointer ke PCB.
sebuah. Apa efek dari menempatkan dua pointer ke proses yang sama dalam
antrian siap?
b. Apa yang akan menjadi dua keuntungan utama dan dua kerugian dari skema ini?
c. Bagaimana Anda memodifikasi algoritma RR dasar untuk mencapai hal yang sama?
efek tanpa pointer duplikat?
5.22 Pertimbangkan sistem yang menjalankan sepuluh tugas terikat I/O dan satu tugas terikat
CPU. Asumsikan bahwa tugas terikat I/O mengeluarkan operasi I/O sekali untuk
setiap milidetik komputasi CPU dan bahwa setiap operasi I/O membutuhkan waktu
10 milidetik untuk diselesaikan. Juga asumsikan bahwa overhead pengalihan konteks
adalah 0,1 milidetik dan bahwa semua proses adalah tugas yang berjalan lama.
Jelaskan penggunaan CPU untuk penjadwal round-robin ketika:
sebuah. Kuantum waktu adalah 1 milidetik b.
Kuantum waktu adalah 10 milidetik 5.23
Pertimbangkan sistem yang menerapkan penjadwalan antrian bertingkat. Strategi apa yang
dapat digunakan pengguna komputer untuk memaksimalkan jumlah waktu CPU yang
dialokasikan untuk proses pengguna?
5.24 Pertimbangkan algoritma penjadwalan prioritas preemptive berdasarkan prioritas yang

berubah secara dinamis. Angka prioritas yang lebih besar menyiratkan prioritas yang lebih tingg
Ketika sebuah proses menunggu CPU (dalam antrian siap, tetapi tidak berjalan
ning), prioritasnya berubah pada tingkat . Saat sedang berjalan, prioritasnya berubah
pada tingkat . Semua proses diberi prioritas 0 ketika mereka memasuki antrian siap.
Parameter dan dapat diatur untuk memberikan banyak algoritma penjadwalan yang
berbeda.
sebuah. Apa algoritma yang dihasilkan dari > > 0 ? b. Apa
algoritma yang dihasilkan dari < < 0 ?
5.25 Jelaskan bagaimana algoritma penjadwalan berikut mendiskriminasikan:

mendukung atau menentang proses pendek:
sebuah. FCFS
b. RR
c. Antrian umpan balik bertingkat

EX-15
5.26 Jelaskan mengapa antrian siap bersama mungkin mengalami masalah kinerja di lingkungan
SMP .
5.27 Pertimbangkan algoritme penyeimbang beban yang memastikan bahwa setiap antrian
memiliki jumlah utas yang kira-kira sama, tidak bergantung pada prioritas.
Seberapa efektif algoritma penjadwalan berbasis prioritas menangani situasi ini jika satu
antrian berjalan memiliki semua utas prioritas tinggi dan antrian kedua memiliki semua
utas prioritas rendah?
5.28 Asumsikan bahwa sistem SMP memiliki antrian yang dijalankan per-prosesor secara pribadi.
Ketika sebuah proses baru dibuat, itu dapat ditempatkan di antrian yang sama dengan
proses induk atau antrian terpisah.
sebuah. Apa manfaat menempatkan proses baru dalam antrian yang sama dengan
induknya? b. Apa manfaat menempatkan proses baru di tempat yang berbeda?
antre?
5.29 Asumsikan bahwa utas telah diblokir untuk I/O jaringan dan memenuhi syarat untuk
dijalankan kembali. Jelaskan mengapa algoritma penjadwalan NUMA-aware harus
menjadwal ulang utas pada CPU yang sama yang sebelumnya dijalankan.
5.30 Menggunakan algoritma penjadwalan Windows, tentukan harga numerik

oritas dari masing-masing utas berikut.
sebuah. Sebuah utas di KELAS PRIORITAS REALTIME dengan prioritas relatif

dari NORMAL
b. Sebuah utas di KELAS PRIORITAS NORMAL DI ATAS dengan kerabat

prioritas TERTINGGI
c. Sebuah utas di KELAS PRIORITAS BAWAH NORMAL dengan kerabat
prioritas DI ATAS NORMAL
5.31 Dengan asumsi bahwa tidak ada utas yang termasuk dalam KELAS PRIORITAS REALTIME
dan tidak ada yang dapat diberi prioritas TIME CRITICAL , kombinasi kelas prioritas dan
prioritas apa yang sesuai dengan prioritas relatif tertinggi dalam penjadwalan Windows?
5.32 Pertimbangkan algoritma penjadwalan dalam sistem operasi Solaris untuk

thread berbagi waktu.
sebuah. Berapa kuantum waktu (dalam milidetik) untuk utas dengan prioritas 15?
Dengan prioritas 40? b. Asumsikan bahwa utas dengan prioritas 50 telah
menggunakan seluruh waktu kuantumnya tanpa pemblokiran. Prioritas baru apa yang
akan ditetapkan oleh penjadwal untuk utas ini? c. Asumsikan bahwa utas dengan
prioritas 20 blok untuk I/O sebelum kuantum waktunya telah kedaluwarsa. Prioritas
baru apa yang akan ditetapkan oleh penjadwal untuk utas ini?
Latihan EX-16
5.33 Asumsikan bahwa dua tugas, A dan B, berjalan pada sistem Linux. Nilai bagus dari A
dan B masing-masing adalah 5 dan +5. Menggunakan penjadwal CFS sebagai
panduan, jelaskan bagaimana nilai vruntime masing-masing bervariasi antara dua
proses yang diberikan masing-masing skenario berikut:
• Baik A dan B terikat pada CPU.
• A terikat I/O, dan B terikat CPU.
• A terikat CPU, dan B terikat I/O.
5.34 Memberikan keadaan spesifik yang menggambarkan di mana penjadwalan tingkat-

monotonik lebih rendah daripada penjadwalan tenggat waktu paling awal dalam
memenuhi tenggat waktu proses waktu nyata?
5.35 Pertimbangkan dua proses, P1 dan P2, di mana p1 = 50, t1 = 25, p2 = 75, dan
t2 = 30.
sebuah. Bisakah kedua proses ini dijadwalkan menggunakan penjadwalan tingkat-

monoton? Ilustrasikan jawaban Anda menggunakan Gantt chart seperti pada
Gambar 5.21–Gambar 5.24.
b. Ilustrasikan penjadwalan kedua proses ini menggunakan penjadwalan tenggat

waktu pertama (EDF) paling awal .
5.36 Jelaskan mengapa waktu latensi interupsi dan pengiriman harus dibatasi dalam a
sistem waktu nyata yang sulit.
5.37 Jelaskan keuntungan menggunakan multiprocessing heterogen dalam a

sistem seluler.
P-29 Bab 5 Penjadwalan CPU
Proyek Pemrograman
Algoritma Penjadwalan
Proyek ini melibatkan penerapan beberapa algoritma penjadwalan proses yang berbeda.
Penjadwal akan diberikan serangkaian tugas yang telah ditentukan sebelumnya dan akan
menjadwalkan tugas berdasarkan algoritme penjadwalan yang dipilih. Setiap tugas diberi prioritas
dan CPU burst. Algoritma penjadwalan berikut akan diterapkan:
• First-come, first-served (FCFS), yang menjadwalkan tugas sesuai urutan permintaan CPU.
• Shortest-job-first (SJF), yang menjadwalkan tugas dalam urutan durasi CPU burst tugas
berikutnya.
• Penjadwalan prioritas, yang menjadwalkan tugas berdasarkan prioritas. •
Penjadwalan round-robin (RR) , di mana setiap tugas dijalankan untuk kuantum waktu
(atau untuk sisa CPU burst-nya).
• Prioritas dengan round-robin, yang menjadwalkan tugas dalam urutan prioritas dan
menggunakan penjadwalan round-robin untuk tugas dengan prioritas yang sama.
Prioritas berkisar dari 1 hingga 10, di mana nilai numerik yang lebih tinggi menunjukkan prioritas
relatif yang lebih tinggi. Untuk penjadwalan round-robin, panjang kuantum waktu adalah 10
milidetik.
I. Implementasi
Implementasi proyek ini dapat diselesaikan baik dalam C atau Java, dan file program yang
mendukung kedua bahasa ini disediakan dalam unduhan kode sumber untuk teks. File pendukung
ini membaca dalam jadwal tugas, memasukkan tugas ke dalam daftar, dan memanggil penjadwal.
Jadwal tugas berbentuk [nama tugas] [prioritas] [CPU burst], dengan format contoh
sebagai berikut:
T1, 4, 20
T2, 2, 25
T3, 3, 25
T4, 3, 15
T5, 10, 10
Jadi, tugas T1 memiliki prioritas 4 dan CPU burst 20 milidetik, dan seterusnya. Diasumsikan
bahwa semua tugas tiba pada waktu yang sama, sehingga algoritme penjadwal Anda tidak harus
mendukung proses dengan prioritas lebih tinggi yang mendahului proses dengan prioritas lebih
rendah. Selain itu, tugas tidak harus ditempatkan ke dalam antrian atau daftar dalam urutan
tertentu.
Ada beberapa strategi berbeda untuk mengatur daftar tugas, seperti yang pertama kali
disajikan di Bagian 5.1.2. Salah satu pendekatannya adalah menempatkan semua tugas dalam
satu daftar yang tidak berurutan, di mana strategi untuk pemilihan tugas bergantung pada penjadwalan
Proyek Pemrograman P-30
algoritma. Misalnya, penjadwalan SJF akan mencari daftar untuk menemukan tugas
dengan CPU burst berikutnya yang terpendek. Atau, daftar dapat dipesan sesuai dengan
kriteria penjadwalan (yaitu, berdasarkan prioritas). Salah satu strategi lain melibatkan
antrian terpisah untuk setiap prioritas unik, seperti yang ditunjukkan pada Gambar 5.7.
Pendekatan-pendekatan ini dibahas secara singkat di Bagian 5.3.6. Perlu juga digarisbawahi
bahwa kita menggunakan daftar istilah dan antrian agak bergantian.
Namun, antrian memiliki fungsi FIFO yang sangat spesifik , sedangkan daftar tidak memiliki
persyaratan penyisipan dan penghapusan yang ketat. Anda mungkin menemukan
fungsionalitas daftar umum lebih cocok saat menyelesaikan proyek ini.
II. C Detail Implementasi

File driver.c membaca dalam jadwal tugas, menyisipkan setiap tugas ke dalam daftar
tertaut, dan memanggil penjadwal proses dengan memanggil fungsi schedule() . Fungsi
schedule() mengeksekusi setiap tugas sesuai dengan algoritma penjadwalan yang
ditentukan. Tugas yang dipilih untuk dieksekusi pada CPU ditentukan oleh fungsi pick
NextTask() dan dieksekusi dengan menjalankan fungsi run() yang ditentukan dalam file
CPU.c. AMakefile digunakan untuk menentukan algoritma penjadwalan spesifik yang akan
dipanggil oleh driver. Misalnya, untuk membangun penjadwal FCFS , kita akan memasukkan
membuat fcfs
dan akan menjalankan penjadwal (menggunakan jadwal tugas schedule.txt) sebagai berikut:
./fcfs schedule.txt
Lihat file README di unduhan kode sumber untuk detail lebih lanjut. Sebelum melanjutkan,
pastikan untuk membiasakan diri dengan kode sumber yang disediakan serta Makefile.
AKU AKU AKU. Detail Implementasi Java
File Driver.java membaca dalam jadwal tugas, menyisipkan setiap tugas ke dalam Java
ArrayList, dan memanggil penjadwal proses dengan memanggil metode schedule() .
Antarmuka berikut mengidentifikasi algoritme penjadwalan umum, yang akan diterapkan
oleh lima algoritme penjadwalan yang berbeda:
Algoritma antarmuka publik {
// Implementasi algoritma penjadwalan public void

schedule();
// Memilih tugas berikutnya yang akan dijadwalkan

publik Tugas pickNetTask();
}
Metode schedule() memperoleh tugas berikutnya untuk dijalankan pada CPU dengan
memanggil metode pickNextTask() dan kemudian menjalankan Tugas ini dengan
memanggil metode run() statis di kelas CPU.java .
Program dijalankan sebagai berikut:
java Driver fcfs schedule.txt

P-31 Bab 5 Penjadwalan CPU
Lihat file README di unduhan kode sumber untuk detail lebih lanjut. Sebelum melanjutkan,
pastikan untuk membiasakan diri dengan semua file sumber Java yang disediakan dalam
unduhan kode sumber.
IV. Tantangan Selanjutnya
Dua tantangan tambahan disajikan untuk proyek ini:
1. Setiap tugas yang diberikan kepada penjadwal diberi tugas unik (tid).
Jika penjadwal berjalan di lingkungan SMP di mana setiap CPU secara terpisah
menjalankan penjadwalnya sendiri, ada kemungkinan kondisi balapan pada variabel
yang digunakan untuk menetapkan pengidentifikasi tugas. Perbaiki kondisi balapan ini
menggunakan bilangan bulat atom.
Pada sistem Linux dan macOS , fungsi sinkronisasi fetch dan add() dapat digunakan
untuk menaikkan nilai integer secara atom. Sebagai contoh, contoh kode berikut
secara atomik menambah nilai sebesar 1:
nilai int = 0;
sinkronisasi ambil dan tambah(&nilai,1);
Lihat Java API untuk detail tentang cara menggunakan kelas AtomicInteger untuk
program Java.
2. Hitung rata-rata waktu penyelesaian, waktu tunggu, dan waktu respons

untuk setiap algoritma penjadwalan.
Bagian ketiga
Proses
Sinkronisasi
Sebuah sistem biasanya terdiri dari beberapa (mungkin ratusan atau bahkan ribuan)
utas yang berjalan secara bersamaan atau paralel. Utas sering berbagi data pengguna.
Sementara itu, sistem operasi terus memperbarui berbagai struktur data untuk mendukung
banyak utas. Kondisi balapan terjadi saat akses ke data bersama tidak dikontrol, yang
mungkin mengakibatkan nilai data rusak.
Sinkronisasi proses melibatkan penggunaan alat yang mengontrol akses ke data

bersama untuk menghindari kondisi balapan. Alat-alat ini harus digunakan dengan hati-
hati, karena penggunaan yang salah dapat mengakibatkan kinerja sistem yang buruk,
termasuk kebuntuan.

Chapter 5

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Chapter 5

Diunggah oleh

Hak Cipta:

Format Tersedia

Machine Translated by Google

• Jelaskan berbagai algoritma penjadwalan CPU .

tunggu I/O I/O meledak

tunggu I/O I/O meledak

tunggu I/O I/O meledak

Gambar 5.1 Urutan CPU dan I/O burst bergantian.

5.1.1 CPU – I/O Burst Cycle

5.1.2 Penjadwal CPU

Gambar 5.2 Histogram durasi CPU-burst.

4. Ketika sebuah proses berakhir

Preemption juga mempengaruhi desain kernel sistem operasi. Selama pemrosesan

Kebanyakan sistem operasi modern sekarang sepenuhnya preemptive ketika berjalan

Gambar 5.3 Peran petugas operator.

• Beralih konteks dari satu proses ke proses lain •

Dispatcher harus secepat mungkin, karena dipanggil selama setiap sakelar

memberikan output yang dipangkas berikut:

sakelar ctxt sukarela sakelar ctxt 150

5.2 Kriteria Penjadwalan

Diinginkan untuk memaksimalkan pemanfaatan dan throughput CPU dan meminimalkan

5.3 Algoritma Penjadwalan

5.3.1 Penjadwalan First-Come, First-Served

Waktu tunggu rata-rata sekarang (6 + 0 + 3)/3 = 3 milidetik. Pengurangan ini

5.3.2 Penjadwalan Terpendek-Pekerjaan-Pertama

Proses Waktu Meledak

Nilai tn berisi informasi terbaru kami, sementara n menyimpan masa lalu

CPU meledak (ti ) 6 4 6 4 13 13 13 …

Untuk memahami perilaku rata-rata eksponensial, kita dapat memperluas

5.3.3 Penjadwalan Round-Robin

Proses Waktu Meledak

waktu proses = 10 kuantum konteks

5.3.4 Penjadwalan Prioritas

Gambar 5.6 Bagaimana waktu penyelesaian bervariasi dengan kuantum waktu.

Proses Waktu Meledak Prioritas

Waktu tunggu rata-rata adalah 8,2 milidetik.

Proses Waktu Meledak Prioritas

5.3.5 Penjadwalan Antrian Bertingkat

prioritas = 2 Q8 T9 T10 T11

prioritas = n terima kasih

Gambar 5.7 Antrian terpisah untuk setiap prioritas.

proses waktu nyata

Gambar 5.8 Penjadwalan antrian bertingkat.

Algoritme penjadwalan antrian bertingkat juga dapat digunakan untuk mempartisi

5.3.6 Penjadwalan Antrian Umpan Balik Bertingkat

Algoritma penjadwalan antrian umpan balik bertingkat , sebaliknya, memungkinkan suatu

Gambar 5.9 Antrian umpan balik bertingkat.

• Algoritma penjadwalan untuk setiap antrian

Definisi penjadwal antrian umpan balik multilevel menjadikannya yang terbaik

5.4 Penjadwalan Utas

5.4.1 Lingkup Perdebatan

5.4.2 Penjadwalan Pthread Kami

• PTHREAD SCOPE PROCESS menjadwalkan thread menggunakan penjadwalan PCS .

• PTHREAD SCOPE SYSTEM menjadwalkan thread menggunakan penjadwalan SCS .

Pada sistem yang menerapkan model banyak-ke-banyak, kebijakan PROSES LINGKUP

• pthread attr setscope(attr pthread t *attr, int scope) • pthread attr

Pada Gambar 5.10, kami mengilustrasikan API penjadwalan Pthread . Program

int main(int argc, char *argv[]) {

/* mendapatkan atribut default */ pthread

/* pertama-tama tanyakan pada lingkup saat ini */ if

/* atur algoritma penjadwalan ke PCS atau SCS */ pthread attr

/* buat utas */ for (i = 0; i < NUM

/* sekarang gabung di setiap utas */

/* Setiap thread akan memulai kontrol dalam fungsi ini */ void

/* lakukan beberapa pekerjaan ... */