Praktikum Sistem Operasi CPU Schedulling
Praktikum Sistem Operasi CPU Schedulling
Tugas 01
Agung Pambudi
519/Pra-MIK/35/2017
Agung Pambudi 519/Pra-MIK/35/2017
Table of Contents
FCFS (First-come First-served) .................................................................................................. 2
SJF (Shortest Job First) / SJN (Shortest Job Next) ..................................................................... 3
Round Robin ............................................................................................................................... 5
Priority Based.............................................................................................................................. 6
Multi-level Queue ....................................................................................................................... 7
Questions & Answers ................................................................................................................. 8
1. Operating System .............................................................................................................. 8
2. Types of Operating Systems ............................................................................................. 8
3. Process .............................................................................................................................. 10
4. CPU Schedulling ............................................................................................................... 10
5. Arrival time, Burst time, Waiting time, Turnaround time................................................. 10
6. Advantages of Round Robin CPU Scheduling Algorithm ................................................ 11
7. CPU Scheduling Algorithm for Real-time OS .................................................................. 11
8. CPU Algorithm with highest waiting time ....................................................................... 11
9. Optimal CPU scheduling algorithm in practice ................................................................ 11
10. The real difficulty with the SJF CPU scheduling algorithm ............................................. 11
11. C program for Round Robin Algorithm ............................................................................ 12
12. C program for Preemptive Shortest Job First Algorithm .................................................. 13
13. Multi-level Queue CPU Schedulling ................................................................................ 14
14. Difference between the general CPU scheduling algorithms ........................................... 14
15. CPU-bound and I/O-bound process .................................................................................. 14
16. Parameters for designing a multilevel feedback queue scheduler..................................... 15
17. Difference between multi-level queue and multi-level feedback queue ........................... 15
18. Advantages and Disadvantages of Multi-level queue and multi-level feedback queue CPU
scheduling algorithms ....................................................................................................... 15
19. C program for Multi-level queue Algorithm..................................................................... 16
REFERENCES ........................................................................................................................... 17
ALGORITMA
Process Waiting time
P0 0 (Proses pertama selalu bernilai 0)
P1 Burst time P0 + Waiting time P0
P2 Burst time P1 + Waiting time P1
dst. dst.
Process Turnaround time
P0 Burst time P0 + Waiting time P0
P1 Burst time P1 + Waiting time P2
P2 Burst time P1 + Waiting time P2
dst. dst.
Average Waiting Time Waiting time / Proses
Average Turnaround Time Turnaround time / Proses
CONTOH PROGRAM
Process BT WT TT
P0 8 0 8 AWT = (0+8+11+31) / 4 = 12.50
P1 3 8 11 ATT = (8+11+31+38) / 4 = 22.00
P2 20 11 31
P3 7 31 38
GANTT CHART
ALGORITMA
1. Tentukan urutan prioritas berdasarkan pendeknya proses yang dilayani.
2. Penentuan proses mana yang akan dilayani oleh pemroses.
SJF akan optimal, ketika rata-rata waktu tunggu minimum untuk setiap proses sudah ditetapkan.
Contoh:
Process diberikan BT Process berjalan BT
P1 6 P4 3
P2 8 P1 6
P3 7 P3 7
P4 3 P2 8
SJF Non-preemptive
Process AT BT
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
1. Pertama, pada urutan pertama masukkan proses yang memiliki arrival time terkecil. dan proses
selanjutnya melihat burst time terkecil
2. Menghitung rata-rata, waktu tunggu dikurangi arrival time diperoleh waktu tunggu untuk P1
adalah 0, P2 adalah 6, P3 adalah 3 dan P4 adalah 7 sehingga rata-rata waktu tunggu adalah
(0 + 6 + 3 + 7) /4 = 4 milidetik.
SJF Pre-emptive
Process AT BT
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
5. Menghitung rata-rata, jika proses terjadi lebih dari 1 kali misal P1 ada dua seperti gantchart
diatas di awal dan diakhir. Cara menghitung adalah waktu tunggu yang terakhir dikurangi
waktu proses yang pertama. Jadi 11-2=9 P1=9
6. Jika proses hanya terjadi 1 kali maka cara menghitungnya adalah waktu tunggu dikurangi
arrival time.
7. Sisa
P1 = 5
P2 = 2
P4 = 4
8. Urutkan dari sisa yang paling kecil. Diperoleh P2, P4, P5
9. Waktu tunggu untuk P1 adalah 9, P2 adalah 1, P3 adalah 0 dan P4 adalah 2 sehingga rata-rata
waktu tunggu adalah (9 + 1 + 0 + 2)/4 = 3 milidetik.
CONTOH PROGRAM
Process diberikan BT Process berjalan BT WT TT
P0 8 P1 3 0 3
AWT = (0+3+10+18) / 4 = 7.75
P1 3 P3 7 3 10 ATT = (3+10+18+30) / 4 = 17.25
P2 20 P0 8 10 18
P3 7 P2 20 18 30
GANTT CHART
Round Robin
Round Robin adalah algoritma proses penjadwalan pre-emptive.
Proses yang dijalankan sudah ditetapkan waktunya (quantum time).
ALGORITMA
Sebelum proses di jalankan, tentukan dulu quantum timenya.
Jika proses memiliki CPU Burst < Quantum Time, maka proses akan melepaskan CPU, jika
telah selesai digunakan, CPU dapat segera digunakan oleh proses selanjutnya.
Jika proses memiliki CPU Burst > Quantum Time, maka proses tersebut akan dihentikan jika
sudah mencapai quantum time dan selanjutnya mengantri kembali pada posisi tail queue (ekor
dari ready queue), CPU kemudian menjalankan proses berikutnya.
Jika quantum time belum habis dan proses menunggu suatu kejadian (selesainya operasi I/O),
maka proses menjadi blocked dan CPU dialihkan ke proses lain.
CONTOH PROGRAM
Proses berikut menggunakan quantum time = 4 msec.
Dengan menggunakan rumus : Burst time - Quantum
Burst time yang tersisa, dimasukkan kembali kedalam antrian sesuai dengan urutan Prosesnya.
GANTT CHART
Priority Based
Merupakan algoritma non-preemptive dan salah satu algoritma penjadwalan yang paling umum
dalam sistem batch.
Setiap proses diberikan prioritas. Proses dengan prioritas tertinggi akan dieksekusi pertama dan
seterusnya.
Proses dengan prioritas yang sama akan dijalankan berdasar first come first served.
Prioritas dapat diputuskan
ALGORITMA
Pertama-tama proses yang dimasukkan dilakukan pengurutan berdasar Prioritas.
Process Waiting time
Proses dengan priority tertinggi ke-1 0 (Proses pertama selalu bernilai 0)
Proses dengan priority tertinggi ke-2 Burst time 1st process + Waiting time 1st process
Proses dengan priority tertinggi ke-3 Burst time 2nd process + Waiting time 2nd process
dst. dst.
Process Turnaround time
Proses dengan priority tertinggi ke-1 Burst time 1st process + Waiting time 1st process
Proses dengan priority tertinggi ke-2 Burst time 2nd process + Waiting time 2nd process
Proses dengan priority tertinggi ke-3 Burst time 3rd process + Waiting time 3rd process
dst. dst.
Average Waiting Time Waiting time / Proses
Average Turnaround Time Turnaround time / Proses
CONTOH PROGRAM
Process BT Priority Process BT Priority WT TT
P0 5 2 P1 7 1 0 7 AWT = (0+7+14+18+23) / 5 = 12.40
P1 7 1 P3 7 1 7 14 ATT = (7+14+18+23+32) / 5 = 18.79
P2 4 2 P2 4 2 14 18
P3 7 1 P0 5 2 18 23
P4 9 5 P4 9 5 23 32
GANTT CHART
Multi-level Queue
Multi-level queue bukan merupakan algoritma penjadwalan yang independen. Mereka memanfaatkan
algoritma lain yang ada untuk mengelompokkan dan menjadwalkan pekerjaan dengan karakteristik
umum sebagai berikut:
Beberapa antrian dikelola untuk proses dengan karakteristik umum.
Setiap antrian dapat memiliki algoritma penjadwalan sendiri.
Prioritas ditetapkan untuk setiap antrian.
Misalnya, pekerjaan CPU-bound dapat dijadwalkan dalam satu antrian dan semua pekerjaan I/O-bound
di antrian lainnya. Proses Scheduler kemudian bergantian memilih pekerjaan dari masing-masing
antrian dan menetapkannya ke CPU berdasarkan algoritma yang ditetapkan untuk antrian.
ALGORITMA
Proses dijalankan berdasar System Process terlebih dahulu, setelah selesai diteruskan dengan User
Process. Sedangkan urutannya tidak bergantung pada besar/kecil Burst time, melainkan secara first
come first served.
CONTOH PROGRAM
Process BT Type Process BT Type WT TT
P0 3 User P1 5 System 0 5 AWT = (0+5+8+11) / 4 = 6.00
P1 5 System P2 3 System 5 8 ATT = (5+8+11+13) / 4 = 9.25
P2 3 System P0 3 User 8 11
P3 2 User P3 2 User 11 13
GANTT CHART
Masalah reliabilitas.
Pertanyaan keamanan dan integritas dari user program dan data.
Masalah komunikasi data.
Sebuah sistem operasi real-time harus memiliki definisi yang baik, kendala
waktu yang tetap, karena jika tidak maka sistem akan gagal. Misalnya, percobaan
ilmiah, sistem pencitraan medis, sistem kontrol industri, sistem senjata, robot, sistem
kontrol lalu lintas udara, dll.
Ada dua jenis sistem operasi real-time:
1. Hard real-time systems
Menjamin bahwa critical tasks akan selesai tepat waktu.
Penyimpanan sekunder terbatas atau hilang dan data disimpan dalam ROM.
Memori virtual hampir tidak pernah ditemukan.
3. Process
Sebuah proses pada dasarnya adalah sebuah program yang sedang di eksekusi/di jalankan.
Pelaksanaan proses harus secara berurutan. Sebuah proses didefinisikan sebagai suatu entitas
yang mewakili unit dasar dari pekerjaan yang harus dilaksanakan dalam sistem.
4. CPU Schedulling
Penjadwalan CPU adalah pemilihan proses dari antrian yang ready untuk dapat dieksekusi.
Penjadwalan CPU merupakan konsep dari multiprogramming, dimana CPU digunakan secara
bergantian untuk proses yang berbeda. Suatu proses terdiri dari dua siklus yaitu Burst I/O dan
Burst CPU yang dilakukan bergantian hingga proses selesai.
Namun bila di praktiknya maka algoritma penjadwalan harus menyesuaikan dengan kondisi yang
sedang terjadi. Sebagai contoh sistem penjualan tiket online, dimana yang bisa mendapatkan tiket
(sesuai dengan pilihan banyak user) ialah user yang tercepat atau di gambarkan dengan burst time
terkecil. Pada kasus ini sama halnya dengan algoritma penjadwalan SJF.
Kesimpulannya bahwa setiap jenis simulasi untuk setiap algoritma penjadwalan CPU memiliki
keterbatasan. Satu-satunya cara untuk mengevaluasi algoritma tersebut ialah dengan membuat kode dan
memasukkannya ke dalam sistem operasi, dimana kemudian kemampuan kerja yang tepat dari
algoritma tersebut dapat diukur dalam sistem real time.
10. The real difficulty with the SJF CPU scheduling algorithm
Kesulitan sesungguhnya dengan algoritma SJF adalah, untuk mengetahui panjang permintaan CPU
berikutnya. SJF meminimalkan average waiting time karena menjalankan proses dengan burst time
kecil sebelum yang besar. Sementara itu karena meminimalkan average waiting time, mungkin proses
dengan burst time yang besar cenderung tertinggal dalam daftar.
1. #include<stdio.h>
2. int main()
3. {
4. int i, limit, total=0, x, counter=0, time_quantum;
5. int wait_time=0, turnaround_time=0, arrival_time[10], burst_time[10], temp[10];
6. float average_wait_time, average_turnaround_time;
7. printf("\nEnter Total Number of Processes:\t");
8. scanf("%d", &limit);
9. x = limit;
10. for(i=0; i<limit; i++)
11. {
12. printf("\nEnter Details of Process[%d]\n", i+1);
13. printf("Arrival Time : ");
14. scanf("%d", &arrival_time[i]);
15. printf("Burst Time : ");
16. scanf("%d", &burst_time[i]);
17. temp[i] = burst_time[i];
18. }
19. printf("\nEnter Time Quantum:\t");
20. scanf("%d", &time_quantum);
21. printf("\nProcess ID\t\tBurst Time\t Turnaround Time\t Waiting Time\n");
22. for(total=0, i=0; x!=0;)
23. {
24. if(temp[i] <= time_quantum && temp[i] > 0){
25. total = total + temp[i];
26. temp[i] = 0;
27. counter = 1;
28. }
29. else if(temp[i] > 0){
30. temp[i] = temp[i] - time_quantum;
31. total = total + time_quantum;
32. }
33. if(temp[i] == 0 && counter == 1){
34. x--;
35. printf("\nProcess[%d]\t\t%d\t\t %d\t\t\t %d", i+1, burst_time[i],
total-arrival_time[i], total-arrival_time[i]-burst_time[i]);
36. wait_time = wait_time+total-arrival_time[i]-burst_time[i];
37. turnaround_time = turnaround_time+total-arrival_time[i];
38. counter = 0;
39. }
40. if(i==limit-1){
41. i=0;
42. }
43. else if(arrival_time[i+1] <= total){
44. i++;
45. }
46. else{
47. i=0;
48. }
49. }
50. average_wait_time = wait_time*1.0 / limit;
51. average_turnaround_time = turnaround_time*1.0 / limit;
52. printf("\n\nAverage Waiting Time:\t%f", average_wait_time);
53. printf("\nAvg Turnaround Time:\t%f\n", average_turnaround_time);
54. return 0;
55. }
First come first serve Algoritma ini mendahulukan proses yang lebih dulu datang.
Kelemahannya,waiting time rata-rata cukup lama.
Shortest job first Algoritma ini mendahulukan proses dengan CPU burst terkecil yang
akan mengurangi waiting time rata-rata.
Priority Algoritma ini mendahulukan prioritas terbesar. Kelemahannya,
prioritas kecil tidak mendapat jatah CPU. Hal ini dapat diatasi dengan
aging,yaitu semakin lama menunggu,prioritas semakin tinggi.
Round Robin Algoritma ini menggilir proses-proses yang ada diantrian dengan jatah
time quantum yang sama. Jika waktu habis,CPU dialokasikan keproses
selanjutnya.
Multilevel Queue Algoritma ini membagi beberapa antrian yang akan diberi prioritas
berdasarkan tingkatan. Tingkatan lebih tinggi menjadi prioritas utama.
Multilevel Feedback Queue Pada dasarnya sama dengan Multilevel Queue, bedanya pada
algoritma ini diizinkan untuk pindah antrian.
Semua proses yang baru datang akan diletakkan pada queue 0 (quantum = 8 ms).
Jika suatu proses tidak dapat diselesaikan dalam 8 ms, maka proses tersebut akan
dihentikan dan dipindahkan ke queue 1 (quantum = 16 ms).
Queue 1 hanya akan dikerjakan jika tidak ada lagi proses di queue 0, dan jika suatu proses
di queue 1 tidak selesai dalam 16 ms, maka proses tersebut akan dipindahkan ke queue 2.
Queue 2 akan dikerjakan bila queue 0 dan 1 kosong, dan akan berjalan dengan algoritma
FCFS.
1. #include<stdio.h>
2. main()
3. {
4. int p[20], bt[20], pri[20], su[20], wt[20], tat[20], i, k, n, temp;
5. float wtavg, tatavg;
6. printf("Enter the number of processes : ");
7. scanf("%d",&n);
8. for(i=0;i<n;i++)
9. {
10. p[i] = i;
11. printf("Enter the Burst Time & Priority of Process %d : ",i);
12. scanf("%d %d",&bt[i], &pri[i]);
13. printf("System/User Process (0/1) ? : ");
14. scanf("%d", &su[i]);
15. }
16. for(i=0;i<n;i++)
17. for(k=i+1;k<n;k++)
18. if(su[i] > su[k])
19. {
20. temp=p[i];
21. p[i]=p[k];
22. p[k]=temp;
23. temp=bt[i];
24. bt[i]=bt[k];
25. bt[k]=temp;
26. temp=su[i];
27. su[i]=su[k];
28. su[k]=temp;
29. }
30. if(pri[i] > pri[k])
31. {
32. temp=p[i];
33. p[i]=p[k];
34. p[k]=temp;
35. temp=bt[i];
36. bt[i]=bt[k];
37. bt[k]=temp; temp=pri[i];
38. pri[i]=pri[k];
39. pri[k]=temp;
40. }
41. wtavg = wt[0] = 0;
42. tatavg = tat[0] = bt[0];
43. for(i=1;i<n;i++)
44. {
45. wt[i] = wt[i-1] + bt[i-1];
46. tat[i] = tat[i-1] + bt[i];
47. wtavg = wtavg + wt[i];
48. tatavg = tatavg + tat[i];
49. }
50. printf("\nPROCESS\t\t SYSTEM/USER PROCESS\t PRIORITY\t BURST TIME\t WAITING
TIME\t TURNAROUND TIME");
51. for(i=0;i<n;i++)
52. printf("\n%d \t\t %d \t\t\t %d \t\t %d \t\t %d \t\t %d ",p[i],su[i],pri
[i],bt[i],wt[i],tat[i]);
53. printf("\n\nAverage Waiting Time is : %f",wtavg/n);
54. printf("\nAverage Turnaround Time is : %f",tatavg/n);
55. getch();
56. }
REFERENCES
https://www.tutorialspoint.com/operating_system/
https://en.wikipedia.org/wiki/Real-time_operating_system
http://research.cs.queensu.ca/home/akl/techreports/scheduling.pdf
http://cgi.csc.liv.ac.uk/~trp/Teaching_Resources/COMP204/204-Lecture12.pdf
http://www.sciencehq.com/computing-technology/1353.html
http://dini3asa.staff.gunadarma.ac.id/Downloads/files/19322/PENJADWALANPROSES.pdf.
http://www.ijetae.com/files/Volume4Issue1/IJETAE_0114_15.pdf