UJIAN AKIR SEMSTER
ANALISIS DAN IMPLEMENTASI ALGORITMA
ROUND ROBIN DAN PRIORITY SCHEDULING
PADA BAHASA C
DOSEN PENGAMPU :
Febie Elfaladonna, S.Kom., M.Kom
Kelas 2ID
DISUSUN OLEH :
M. Fadhil Al Kandias
Muhammad Fadlil
062430801639
062430801640
JURUSAN MANAJEMEN INFORMATIKA
POLITEKNIK NEGERI SRIWIJAYA 2025
I. Algoritma Round Robin
A. Penjelasan Singkat
Round Robin adalah algoritma penjadwalan CPU preemptive di mana setiap
proses mendapatkan jatah waktu CPU (time quantum) secara bergilir. Jika
dalam jatah waktu itu proses belum selesai, maka akan dimasukkan kembali
ke antrian ready queue untuk menunggu giliran berikutnya.
a) Konsep dasar
Semua proses dimasukkan ke ready queue.
Scheduler mengeksekusi proses pertama selama time quantum
tertentu.
Jika proses selesai sebelum time quantum habis, CPU
langsung berpindah ke proses berikutnya.
Jika proses belum selesai ketika time quantum habis, proses
dikembalikan ke belakang antrian dan menunggu giliran
berikutnya.
b) Time Quantum
Time quantum (TQ) adalah interval waktu maksimum untuk
eksekusi proses sebelum dialihkan ke proses berikutnya.
Jika TQ terlalu kecil → terlalu banyak context switching →
overhead besar.
Jika TQ terlalu besar → Round Robin mendekati FCFS (First Come
First Serve).
c) Karakteristik dan Kelebihan
Bersifat preemptive, mendukung sistem multitasking.
Adil: semua proses mendapat waktu yang sama secara bergiliran.
Cocok untuk time-sharing system (misal OS modern).
Overhead tinggi jika TQ terlalu kecil.
Adil (Fair): Tidak ada proses yang dimonopoli, cocok untuk sistem
multitasking.
Responsif: Karena preemptive, proses dengan burst time kecil
tidak akan menunggu lama dibanding FCFS.
Cocok untuk time-sharing systems seperti komputer umum atau
server multi-user.
Sederhana diimplementasikan menggunakan queue
1
d) Contoh soal 1
Soal
Terdapat 4 proses dengan burst time berikut:
Proses
Burst Time
P1
10 ms
P2
4 ms
P3
5 ms
P4
3 ms
Gunakan time quantum = 3 ms. Hitung:
a.
Average
b. Average Turnaround Time
Waiting
Penyelesaian Manual
Proses Eksekusi
Sisa burst time
P1 (0-3)
7
P2 (3-6)
1
P3 (6-9)
2
P4 (9-12)
0 (selesai)
P1 (12-15)
4
P2 (15-16)
0 (selesai)
P3 (16-18)
0 (selesai)
P1 (18-21)
1
P1 (21-22)
0 (selesai)
Completion Time (CT)
P1 = 22, P2 = 16, P3 = 18, P4 = 12
2
Time
Turnaround Time (TAT) = CT - Arrival (arrival = 0 semua)
P1 = 22, P2 = 16, P3 = 18, P4 = 12
Waiting Time (WT) = TAT - Burst Time
P1 = 22-10=12
P2 = 16-4=12
P3 = 18-5=13
P4 = 12-3=9
Average Waiting Time = (12+12+13+9)/4 = 11.5 ms
Average Turnaround Time = (22+16+18+12)/4 = 17 ms
KODE C SOAL 1
#include <stdio.h>
int main() {
int n = 4, i, time = 0, remain = 4, flag = 0, tq = 3;
int bt[4] = {10,4,5,3};
int rt[4], wt[4] = {0}, tat[4] = {0};
for(i = 0; i < n; i++)
rt[i] = bt[i];
while(remain != 0) {
flag = 0;
for(i = 0; i < n; i++) {
if(rt[i] > 0) {
flag = 1;
if(rt[i] > tq) {
time += tq;
rt[i] -= tq;
}
else {
time += rt[i];
tat[i] = time;
wt[i] = tat[i] - bt[i];
rt[i] = 0;
remain--;
}
}
}
if(flag == 0)
break;
}
3
int total_wt = 0, total_tat = 0;
printf("Process\tBT\tTAT\tWT\n");
for(i = 0; i < n; i++) {
printf("P%d\t%d\t%d\t%d\n", i+1, bt[i], tat[i], wt[i]);
total_wt += wt[i];
total_tat += tat[i];
}
printf("Average Waiting Time: %.2f ms\n", total_wt*1.0/n);
printf("Average Turnaround Time: %.2f ms\n", total_tat*1.0/n);
return 0;
}
Output:
e) Soal 2
3 proses dengan burst time:
Proses
Burst Time
P1
7 ms
P2
3 ms
P3
9 ms
f)
g)
Gunakan time quantum = 2 ms. Hitung:
a. Average Waiting Time
b. Average Turnaround Time
h)
4
i)
Penyelesaian Manual
Proses Eksekusi
Sisa burst time
P1 (0-2)
5
P2 (2-4)
1
P3 (4-6)
7
P1 (6-8)
3
P2 (8-9)
0 (selesai)
P3 (9-11)
5
P1 (11-13)
1
P3 (13-15)
3
P1 (15-16)
0 (selesai)
P3 (16-18)
1
P3 (18-19)
0 (selesai)
Completion Time (CT)
P1 = 16, P2 = 9, P3 = 19
Turnaround Time (TAT) = CT - Arrival
P1 = 16, P2 = 9, P3 = 19
Waiting Time (WT) = TAT - BT
P1 = 16-7=9
P2 = 9-3=6
P3 = 19-9=10
Average Waiting Time = (9+6+10)/3 = 8.33 ms
Average Turnaround Time = (16+9+19)/3 = 14.67 ms
KODE C SOAL 2
#include <stdio.h>
int main() {
int n = 3, i, time = 0, remain = 3, flag = 0, tq = 2;
int bt[3] = {7,3,9};
int rt[3], wt[3] = {0}, tat[3] = {0};
for(i = 0; i < n; i++)
5
rt[i] = bt[i];
while(remain != 0) {
flag = 0;
for(i = 0; i < n; i++) {
if(rt[i] > 0) {
flag = 1;
if(rt[i] > tq) {
time += tq;
rt[i] -= tq;
}
else {
time += rt[i];
tat[i] = time;
wt[i] = tat[i] - bt[i];
rt[i] = 0;
remain--;
}
}
}
if(flag == 0)
break;
}
int total_wt = 0, total_tat = 0;
printf("Process\tBT\tTAT\tWT\n");
for(i = 0; i < n; i++) {
printf("P%d\t%d\t%d\t%d\n", i+1, bt[i], tat[i], wt[i]);
total_wt += wt[i];
total_tat += tat[i];
}
printf("Average Waiting Time: %.2f ms\n", total_wt*1.0/n);
printf("Average Turnaround Time: %.2f ms\n",
total_tat*1.0/n);
return 0;
}
Output:
6
II PRIORITY SCHEDULING
1. Penjelasan Singkat
A) Priority Scheduling adalah algoritma penjadwalan di mana proses
dengan prioritas tertinggi akan dieksekusi lebih dahulu. Jika dua
proses memiliki prioritas sama, maka biasanya diatur dengan FCFS.
2. Konsep Dasar
Setiap
proses
memiliki
nilai
prioritas.
CPU akan dialokasikan ke proses dengan prioritas tertinggi (nilai
prioritas paling rendah untuk sistem prioritas angka kecil) atau
sebaliknya tergantung sistem.
Contoh:
Jika angka kecil = prioritas tinggi → P1(priority=1) didahulukan
daripada P2(priority=4).
Jika proses baru masuk memiliki prioritas lebih tinggi daripada
proses saat ini:
Jika preemptive, CPU akan segera dialihkan ke proses baru.
Jika non-preemptive, proses yang sedang berjalan akan tetap
selesai dulu.
3. Jenis Priority Scheduling
a. Preemptive Priority Scheduling
Proses baru dengan prioritas lebih tinggi akan menghentikan
proses yang sedang berjalan, dan CPU dialihkan ke proses baru
tersebut.
b. Non-preemptive Priority Scheduling
Proses yang sedang berjalan tetap melanjutkan hingga selesai,
meskipun ada proses baru dengan prioritas lebih tinggi yang
masuk.
7
4. Karakteristik, Kelebihan, dan Kekurangan
B) Karakteristik:
Memperhatikan priority number pada setiap proses.
Cocok untuk real-time system yang memerlukan prioritas ketat.
Dapat menyebabkan starvation pada proses dengan prioritas rendah
jika banyak proses prioritas tinggi masuk.
Kelebihan:
Memberikan CPU kepada proses yang lebih penting.
Baik untuk sistem real-time atau time-critical tasks.
Preemptive Priority Scheduling dapat meningkatkan responsiveness
untuk proses high-priority.
Kekurangan:
Starvation (kelaparan CPU) pada proses prioritas rendah jika proses
high-priority terus masuk.
Memerlukan penanganan aging untuk meningkatkan prioritas
proses lama dan mencegah starvation.
Implementasi lebih kompleks dibanding FCFS atau SJF.
CONTOH SOAL 1
Soal (Non-Preemptive Priority Scheduling)
Diketahui 5 proses berikut:
Proses
P1
P2
P3
P4
P5
Burst Time
10
1
2
1
5
8
Priority
3
1
4
5
2
Urutkan eksekusi proses dan hitung:
a. Average Waiting Time
b. Average Turnaround Time
Penyelesaian Manual
Urutan berdasarkan prioritas kecil = prioritas tinggi:
1.
2.
3.
4.
5.
P2 (priority=1) → BT=1
P5 (priority=2) → BT=5
P1 (priority=3) → BT=10
P3 (priority=4) → BT=2
P4 (priority=5) → BT=1
Proses
P2
Waiting Time
0
Turnaround Time
1
P5
1
6
P1
6
16
P3
16
18
P4
18
19
Average WT = (0+1+6+16+18)/5 = 41/5
Average TAT = (1+6+16+18+19)/5 = 60/5 = 12 ms
KODE C SOAL 1
#include <stdio.h>
struct Process {
int id;
int burstTime;
int priority;
int waitingTime;
int turnaroundTime;
};
void sortByPriority(struct Process p[], int n) {
struct Process temp;
for(int i=0; i<n-1; i++) {
9
=
8.2
ms
for(int j=i+1; j<n; j++) {
if(p[j].priority < p[i].priority) {
temp = p[i];
p[i] = p[j];
p[j] = temp;
}
}
}
}
int main() {
int n = 5;
struct Process p[5] = {
{1, 10, 3, 0, 0}, // P1
{2, 1, 1, 0, 0}, // P2
{3, 2, 4, 0, 0}, // P3
{4, 1, 5, 0, 0}, // P4
{5, 5, 2, 0, 0} // P5
};
// Sort berdasarkan prioritas (semakin kecil semakin tinggi)
sortByPriority(p, n);
// Hitung Waiting Time dan Turnaround Time
int totalWT = 0, totalTAT = 0;
p[0].waitingTime = 0;
p[0].turnaroundTime = p[0].burstTime;
totalTAT += p[0].turnaroundTime;
for(int i = 1; i < n; i++) {
p[i].waitingTime = p[i-1].waitingTime + p[i-1].burstTime;
p[i].turnaroundTime = p[i].waitingTime + p[i].burstTime;
totalWT += p[i].waitingTime;
totalTAT += p[i].turnaroundTime;
}
printf("Urutan Eksekusi Berdasarkan Prioritas:\n");
for(int i = 0; i < n; i++) {
printf("P%d ", p[i].id);
}
printf("\n\n");
printf("Proses\tBT\tPrio\tWT\tTAT\n");
for(int i = 0; i < n; i++) {
printf("P%d\t%d\t%d\t%d\t%d\n",
p[i].id, p[i].burstTime, p[i].priority,
10
p[i].waitingTime, p[i].turnaroundTime);
}
float avgWT = (float)totalWT / n;
float avgTAT = (float)totalTAT / n;
printf("\nAverage Waiting Time: %.2f ms", avgWT);
printf("\nAverage Turnaround Time: %.2f ms\n", avgTAT);
return 0;
}
Output:
CONTOH SOAL 2
Soal (Preemptive Priority Scheduling)
Terdapat 4 proses berikut:
Proses
Burst Time
P1
6
Priority
2
P2
8
1
P3
7
3
P4
3
4
Hitung:
a. Average Waiting Time
b. Average Turnaround Time
Penyelesaian Manual (Preemptive)
Urutan eksekusi:
P2 (priority=1) → BT=8
P1 (priority=2) → BT=6
P3 (priority=3) → BT=7
P4 (priority=4) → BT=3
11
Karena tidak ada arrival time berbeda, maka urutannya tetap seperti di
atas, dan hasilnya sama seperti non-preemptive.
Proses
P2
P1
P3
P4
Waiting Time
0
8
14
21
Turnaround Time
8
14
21
24
Average WT = (0+8+14+21)/4 = 43/4
Average TAT = (8+14+21+24)/4 = 67/4 = 16.75 ms
KODE C SOAL 2
#include <stdio.h>
struct process {
int pid, bt, priority, wt, tat;
};
int main() {
int n = 4, i, j;
struct process p[4] = {
{1, 6, 2}, // P1
{2, 8, 1}, // P2
{3, 7, 3}, // P3
{4, 3, 4} // P4
};
struct process temp;
12
=
10.75
ms
// Sort processes based on ascending priority (lower = higher priority)
for(i = 0; i < n - 1; i++) {
for(j = i + 1; j < n; j++) {
if(p[i].priority > p[j].priority) {
temp = p[i];
p[i] = p[j];
p[j] = temp;
}
}
}
// Calculate Waiting Time and Turnaround Time
p[0].wt = 0;
p[0].tat = p[0].bt;
for(i = 1; i < n; i++) {
p[i].wt = p[i-1].wt + p[i-1].bt;
p[i].tat = p[i].wt + p[i].bt;
}
// Print process table and calculate total WT and TAT
int total_wt = 0, total_tat = 0;
13
printf("PID\tBT\tPriority\tWT\tTAT\n");
for(i = 0; i < n; i++) {
printf("P%d\t%d\t%d\t\t%d\t%d\n", p[i].pid, p[i].bt, p[i].priority, p[i].wt,
p[i].tat);
total_wt += p[i].wt;
total_tat += p[i].tat;
}
printf("\nAverage Waiting Time : %.2f ms\n", (float)total_wt / n);
printf("Average Turnaround Time: %.2f ms\n", (float)total_tat / n);
return 0;
}
Output:
14
III. KESIMPULAN
Berdasarkan pembahasan yang telah dilakukan mengenai algoritma Round
Robin dan Priority Scheduling, dapat disimpulkan bahwa:
1. Algoritma Round Robin merupakan algoritma penjadwalan preemptive
yang memberikan jatah waktu eksekusi secara bergilir dengan time quantum
tertentu. Algoritma ini bersifat adil bagi semua proses karena setiap proses
mendapatkan alokasi waktu CPU secara merata, sehingga cocok digunakan
pada time-sharing system. Namun, penggunaan time quantum yang terlalu
kecil akan meningkatkan overhead akibat frekuensi context switching
yang tinggi.
2. Algoritma Priority Scheduling menjadwalkan proses berdasarkan
prioritas, baik secara preemptive maupun non-preemptive. Algoritma ini
efektif digunakan untuk sistem yang memiliki kebutuhan prioritas tertentu
(real-time system). Namun, algoritma ini memiliki kelemahan yaitu dapat
menyebabkan starvation pada proses dengan prioritas rendah apabila tidak
diterapkan teknik aging.
3. Berdasarkan hasil implementasi menggunakan Bahasa C, diketahui bahwa:
o Round Robin menghasilkan waiting time dan turnaround time yang
bergantung pada nilai time quantum dan urutan proses.
o Priority Scheduling menghasilkan waiting time dan turnaround time
yang dipengaruhi oleh urutan prioritas proses.
4. Dengan memahami kedua algoritma dan mengimplementasikannya, dapat
membantu dalam menentukan algoritma penjadwalan yang tepat untuk
berbagai kebutuhan sistem operasi dan meningkatkan performa CPU sesuai
tujuan sistem.
15
