Algoritma Penjadwalan CPU Round Robin Menggunakan Bahasa C++

A. Dasar Teori Penjadwalan CPU 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.
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 burst yang lebih
besar dibandingkan 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.

Ketentuan

Ketentuan algoritma round robin adalah sebagai berikut:

1. Jika quantum dan proses belum selesai maka proses menjadi runnable dan pemroses
dialihkan ke proses lain.
2. Jika quantum belum habis dan proses menunggu suatu kejadian (selesainya operasi I/O),
maka proses menjadi blocked dan pemroses dialihkan ke proses lain.
3. Jika quantum belum habis tapi proses telah selesai, maka proses diakhiri dan pemroses
dialihkan ke proses lain.

Algoritma ini sepenuhnya bergantung besarnya time quantum. Jika terlalu besar, algoritma ini
akan sama saja dengan algoritma first come first served. Jika terlalu kecil, akan semakin banyak
peralihan proses sehingga banyak waktu terbuang. Algoritma penjadwalan ini dapat
diimplementasi sebagai berikut: Mengelola senarai proses read (runnable) sesuai urutan
kedatangan. Ambil proses yang berada di ujung depan antrian menjadi running. Bila quantum
belum habis dan proses selesai maka ambil proses di ujung depan antrian proses ready. Jika
quantum habis dan proses belum selesai maka tempatkan proses running ke ekor antrian proses
ready dan ambil proses di ujung depan antrian proses ready.

B. Bentuk Algoritma

Algoritma ini menggilir proses yang ada di antrian. Proses akan mendapat jatah sebesar time
quantum. Jika time quantum-nya habis atau proses sudah selesai, CPU akan dialokasikan ke
proses berikutnya. Tentu proses ini cukup adil karena tak ada proses yang diprioritaskan, semua
proses mendapat jatah waktu yang sama dari CPU yaitu (1/n), dan tak akan menunggu lebih lama
dari (n-1)q dengan q adalah lama 1 quantum. Algoritma ini sepenuhnya bergantung besarnya
time quantum. Jika terlalu besar, algoritma ini akan sama saja dengan algoritma first come first
served. Jika terlalu kecil, akan semakin banyak peralihan proses sehingga banyak waktu
terbuang.

Permasalahan utama pada round robin adalah menentukan besarnya time quantum. Jika time
quantum yang ditentukan terlalu kecil, maka sebagian besar proses tidak akan selesai dalam 1
quantum. Hal ini tidak baik karena akan terjadi banyak switch, padahal CPU memerlukan waktu
untuk beralih dari suatu proses ke proses lain (disebut dengan context switches time).
Sebaliknya, jika time quantum terlalu besar, algoritma Round Robin akan berjalan seperti
algoritma first come first served. Time quantum yang ideal adalah jika 80% dari total proses
memiliki CPU burst time yang lebih kecil dari 1 time quantum.

Urutan Event dalam algoritma Round Robin

Penggunaan Waktu Quantum

Berikut adalah algoritma penjadwalan Round Robin secara Keseluruhan :

Setiap proses mendapat jatah waktu CPU (time slice/quantum) tertentu Time
slice/quantum umumnya ntara 10 100 milidetik.

1. Setelah time slice/quantum maka proses akan di-preempt dan dipindahkan ke antrian ready.
2. Proses ini adil dan sangat sederhana.

Jika terdapat n proses di antrian ready dan waktu quantum q (milidetik), maka:

1. Maka setiap proses akan mendapatkan 1/n dari waktu CPU.

2. Proses tidak akan menunggu lebih lama dari: (n-1)q time units.

Performance dari algoritma ini tergantung dari ukuran time quantum

1. Time Quantum dengan ukuran yang besar maka akan sama dengan FCFS.
2. Time Quantum dengan ukuran yang kecil maka time quantum harus diubah ukurannya lebih
besar dengan respek pada context switch sebaliknya akan memerlukan ongkos yang besar.

Menghitung Average Waiting Time dalam Algoritma Penjadwalan Round Robin

Dalam algoritma penjadwalan proses Round Robin, proses akan diberikan porsi waktu
pengerjaan yang sama dari tiap-tiap prosesnya. Algoritma Round Robin ini disebut dengan
algoritma yang adil. Untuk memahami dari cara kerja algoritma penjadwalan Round Robin ini,
mari kita kerjakan soal berikut :

Hitunglah Average Waiting Times proses di atas dengan menggunakan algoritma penjadwalan
Round Robin dengan QT = 5 ms.

Penyelesaian:

Seperti halnya algoritma penjadwalan sebelumnya, langkah pertama untuk mencari AWT
dengan Algoritma penjadwalan Round Robin dilakukan dengan membuat Gantt Chart
prosesnya. Berikut gambarnya:

Dari Gantt Chart di atas terlihat bahwa setiap proses dikerjakan menurut waktu yaitu setiap
proses di proses sebesar 5. Awalnya P1 akan di kerjakan sebanyak 5 langkah, kemudian, P2
sebanyak 5 langkah, dan begitupun selanjutnya hingga P5. Proses yang sudah di proses menurut
porsi waktu yang diberikan akan kembali menunggu dan berada paling belakang dari antrian
proses yang ada. Contohnya P1 dikerjakan di awal, kemudian ada P2, P3,P4,dan P5 yang
mengantri di belakangnya. Jika P1 selesai di proses menurut porsi waktunya maka P1 akan di
pindahkan ke belakang, sehingga urutannya menjadi P2, P3, P4, P4, P1. begitupun seterusnya.

Setelah mendapatkan Gantt Chartnya, sekarang kita menghitung Waiting Time-nya, lihat
gambar di bawah:
 Dari Waiting Times di atas dapat kita tentukan AWTnya yaitu dengan cara :

C. Contoh :
D. Atau Bisa Di Lihat Hasilnya Di Nota
Adapun untuk melihat Sounce Code-nya bisa di lihat dengan cara Klik Disini

File Lengkapnya Silahkan Klik Disini

E. Kesimpulan

Penjadwalan proses adalah urutan kerja yang dilakukan oleh system operasi,ini sangat diperlukan
untuk kelangsungan system operasi dalam menentukan proses yang akan dieksekusi.

Berdasarkan segi waktu penyelesaian proses, penjadwalan proses preemptive dinilai lebih
efektif, karena dalam penjadwalan metode ini proses-proses dengan waktu proses yang lebih
pendek akan selesai lebih dulu, karena walaupun terdapat proses dengan waktu proses yang lama
berada pada antrian pertama, sedangkan ada proses di antrian kedua dengan waktu proses lebih
pendek, maka proses pada antrian pertama dapat disela untuk mengerjakan proses diantrian
kedua terlebih dahulu hingga selesai, dengan asumsi penjadwalan preemptive tersebut tidak
berprioritas. Beberapa penjadwalan proses yang telah divisualisasikan mempunyai kesamaan
dalam menyelesaikan sebuah proses yang berada di dalam antrian. Proses dengan waktu proses
terpendek akan diselesaikan terlebih dahulu, setelah itu baru proses-proses lainnya yang
mempunyai waktu proses lebih lama.
Metode Penjadwalan Round Robin
Senin, Desember 23, 2013 asti widyaningsih

Langsung saja ya sahabat-sahabatku...

Diketahui ada 4 proses yang arrival time dan burst time sebagai berikut.

Proses Arrival Time Burst Time

P1 0 8

P2 3 5

P3 5 2

P4 6 6

Hitung Waiting Time dan Average Time menggunakan metode penjadwalan Penjadwalan Round Robin.

Jawabannya sebagai berikut.

Metode Round Robin yaitu metode yang setiap prosesnya memperoleh alokasi waktu CPU dalam
quantum waktu yang telah diketahui. Disni quantum time diketahui 3 ms.
Waiting Time
P1 = 0 ms + (11-3 ms) + (19-14 ms) = 13 ms

P2 = (3-3 ms) + (14-6 ms) = 8 ms

P3 = 6 ms - 5 ms = 1 ms

P4 = (8-6 ms) + (16-11 ms) = 7 ms

Jadi, rata-rata waktu yang dibutuhkan pada metode Penjadwalan Round Robin (RR) dengan quantum
time= 3 ms adalah 7,25 mili second.
Belajar Round Robin

Round Robin merupakan salah satu penjadualan proses, dimana algoritma ini menggilir proses
yang ada di antrian. Proses akan mendapatkan jatah sebesar time quantum. Jika time quantum-
nya habis atau proses sudah selesai, CPU akan dialokasikan ke proses berikutnya. Pada
penjadualan proses ini, tidak ada proses yang diprioritaskan, semua proses mendapatkan
pembagian waktu yang sama dari CPU.

*Contoh Pertama :

Sebuah CPU dengan quantum 4 mendapat beberapa proses dengan waktu kedatangan yang
bersamaan eperti berikut:

Langkah Pertama:

Membuat Gantt Chart

Masukkan proses yang berurutan, kemudain kurangi Burst Time dengan nilai quantum.
P1 :

Burst time Quantum

4 4 = 0.

Waktu = 4

P2:

Burst time Quantum

9 4 = 5.

Sisa = 5

Waktu = 4

P3:

Burst time Quantum

6 4 = 2.

Sisa = 2

Waktu = 4

P4:

Burst time Quantum

5 4 = 1.

Sisa = 1

Waktu antrian = 4

P5:

Burst time Quantum

3 4 = (-1).

Waktu antrian = 3

Proses yang memiliki sisa, kemudian dimasukkan kembali kedalam antrian sesuai dengan urutan
Prosesnya.

P2:

Sisa Burst time Quantum

54=1

Sisa = 1

Waktu antrian = 4

P3:

Sisa Burst time Quantum

2 4 = (-2)

Waktu antrian = 2

P4:

Sisa Burst time Quantum

1 4 = (-3)

Waktu antrian = 1

P2:

Sisa Burst time Quantum

1 4 = (-3)

Waktu antrian = 1

Setelah selesai menentukan waktu antrian, kemudian buat table seperti dibawah ini:

Langkah Kedua

Menghitung AWT (Average Waiting Time)

AWT yang terjadi adalah:

(0 + 18 + 19 + 21 + 16)/ 5

= 74 / 5

= 14,8

Langkah Ketiga

Menghitung ATAT (Average Turn Arround Time)

*Contoh Kedua:

Sebuah CPU dengan Quantum 2 mendapat proses yang kedatangannya berbeda beda sebagai
berikut:
 Langkah Pertama

Membuat Gantt Chart

Untuk membuat Gantt Chart pada proses yang kedatangannya berbeda, membuat antrian
disesuaikan dengan waktu kedatangan Proses . Untuk pencarian waktu antrian yang dilakukan
sama seperti yang sebelumnya. Hanya pengurutan dalam antrian saja yang berbeda.

Langkah kedua

Membuat AWT
AWT yang terjadi adalah:

(6 + 3 + 10 + 3 + 8)/5

= 30/5

=6

Langkah ketiga

Membuat ATAT

Selamat mencoba..

Semoga dapat membantu dan bermanfaat, kalau ada salah kata atau kekurangan tolong berikan

masukkan, karena saya pun masih belajar

See ya..
Penjadwalan Round Robin

Penjadwalan Round Robin (RR)

Round robin adalah sebuah susunan yang memilih semua elemen pada grup seperti
beberapa perintah rasional, biasanya dari atas sampai ke bawah sebuah daftar/susunan
dan kembali lagi keatas dan begitu seterusnya. Dapat diandaikan bahwa round robin
seperti mengambil giliran (taking turns).

Dalam cara kerja komputer, satu metode memiliki beberapa proses program yang berbeda
dalam mengambil giliran, dengan menggunakan sumber daya komputer ke batas proses
setiap jangka waktu pendek tertentu, kemudian membatalkan/menghentikan proses yang
sedang berjalan kepada proses yang mendapat giliran berikutnya. Biasa diartikan sebagai
proses Penjadwalan Round Robin.

Dapat dianalogikan seperti turnamen olahraga, dimana round robin menyusun/mengatur

semua tim atau para pemain mengambil/memainkan giliran mereka bermain. Yang akan
menghasilkan pemenang dari turnamen yang telah diselenggarakan.

Pengertian lain Round Robin Merupakan :

Penjadwalan yang paling tua, sederhana, adil,banyak digunakan algoritmanya dan mudah
diimplementasikan/diterapkan.
Penjadwalan ini bukan dipreempt(diinterupsi) oleh proses lain tetapi oleh penjadwal
berdasarkan lama waktu berjalannya proses (preempt by time).
Penjadwalan tanpa prioritas (pengutamaan).
Dapat dikatakan bahwa semua proses memiliki kepentingan yang sama, sehingga tidak
ada prioritas tertentu.
Semua proses dianggap penting sehingga diberi sejumlah waktu oleh pemroses yang
disebut kwanta (quantum) atau time slice dimana proses itu berjalan. Jika proses masih
running sampai akhir quantum, maka CPU akan mempreempt proses itu dan
memberikannya ke proses lain. Penjadwal membutuhkannya dengan memelihara daftar
proses dari runnable. Tentu proses ini cukup adil karena tak ada proses yang
diprioritaskan, semua proses mendapat jatah waktu yang sama dari CPU yaitu (1/n), dan
tak akan menunggu lebih lama dari (n-1)q dengan q adalah lama 1 quantum.
Permasalahan utama pada Round Robin adalah menentukan besarnya time quantum. Jika
time quantum yang ditentukan terlalu kecil, maka sebagian besar proses tidak akan selesai
dalam 1 quantum dan akan banyak peralihan proses sehingga banyak waktu terbuang. Hal
ini tidak baik karena akan terjadi banyak switch, padahal CPU memerlukan waktu untuk
beralih dari suatu proses ke proses lain (disebut dengan context switches time). Sebaliknya,
jika time quantum terlalu besar, algoritma Round Robin akan berjalan seperti algoritma
first come first served (siapa yang datang pertama, dialah yang dilayani). Time quantum
yang ideal adalah jika 80% dari total proses memiliki CPU burst time yang lebih kecil dari 1
time quantum.

Ketika quantum habis untuk satu proses tertentu, maka proses tersebut akan diletakkan
diakhir daftar (list), seperti nampak dalam gambar berikut ini :

Proses
Saat Ini

+---+ +---+ +---+ +---

+ +---+ +---+ +---+ +---+ +---+ +---+
: B :--: F :--: D :--: G :--: A : : B :--: F :--: D :--: G :--: A :
+---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+

Gambar 4.1(a) : Daftar proses runnable.

4.1(b) : Daftar proses runnable sesudah proses b habis quantum-nya.
Algoritma yang digunakan :
1. Jika kwanta habis dan proses belum selesai, maka proses menjadi runnable dan
pemroses dialihkan ke proses lain.
2. Jika kwanta belum habis dan proses menunggu suatu kejadian (selesainya operasi I/O),
maka proses menjadi blocked dan pemroses dialihkan ke proses lain.
3. Jika kwanta belum habis tetapi proses telah selesai, maka proses diakhiri dan pemroses
dialihkan ke proses lain.

Diimplementasikan dengan :
1. Mengelola senarai proses ready (runnable) sesuai urutan kedatangan.
2. Ambil proses yang berada di ujung depan antrian menjadi running.
3. Bila kwanta belum habis dan proses selesai, maka ambil proses di ujung depan antrian
proses ready.
4. Jika kwanta habis dan proses belum selesai, maka tempatkan proses running ke ekor
antrian proses ready dan ambil proses di ujung depan antrian proses ready.

Masalah yang timbul adalah menentukan besar kwanta, yaitu :

Kwanta terlalu besar menyebabkan waktu tanggap besar dan turn arround time rendah.
Kwanta terlalu kecil menyebabkan peralihan proses terlalu banyak sehingga menurunkan
efisiensi proses.
Switching dari satu proses ke proses lain membutuhkan kepastian waktu yang digunakan
untuk administrasi, menyimpan, memanggil nilai-nilai register, pemetaan memori,
memperbaiki tabel proses dan senarai dan sebagainya.
Mungkin proses switch ini atau konteks switch membutuhkan waktu 5 msec disamping
waktu pemroses yang dibutuhkan untuk menjalankan proses tertentu. Dengan
permasalahan tersebut tentunya harus ditetapkan kwanta waktu yang optimal
berdasarkan kebutuhan sistem dari hasil percobaan atau data historis. Besar kwanta waktu
beragam bergantung beban sistem. Apabila nilai quantum terlalu singkat akan
menyebabkan terlalu banyak switch antar proses dan efisiensi CPU akan buruk, sebaliknya
bila nilai quantum terlalu lama akan menyebabkan respon CPU akan lambat sehingga
 proses yang singkat akan menunggu lama. Sebuah quantum sebesar 100 msec merupakan
nilai yang dapat diterima.

Penilaian penjadwalan ini berdasarkan kriteria optimasi :

Adil
Adil bila dipandang dari persamaan pelayanan oleh pemroses.
Efisiensi
Cenderung efisien pada sistem interaktif.
Waktu tanggap
Memuaskan untuk sistem interaktif, tidak memadai untuk sistem waktu nyata.
Turn around time
Cukup baik.
Throughtput
Cukup baik.

Penjadwalan ini :
a. Baik untuk sistem interactive-time sharing dimana kebanyakan waktu dipergunakan
menunggu kejadian eksternal.
Contoh : text editor, kebanyakan waktu program adalah untuk menunggu keyboard,
sehingga dapat dijalankan proses-proses lain.
b. Tidak cocok untuk sistem waktu nyata apalagi hard-real-time applications.
Jadi kesimpulan yang dapat ditambahkan dari round robin adalah:

Tiap proses memperoleh alokasi waktu CPU dlm kuantum waktu, biasanya 10-100
ms
Setelah kuantum waktu lewat, proses dipreempted dan dimasukkan ke belakang
antrian ready
Jika ada n proses pada antrian ready dan kuantum waktu=q, maka:
Pada gilirannya tiap proses memperoleh 1/n waktu CPU selama q
Tidak ada proses yg menunuggu lebih dari (n-1)q unit waktu
 Performansi:
q besar FIFO
q kecil overhead untuk context switch sangat besar
Contoh :
Proses Durasi Urutan Kedatangan
P1 3 1 0
P2 4 2 0
P3 3 3 0
Asumsi : kuantum waktu = 1 unit ; P1, P2, dan P3 tidak pernah diblokir
P1 P2 P3 P1 P2 P3 P1 P2 P3 P2
Waktu tunggu:
P1=0+2+2=4,
P2=1+2+2+1=6
P3=2+2+2=6
Waktu tunggu rata-rata: (4+6+6)/3=5.33