PERTEMUAN 4

PENJADUALAN PROSES
 Highlight
1. Konsep Dasar Penjadualan Proses
2. Kriteria Penjadualan
3. Algoritma Penjadualan
– First Come First Served
Scheduling(FCFS)
– Shortest Job First Scheduling (SJF)
– Priority Scheduling
– Round Robin Scheduling
 1. Konsep Dasar Penjadwalan
Proses
• Tujuan Utama : agar proses-proses berjalan
secara konkuren dan untuk memaksimalkan
kinerja dari CPU.
• Pemanfaatan CPU maksimum diperoleh dengan
multiprograming
– Proses dieksekusi secara bergantian
• CPU-I/O Burst Cycle adalah pelaksanaan proses
terdiri dari suatu siklus tunggu I/O dan eksekusi
CPU
Alternating Sequence of CPU
And I/O Bursts
Histogram of CPU-burst Times
• Keterangan gambar
Pada saat suatu proses dieksekusi, terdapat banyak CPU burst
yang pendek dan terdapat sedikit CPU burst yang panjang.
Program yang I/O bound, CPU burst-nya biasanya sangat
pendek, sedangkan program yang CPU bound
kemungkinana CPU burstnya sangat lama. Hal ini dapat
digambarkan dengan grafik yang eksponensial atau hiper
eksponensial seperti gambar diatas. Oleh karena itu,
pemilihan algoritma penjadwalan CPU sangat penting.
 CPU Scheduller
• Short term scheduler memilih dari sekian proses yang ada di
memori yang sudah siap dieksekusi, dan mengalokasikan CPU untuk
kepadanya
• Penjadwalan CPU akan terjadi perubahan state:
1. Berubah dari running ke waiting state.
2. Berubah dari running ke ready state.
3. Berubah dari waiting ke ready.
4. Terminates.
• Penjadwalan 1 dan 4 adalah non preemptive; Maksudnya adalah
dalam penjadual nonpreemptive sekali CPU telah dialokasikan
untuk sebuah proses, maka tidak bisa di ganggu,
– contoh pada windows 3.x
• Selain itu bersifat preemptive (win 95 dst).
 Dispatcher
• Merupakan modul pemberi kontrol CPU kepada proses,
fungsinya :
– switching context
– switching to user mode
– Lompat dari suatu bagian di progam user untuk mengulang
progam.
• Dispatch Latency: waktu yang dibutuhkan untuk menstop
satu proses dan menjalankan proses lainnya
– Sebisa mungkin dipatcher secepat-cepatnya.
 2. Scheduling Criteria
• CPU utilization. Diharapkan agar CPU selalu dalam keadaan sibuk. Utilitas CPU
dinyatakan dalam bentuk persen yaitu 0-100%. Namun dalam kenyataannya
hanya berkisar antara 40-90%.
• Throughput. Adalah banyaknya proses yang selesai dikerjakan dalam satu
satuan waktu.
• Turnaround time. Banyaknya waktu yang diperlukan untuk mengeksekusi
proses, dari mulai menunggu untuk meminta tempat di memori utama,
menunggu di ready queue, eksekusi oleh CPU, dan mengerjakan I/O.
• Waiting time. Waktu yang diperlukan oleh suatu proses untuk menunggu di
ready queue. Waiting time ini tidak mempengaruhi eksekusi proses dan
penggunaan I/O.
• Response time. Waktu yang dibutuhkan oleh suatu proses dari minta dilayani
hingga ada respon pertama yang menanggapi permintaan tersebut.
 3. Algortima Penjadwalan
Penjadwalan CPU menyangkut penentuan proses-proses
yang ada dalam ready queue yang akan dialokasikan pada
CPU. Terdapat beberapa algoritma penjadwalan CPU seperti
dibawah ini :
1. First Come First Served Scheduling(FCFS)
2. Shortest Job First Scheduling (SJF)
3. Priority Scheduling
4. Round Robin Scheduling
 Algortima Penjadwalan
1. First Come First Served Scheduling(FCFS)
Pertama datang, pertama dilayani (First In, First Out atau FIFO) tidak peduli apakah
burst time-nya panjang atau pendek, sebuah proses yang sedang dikerjakan
diselesaikan terlebih dahulu barulah proses berikutnya dilayani.
Penjadwalan FCFS merupakan :
– Penjadwalan non-preemptive (run-to-completion)
– Penjadwalan tidak berprioritas
Ketentuan dari penjadwalan FCFS adalah :
– Proses-proses diberi jatah waktu pemroses, diurut dengan waktu kedatangannya.
– Begitu proses mendapat jatah waktu pemroses, proses dijalankan sampai proses
tersebut selesai, walaupun ada proses lain yang datang, proses tersebut berada
dalam antrian sistem atau disebut dengan ready queue.
 FCFS
• dalam hal bahasa, FCFS ini cukup adil karena yang datang lebih dahulu
dikerjakan terlebih dahulu.
• Dari segi konsep SO, tidak adil, karena :
- proses-proses yang membutuhkan waktu yang lama membuat proses-
proses yang memiliki waktu lebih pendek menunggu sampai proses yang
lama tersebut selesai
-sedangkan proses-proses yang tidak penting membuat proses penting
menunggu.
• Penjadwalan FCFS ini cocok digunakan untuk sistem batch yang sangat
jarang melakukan interaksi langsung dengan user, tapi tidak cocok
digunakan untuk sistem interaktif karena tidak memberi waktu tanggap
yang bagus, begitu juga dengan sistem waktu nyata.
 FCFS
• Contoh : misalnya proses-proses yang akan
dikerjakan oleh CPU adalah sebagai berikut :
Proses Arrival Time (AT) Burst Time (BT
P1 0 12
P2 2 8
P3 3 5
P4 5 2
P5 9 1
 FCFS
CPU P1 P2 P3 P4 P5

RQ 0 2 3 5 9 12 20 25 27 28
P1 P2 P3 P4 P5 P2 P3 P4 P5
P3 P4 P5
Waktu tunggu setiap proses :
P1 = 0 =0 P4 P5
P2 = 12-2 = 10 P5
P3 = 20-3 = 17
P4 = 25-5 = 20
P5 = 27-9 = 18 Jadi, rata-rata waktu tunggu untuk setiap proses adalah :
=================== Avg 65/5 = 13 satuan waktu
JUMLAH = 65
 FCFS
• Jika urutan proses tadi dibalik :
Proses Arrival Time (AT) Burst Time (BT
P5 0 1
P4 2 2
P3 3 5
P2 5 8
P1 9 12
 FCFS
Idle time

CPU P5 P4 P3 P2 P1

RQ 0 1 2 3 5 4 9 17 29
P5 P4 P3 P3 P2 P2 P1
P1
 Algortima Penjadwalan
2. Shortest Job First Scheduling (SJF)
Pada penjadwalan SJF, proses yang memiliki CPU burst paling
kecil dilayani terlebih dahulu. Terdapat dua skema:
1. Non preemptive, bila CPU diberikan pada proses, maka
tidak bisa ditunda sampai CPU burst selesai.
2. Preemptive, jika proses baru datang dengan panjang CPU
burst lebih pendek dari sisa waktu proses yang saat itu
sedang dieksekusi, proses ini ditunda dan diganti dengan
proses baru. Skema ini disebut dengan Shortest-
Remaining-Time-First (SRTF)
 SJF
• SJF-Non Preemptive
Algoritma ini mirip dengan FCFS, tetapi jika AT
sama, maka dipilih proses yang BT-nya lebih
pendek untuk diproses dulu.
 SJF-Non Preemptive

• Contoh :
Proses Arrival Time (AT) Burst Time (BT
P1 0 12
P2 2 8
P3 3 5
P4 5 2
P5 9 1
 SJF-Non Preemptive

CPU P1 P5 P4 P3 P2

RQ 0 2 3 5 9 12 13 15 20 28
P1(12) P2(8) P3(5) P4(2) P5(1) P2(8) P2(8) P2(8) P2(8)
P3(5) P3(5) P3(5)

Waktu tunggu setiap proses : P4(2) P4(2)

P1 = 0 =0 P5(1)
P2 = 20-2 = 18
P3 = 15-3 = 12
P4 = 13-5 =8
P5 = 12-9 =3 Jadi, rata-rata waktu tunggu untuk setiap proses adalah :
=================== Avg 41/5 = 8,5 satuan waktu
JUMLAH = 41
 SJF
• SJF-Preemptive
Jika suatu proses sedang dikerjakan kemudian
ada proses lain yang datang di mana BT-nya
lebih kecil dari sisa waktu proses yang sedang
dijalankan itu, maka proses lain ini akan
dikerjakan dulu, sementara sisa proses tadi
dikembalikan ke Ready Queue (RQ).
 SJF- Preemptive

• Contoh :
Proses Arrival Time (AT) Burst Time (BT
P1 0 12
P2 2 8
P3 3 5
P4 5 2
P5 9 1
 SJF- Preemptive

CPU P4 P3 P2 P1
P1 P2 P3 P3 P5

RQ 0 2 3 5 7 9 10 11 18 28
P1(12) P2(8) P1(10) P1(10) P1(10) P1(10) P1(10) P1(10) P1(10)
P2(7) P2(7) P2(7) P2(7)
P1(10) P2(7) P2(7)
P3(5) P3(3) P3(3) P3(1) P5(1)
P4(2)
P5(1)

Waktu tunggu setiap proses :

P1 = 0+(18-2) (karena pada saat masuknya P1, P2 kembali menunggu) = 16 Jadi, rata-rata waktu
P2 = (11-3) =8 tunggu untuk setiap
P3 = (7-5) =2 proses adalah :
P4 = 0 (5-5) =0
P5 = 10-9 =1
Avg 27/5 = 5,4 satuan
================================================================= waktu
JUMLAH = 27
 Algortima Penjadwalan
3. Priority Scheduling
Algoritma SJF adalah suatu kasus khusus dari penjadwalan berprioritas.
Tiap-tiap proses dilengkapi dengan nomor prioritas (integer).
CPU dialokasikan untuk proses yang memiliki prioritas paling tinggi (nilai
integer terkecil biasanya merupakan prioritas terbesar).
Jika beberapa proses memiliki prioritas yang sama, maka akan digunakan
algoritma FCFS.
Priority Scheduling juga memiliki dua skema :
1. non-preemptive
2. preemptive
 Priority Scheduling

jika ada proses P1 yang datang pada saat P0 sedang berjalan,

maka akan dilihat prioritas P1. seandainya prioritas P1 lebih
besar dibanding dengan prioritas P0, maka :
1. pada non-preemptive, algoritma tetap akan
menyelesaikan P0 sampai habis CPU burst-nya, dan
meletakkan P1 pada posisi head queue.
2. Sedangkan pada preemptive, P0 akan dihentikan dulu,
dan CPU ganti dialokasikan untuk P1. Misalnya terdapat
lima proses P1,P2,P3, P4 dan P5 yang datang secara
berurutan dengan CPU burst dalam milidetik.
 Priority Scheduling - non-preemptive

• Contoh : non-preemptive
Proses Arrival Time Burst Time Size (kb)
(AT) (BT
P1 0 10 100 kb
P2 2 8 150 kb
P3 3 12 175 kb
P4 5 5 100 kb
 Priority Scheduling – non-preemptive

CPU P1=10 P2=8 P4=5

P3=12

RQ 0 2 3 5 10 22 30 35
P1(10) P2(8) P3(12) P4(5) P3(12) P2(8) P4(5)
P2(8) P4(5)
P4(5)

Waktu tunggu (waiting time) setiap proses

:
P1 = 0 =0 Jadi, rata-rata waktu
P2 = (22-2) = 20 tunggu untuk setiap
P3 = (10-3) =7 proses adalah :
P4 = (30-5) = 25
========================
Avg 52/4 = 13 satuan
JUMLAH = 52 waktu
 Priority Scheduling - preemptive

• Contoh : preemptive
Proses Arrival Time Burst Time Size (kb)
(AT) (BT
P1 0 10 100 kb
P2 2 8 150 kb
P3 3 12 175 kb
P4 5 5 100 kb
 Priority Scheduling – preemptive

CPU P1=2 P2=1 P3=12 P1=8 P4=5

P2=7

RQ 0 2 3 5 15 22 30 35
P1(10) P2(8) P3(12) P4(5) P2(7) P1(8) P4(5)
P1(8) P1(8) P1(8) P4(5)
P2(7) P4(5)

Waktu tunggu (waiting time) setiap proses

:
P1 = 0+(22-2) = 20 Jadi, rata-rata waktu
P2 = (2-2) + (15-3) = 12 tunggu untuk setiap
P3 = (3-3) =0 proses adalah :
P4 = (30-5) = 25
========================
Avg 57/4 = 14,25
JUMLAH = 57 satuan waktu
 Algortima Penjadwalan
– Round Robin Scheduling
Konsep dasar dari algoritma ini adalah dengan menggunakan
time sharing. Pada dasarnya algoritma ini sama dengan FCFS,
hanya saja bersifat preemptive, setiap proses mendapatkan
waktu CPU yang disebut dengan waktu quantum (quantum
time) untuk membatasi waktu proses, biasanya 1-100
milidetipk. Setelah waktu habis, proses ditunda dan
ditambahkan pada ready queue.
 Round Robin Scheduling

• Jika suatu proses memiliki CPU burst lebih kecil dibandingkan dengan
waktu quantum, maka proses tersebut akan melepaskan CPU jika telah
selesai bekerja, sehingga CPU dapat segera digunakan oleh proses
selanjutnya. Sebaliknya, jika suatu proses memiliki CPU burstp yang lebih
besardibandingkan dengan waktu quantum, maka proses tersebut akan
dihentikan sementara jika sudah mencapai waktu quantum, dan
selanjutnya mengantri kembali pada posisi ekor dari ready queue, CPU
kemudian menjalankan proses berikutnya. Pjika terdapat n proses pada
ready queue dan apling banyak q unit waktu pada sekali penjadwalan CPU.
Tidak ada proses yang menunggu lebih dari (n-1) q unit waktu. Performasi
algoritma round robin dapat dijelaskan sebagai berikut, jika q besar, maka
yang digunakan adalah algoritma FIFO, tetapi jika q kecil maka sering
terjadi context switch.
 RR-FCFS

RR-FCFS merupakan metode penjadwalan yang lebih dulu

sampai di ready queue akan dilayani lebih dahulu dan kalau
quantum untuk proses tersebut dihabiskan lebih dahulu, maka
proses tersebut harus keluar dan masuk kembali ke antrian ready
queue kalau masih ada sisa (list masuk belakang).
 RR-FCFS

• Contoh :
Diketahui : RR-FCFS dengan Quantum = 3
Proses Arrival Time Burst Time
(AT) (BT
P1 0 12
P2 2 8
P3 3 5
P4 5 2
P5 9 1
 RR-FCFS
CPU P1 P2 P3 P1 P4 P2 P5 P3 P1 P2 P1

RQ 0 2 3 5 6 9 12 14 17 18 20 23 25 28
P1(12) P2(8) P3(5) P1(9) P4(2) P2(5) P5(1) P3(2) P1(6) P2(2) P1(3)
P3(5) P1(9) P4(2) P2(5) P5(1) P3(2) P1(6) P2(2) P1(3)
P1(9) P4(2) P2(5) P5(1) P3(2) P1(6) P2(2)
P2(5) P5(1) P3(2) P1(6) P2(2)
P2(8) P3(5) P3(2) P1(6)
P1(9)
P4(2) Waktu tunggu (waiting time) setiap proses : Jadi, rata-rata waktu
P1 = 0+(9-2)+(20-12)+(25-23) = 16
P2 = (3-2) + (14-6)+(23-17) = 15
tunggu untuk setiap
P3 = (6-3)+(18-9) = 12 proses adalah :
P4 = (12-5) = 17 Avg (Waiting Time)
P5 = (17-9) =8 58/5 = 11,6 Satuan
========================
JUMLAH = 57 Waktu
 RR-SJF (Non Preemptive)
CPU P1 P3 P3 P4 P5 P2 P2 P2 P1 P1 P1

RQ 0 2 3 5 6 8 9 10 11 14 17 19 22 25 28
P1(12) P3(5) P2(8) P2(8) P2(8) P2(8) P1(9) P1(9) P1(9) P1(6) P1(3)
P2(8) P1(9) P1(9) P1(9) P2(5) P2(2)
P1(9)
P1(9) P4(2) P4(2) P5(1)

P3(2)
P2(8) P4(5) P5(1)

Waktu tunggu (waiting time) untuk setiap proses : Jadi, waktu tunggu
P1 = 0+ (19-3) = 16
P2 = (11-2) = 9
rata-rata untuk setiap
P3 = (6-3) = 3 proses adalah :
P4 = (8-5) = 3 Avg (Waiting Time)
P5 = (10-9) = 1 32/5 = 5,3 Satuan
========================
JUMLAH = 32 Waktu
 RR-SJF (Preemptive)
CPU P3 P4 P5 P2 P2 P2 P1 P1 P1
P1 P3

RQ 0 2 3 5 7 9 10 11 14 17 18 21 24 27 28
P1(12) P1(10) P1(10) P1(10) P1(10) P1(10) P1(10) P1(10) P1(10) P1(10) P1(7) P1(4) P1(1)
P3(5) P3(3) P3(3) P2(7) P2(7) P2(7) P2(4) P2(1)
P2(7) P5(1) P5(1)
P2(7) P2(7)
P2(8)
P3(1)
P1(10) P4(2)

Waktu tunggu (waiting time) untuk setiap proses : Jadi, waktu

P1 = 0+ (18-2) = 16
tunggu rata-rata
P2 = 0+ (11-3) = 8
P3 = 0+ (7-5) = 2 untuk setiap
P4 = 0 = 0 proses adalah :
P5 = (10-9) = 9 Avg 27/5 = 5,4
========================
JUMLAH = 27 Satuan Waktu