LABORATORIUM PEMBELAJARAN ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA

NAMA : YOLANDA SAPUTRI

NIM : 195150201111064
MATERI : BAB V
TANGGAL : 11/11/2020
ASISTEN : FRANKLID GUNAWAN

BAB 5
PENJADWALAN
5.1. Tujuan Praktikum
Pelaksanaan praktikum ini bertujuan memberikan pengetahuan
mengenai CPU scheduling dengan mengamati perilaku CPU saat
menjalankan program yang diberikan.

5.2. Capaian Praktikum

1. Mampu menjelaskan konsep CPU Scheduling
2. Mampu mengenali karakteristik dan l
5.3. Dasar Teori
Pada sistem single-processor hanya ada satu proses yang berjalan
pada satu waktu. Proses yang lain harus menunggu hingga CPU kosong
dan bisa dijadwalkan kembali. Sedangkan pada sistem multiprogramming
ada beberapa proses yang berjalan pada satu waktu dan untuk
meningkatkan performansi dari CPU. Beberapa proses disimpan dalam
memori pada waktu yang sama, ketika satu proses harus menunggu, sistem
operasi mengambil CPU dari proses itu dan memberikannya ke proses
yang lain.

5.3.1. Burst Cycle

Keberhasilan penjadwalan CPU tergantung pada eksekusi proses
yang terdiri dari siklus eksekusi CPU dan I/O wait. Proses bergantian antara
dua state itu. Eksekusi proses dimulai dengan CPU burst. Yang diikuti oleh
I/O burst, kemudian diikuti CPU burst yang lain, kemudian I/O burst, dan
sebagainya. Akhirnya, CPU burst berhenti dengan system request untuk
mengakhiri eksekusi. Pada saat suatu proses dieksekusi, terdapat banyak
CPU burst yang pendek dan terdapat sedikit CPU burst yang panjang.
Program yang I/O bound biasanya sangat pendek CPU burst nya,
sedangkan program yang CPU bound kemungkinan CPU burst nya sangat
lama.
5.3.2. Kriteria Penjadwalan

Algoritma CPU yang berbeda memiliki sifat yang berbeda, dan

pilihan algoritma tertentu dapat mendukung satu kelas proses di atas yang
lain. Dalam memilih algoritma untuk digunakan dalam situasi tertentu, harus
dipertimbangkan sifat-sifat dari berbagai algoritma.

a. Utilisasi CPU
Utilisasi CPU dapat berkisar 0-100 persen. Di sistem yang nyata,
range 40-90 persen.

b. Throughput
Jika CPU sibuk dalam eksekusi proses, kemudian selesai. Salah
satu ukuran kerja adalah banyak proses yang diselesaikan per
satuan waktu.

c. Turnaround Time
Dari sudut pandang proses tertentu, kriteria yang penting adalah
berapa lama waktu yang dibutuhkan untuk eksekusi proses tersebut.
Interval dari waktu pengajuan proses ke waktu penyelesaian. Jumlah
dari periode yang dihabiskan untuk masuk ke memori, menunggu di
ready queue, eksekusi di CPU, dan melakukan I/O.

d. Waiting Time
Jumlah dari periode yang dihabiskan menunggu di ready queue.

e. Response Time
Waktu dari pengajuan permohonan sampai respon pertama
diproduksi. Pengukuran ini disebut response time yang merupakan
waktu yang dibutuhkan untuk memulai respon, bukan waktu yang
dibutuhkan untuk keluaran respon.

5.3.3. Algoritma Penjadwalan

Penjadwalan CPU menyangkut penentuan proses-proses yang ada

dalam ready queue yang akan dialokasikan pada CPU. Terdapat beberapa
algoritma penjadwalan CPU seperti di bawah ini:

a. First Come First Served (FCFS)

Proses yang pertama kali meminta jatah waktu untuk menggunakan
CPU akan dilayani terlebih dahulu. Pada skema ini, proses yang
meminta CPU pertama kali akan dialokasikan ke CPU pertama kali.
 b. Shortest Job First Scheduler (SJF)
Pada penjadwalan SJF, proses yang memiliki CPU burst paling kecil
dilayani terlebih dahulu. SJF adalah algoritma penjadwalan yang
optimal dengan rata-rata waktu tunggu yang minimal.

c. Priority
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.

d. Round Robin
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 milidetik. Setelah waktu
habis, proses ditunda dan ditambahkan pada ready queue.

5.4. Langkah Praktikum

Praktikum ini dilakukan dengan terlebih dahulu terhubung dengan
layanan aws educate dengan cara mengaktifkan instance dari halaman
instance summary. Pilih action dan Start untuk mengaktifkan instance.
Lakukan koneksi SSH dengan cara yang sama seperti pada Bab 1.

Lakukan percobaan pada kode program berikut.

main.c
1 #include<stdio.h>
2 #include<string.h>
3
4 int main() {
5 // n= banyak proses, AT= Arrival Time, WT=
Waiting Time, TAT= TurnAround Time
6 // b= burst time, TotWT= Total Waiting
Time, TotTA= Total TurnAround time
7 // name= nama proses, AvWT= Average
Waiting Time, AvTA= Average TurnAround time
8 int n, AT[100], b[100], i, j, tmp,
WT[100], TAT[100], time[100];
9 int TotWT=0, TotTA=0;
10 float AvWT, AvTA;
11 char name[20][20], tmpName[20];
12 printf("\t Algoritma CPU Scheduling FCFS
\n");
13 puts("");
14 printf("Jumlah Proses\t= "); scanf("%d",
&n);
15 puts("");
16
17 // Masukkan data yang diproses
18 for(i = 0; i < n; i++) {
19 fflush(stdin);
20 printf("Nama Proses\t=
");scanf("%s", name[i]);
21 printf("Arrival time\t= ");
scanf("%d", &AT[i]);
22 printf("Burst time\t= ");
scanf("%d", &b[i]);
23 puts("");
24 }
25
26 // Urutkan Data
27 for(i = 0; i < n; i++) {
28 for(j = i + 1; j < n; j++) {
29 if(AT[i] > AT[j]) {
30 //tukar nama
31 strcpy(tmpName, name[i]);
32 strcpy(name[i], name[j]);
33 strcpy(name[j], tmpName);
34
35 //tukar arrival time
36 tmp=AT[i];
37 AT[i]=AT[j];
38 AT[j]=tmp;
39
40 //tukar burst
41 tmp=b[i];
42 b[i]=b[j];
43 b[j]=tmp;
44 }
45 }
46 }
47
48 time[0]=AT[0];
49 puts("\n\t Tabel Proses ");
50 puts("====================================
======");
51 printf("| no | proses\t | time arrival\t |
burst |\n");
52 puts("————————————————————————————————————
——————");
53
54 for (i = 0; i < n; i++) {
55 printf("| %2d | %s\t | \t%d\t | %d\t
|\n", i+1, name[i], AT[i], b[i]);
56 time[i+1]=time[i]+b[i]; //menghitung
time pada gant chart
57 WT[i]=time[i]-AT[i];
58 TAT[i]=time[i+1]-AT[i];
59 TotWT+=WT[i];
60 TotTA+=TAT[i];
61 }
62
63 puts("====================================
======");
64 printf("\tTotal waiting time\t= %d \n",
TotWT);
65 printf("\tTurn around time\t= %d \n",
TotTA);
66 puts("\n\t Tabel Waktu Proses ");
67 puts("====================================
==============");
68 printf("| no | proses\t | waiting time\t |
turn arround\t |\n");
69 puts("————————————————————————————————————
——————————————");
70
71 for(i = 0; i < n; i++) {
72 printf("| %2d | %s\t | \t%d\t |
\t%d\t |\n", i+1, name[i], WT[i],
73 TAT[i]);
74 }
75
76 puts("====================================
==============");
77
78 //untuk Gant Chart
79 puts("\n");
80 puts("\t Gant-Chart \n");
81
82 for(i = 0; i < n; i++) {
83 printf(" %s\t ", name[i]);
84 }
85
86 puts("");
87
88 for(i = 0; i < n; i++) {
89 printf("|=========");
90 }
91
92 printf("|\n");
93
94 for(i = 0; i <= n; i++) {
95 printf(" %d\t ", time[i]);
96 }
97
98 printf("//diperoleh dari penjumlahan
Burst");
99 puts("\n");
100 AvWT=(float)TotWT/n;
 101 AvTA=(float)TotTA/n;
102 printf("\tAverage Waiting Time : %f\n",
AvWT);
103 printf("\tAverage Turn Around
TIme : %f\n", AvTA);
104 }

1. Lakukan kompilasi kode program dengan menggunakan

perintah gcc penjadwalan.c -o penjadwalan
Jawab:
 Gambar 1 Screenshot hasil membuat kode program dan menyimpannya

Gambar 2 Screenshot hasil kompilasi program

Langkah pertama adalah membuat nano penjadwalan.c

lalu memasukkan kode program sesuai dengan yang diberikan
dan menyimpannya seperti pada Gambar 1. Langkah
selanjutnya adalah melakukan kompilasi kode program
dengan menggunakan perintah gcc penjadwalan.c -o
penjadwalan seperti pada Gambar 2.

2. Jalankan hasil kompilasi menggunakan perintah ./main

3. Masukkan variabel berikut dengan jumlah proses sebanyak 3:

Nama Proses Arrival Time Burst Time

p1 0 3
p2 1 2
p3 2 1
4. Capture/ Snapshot output-nya dan simpan sebagai laporan.
Jawab:

Gambar 3 Screenshot hasil menjalankan prorgam dan memasukkan variabel

Gambar 4 Screenshot output

Langkah berikutnya adalah menjalankan program kemudian

memasukkan variabel sesuai dengan soal yang diberikan dan
jumlah proses sebanyak 3 seperti pada Gambar3. Lalu muncul
output seperti pada Gambar 4.

5. Jalankan program tersebut beberapa kali dengan nilai variabel

masukkan yang berbeda-beda.

6. Amati output hasil percobaannya.

Jawab:
Gambar 5 Screenshot hasil memasukkan variabel dengan bebas percobaan pertama

Gambar 6 Screenshot output percobaan pertama

 Gambar 7 Screenshot hasil memasukkan variabel dengan bebas percobaan kedua

Gambar 8 Screenshot output percobaan kedua

Langkah berikutnya adalah menjalankan program kemudian

memasukkan variabel dengan jumlah proses nilai variabel
sesuai yang saya inginkan sebanyak 2 kali percobaan. Seperti
pada Gambar 5 saya memasukkan variabel dan pada Gambar
6 adalah output dari percobaan pertama. Lalu pada percobaan
ke-2 yaitu Gambar 7 saya memasukkan variabel dan pada
Gambar 8 adalah outputnya.

7. Dari hasil percobaan tersebut, simpulkanlah jenis algoritma

penjadwalan apa yang digunakan dalam program tersebut?
Jawab:
Dari percobaan yang saya lakukan, saya menyimpulkan
bahwa jenis algoritma penjadwalan yang digunakan dalam
program tersebut adalah penerapan dari algoritma schedulling
First Come First Served (FCFS). Alasannya karena apabila
waktu masuk sebuah proses lebih cepat dibandingkan dengan
proses lainnya, maka proses tersebut dijalankan hingga
berakhir kemudian proses lainnya yang di dalam antrian juga
akan masuk tanpa adanya penyelaan. Hal tersebut memang
benar sesuai dengan prinsip Algoritma Scheduling FCFS.
 LABORATORIUM PEMBELAJARAN ILMU KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS BRAWIJAYA

NAMA : YOLANDA SAPUTRI

NIM : 195150201111064
TUGAS : BAB V
TANGGAL : 11/11/2020
ASISTEN : FRANKLID GUNAWAN

1. Login ke sistem GNU/ Linux kemudian buka terminal.

Jawab:

Gambar 9 Screenshot PuTTy

Gambar 9 adalah screenshot dari terminal yang saya gunakan.

2. Lakukan percobaan terhadap kode program berikut.

main.c
1 #include<stdio.h>
2
3 int main() {
4 int i,j,n,time,remain,flag=0,tq;
5 int TotWT=0,TotTA=0,AT[100],b[100],rt[100];
6 printf("Masukkan jumlah proses : ");
7 scanf("%d",&n);
8 remain=n;
9
10 for(i = 0; i < n; i++) {
11 printf("Masukkan arrival time untuk
Proses P%d :",i+1);
12 scanf("%d",&AT[i]);
13 printf("Masukkan burst time untuk
Proses P%d :",i+1);
14 scanf("%d",&b[i]);
15 rt[i]=b[i];
 16 }
17
18 printf("Masukkan time quantum ");
19 scanf("%d",&tq);
20 printf("\n\nProcess\t|Turnaround
time|waiting time\n\n");
21
22 for(time=0,i=0;remain!=0;) {
23 if(rt[i] <= tq && rt[i] > 0) {
24 time+=rt[i];
25 rt[i]=0;
26 flag=1;
27 } else if(rt[i] > 0) {
28 rt[i]-=tq;
29 time+=tq;
30 }
31
32 if(rt[i]==0 && flag==1) {
33 remain--;
34
35 printf("P[%d]\t|\t%d\t|\t%d\n",i+1,time-
AT[i],time-AT[i]-b[i]);
36 TotWT+=time-AT[i]-b[i];
37 TotTA+=time-AT[i];
38 flag=0;
39 }
40
41 if(i==n-1)
42 i=0;
43 else if(AT[i+1]<=time)
44 i++;
45 else
46 i=0;
47 }
48
49 printf("\nAverage Waiting Time
= %f\n",TotWT*1.0/n);
50 printf("Average Turnaround Time
= %f\n",TotTA*1.0/n);
51 return 0;
52 }

Jawab:
 Gambar 10 Screenshot hasil membuat kode program dan menyimpannya

Gambar 10 adalah screenshot hasil saya membuat nano

roundrobin.c dengan kode seperti yang diberikan dan saya
menyimpannya.

3. Lakukan kompilasi kode program dengan menggunakan perintah

gcc roundrobin.c -o roundrobin
Jawab:
 Gambar 11 Screenshot hasil kompilasi program

Pada Gambar 11 adalah screenshot hasil kompilasi program dengan

perintah gcc roundrobin.c -o roundrobin.

4. Jalankan hasil kompilasi menggunakan perintah ./roundrobin

5. Masukkan variabel berikut dengan: jumlah proses sebanyak 3, time

quantum 2, dan

Nama Proses Arrival Time Burst Time

p1 0 3
p2 1 2
p3 2 1

6. Amati hasil outputnya!

Jawab:
 Gambar 12 Screenshot hasil memasukkan variabel beserta outputnya

Saya menjalankan hasil kompilasi program dengan

perintah ./roundrobin. Selanjutnya memasukkan variabel yang
diperintahkan dan jumlah proses sebanyak 3 serta time quantumnya
2 seperti pada Gambar 12. Gambar 12 juga menampilkan outputnya.
Dapat dilihat bahwa untuk masing-masing proses memiliki waktu
waiting time yang cukup kecil dengan avarage waiting time yang
sedikit juga.

7. Jika variabel pada nomor 4 diatas diubah menjadi: jumlah proses

sebanyak 3, time quantum 2, dan

Nama Proses Arrival Time Burst Time

p1 0 5
p2 20 4
p3 25 5

8. Amati hasil outputnya!

Jawab:
 Gambar 13 Screenshot hasil memasukkan variabel beserta outputnya

Saya menjalankan hasil kompilasi program dengan

perintah ./roundrobin. Selanjutnya memasukkan variabel yang
diperintahkan dan jumlah proses sebanyak 3 serta time quantumnya
2 seperti pada Gambar 13. Gambar 13 juga menampilkan outputnya.
Terlihat bahwa proses berjalan secara terus menerus tanpa henti
sampai akhirnya saya hentikan dengan paksa. Hal ini disebabkan
oleh adanya flag pada kode program yang telah diberikan. Flag
tersebut apabila bernilai nol dan remain time (rt) pada baris ke 32
bernilai 0, maka remain tidak akan berkurang dan flag tidak akan
menjadi 1. Hal ini menyebabkan proses terkunci di baris tersebut
sehingga akan mengalami infinite loop (perulangan tak hingga).

9. Berdasarkan hasil pengamatan anda, maka algoritma apa yang

digunakan dalam program tersebut?
Jawab:
Dari hasil pengamatan yang saya lakukan, saya menyimpulkan
bahwa jenis algoritma penjadwalan yang digunakan dalam program
tersebut adalah Round Robin. Algoritma ini menggilir proses yang
ada di antrian. Proses akan mendapat jatah sebesar time quantum.
Apabila time quantum tersebut habis atau proses telah selesai, CPU
akan dialokasikan ke proses berikutnya. Proses ini cukup adil karena
tidak ada proses yang diprioritaskan, semua proses mendapat jatah
waktu yang sama dari CPU. Algoritma Round Robin ini sepenuhnya
bergantung pada besarnya time quantum. Jika terlalu besar makan
akan sama dengan algoritma FCFS. Sedangkan jika terlalu kecil akan
semakin banyak peralihan proses sehingga waktu banyak yang
terbuang. Permasalahan utama pada algoritma Round Robin adalah
menentukan besarnya time quantum. Time quntum yang ideal adalah
jika 80% dari total proses memiliki CPU burst time yang lebih kecil
dari 1 time quantum. Adanya time quantum ini juga yang membagikan
jatah kepada setiap proses sehingga proses 1 pada inputan pertama
memiliki waiting time lebih dari nol.
 LABORATORIUM PEMBELAJARAN ILMU KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS BRAWIJAYA

NAMA : YOLANDA SAPUTRI

NIM : 195150201111064
KESIMPULAN : BAB V
TANGGAL : 11/11/2020
ASISTEN : FRANKLID GUNAWAN

Jelaskan kesimpulan dari hasil percobaan pada Bab 5 ini.

Setiap penjadwalan memiliki algoritma tertentu. Algoritma yang

digunakan akan menentukan proses mana yang selesai terlebih dahulu,
proses mana yang diletakkan di akhir, dan bagaimana keseluruhan
proses berjalan berdasarkan gant chart. Algoritma scheduling terdiri atas
beberapa jenis. Di antaranya Priority, First Come First Served (FCFS),
Shortest Job First (SJF), dan Round Robin. Pada praktikum ini yang
disertakan adalah algoritma FCFS dan Round Robin.

Pada percobaan praktikum kali ini menggunakan algoritma FCFS

dan Round Robin. Kedua algoritma FCFS dan Round Robin memiliki
perbedaan di mana FCFS akan menjalankan proses secara berurutan
sehingga tidak ada waiting time untuk proses pertama, dan proses
setelahnya akan mengikuti arrival time dan masing-masing proses akan
dijalankan hingga akhir. Sedangkan Round Robin akan membagikan
jatah running untuk setiap proses yang terdapat di antrean. Sehingga,
algoritma ini akan membagikan waktu waiting time untuk keseluruhan
proses. Apabila tidak terdapat proses selanjutnya maka akan menunggu
hingga akhir sehingga terjadinya starvation. Kedua algoritma ini cocok
digunakan dalam sistem operasi namun memiliki kekurangan dan
kelebihannya masing-masing.

54.158.194.181

3.95.208.86