Penjadwalan CPU dengan Metode FCFS (First Come First Serve)

Seperti yang diketahui pembahasan ini dipertunjukan mengenai penjadwalan CPU, FCFS (First Come First Serve) atau juga bisa disebut FIFO (First In First Out). "Stay Slow Class" juga berterima kasih atas materi yang disampaikan oleh dosen sekaligus yang memberikan tugas matakuliah Sistem Operasi yang menyangkut tentang materi penjadwalan CPU, rasa terima kasih atas orang tua yang selalu mendukung kami, teman - teman seperjuangan kami.

Pada materi tentang penjadwalan CPU, dosen memberikan tugas kepada kami untuk membuat ilustrasi atau sebuah program berupa bahasa C++ tentang berjalannya alur jadwal CPU, dan metode yang digunakan adalah metode Firt Come First Serve atau FCFS.

Penjadwalan CPU

Penjadwalan CPU (CPU Scheduling) adalah basis dari sistem operasi multiprograming. Dengan men-switch CPU kepada proses-proses, sistem operasi dapat membuat computer lebih produktif. Tujuan dari multiprograming adalah agar beberapa proses dapat berjalan sedemikian rupa sehingga penggunaan CPU menjadi maksimal (CPU utilization maksimal). Ketika CPU mengganggur, sistem operasi harus memilih satu dari proses dalam ready queue untuk dieksekusi. Pemilihan tersebut dilakukan oleh penjadwal CPU (CPU Scheduler). Penjadwal tersebut akan memilih di antara proses di memori yang siap untuk dieksekusi dan kemudian akan memberikan jatah CPU kepada salah satu proses tersebut.
Keputusan dalam penjadwalan CPU berlangsung saat state proses :

1. Berubah dari running state ke waiting state
2. Berubah dari running state ke ready state
3. Berubah dari waiting state ke ready state
4. Terminates

Untuk nomor 1 dan 4, skema penjadwalannya dikatakan non-preemptive. Sedangkan untuk nomor 2 dan 3, skema penjadwalannya dikatakan preemptive. Preemptive maksudnya dapat diganti oleh proses lain. Non-preemptive maksudnya tidak dapat diganti oleh proses lain (proses yang sedang berjalan harus dijalankan sampai selesai dulu).

Kriteria Penjadwalan

Kriteria yang digunakan untuk membandingkan algoritma-algoritma penjadwalan adalah sebagai berikut:

• CPU utilization Sebaiknya CPU bekerja sesibuk mungkin.
• Throughput, banyaknya proses yang selesai dieksekusi per satuan waktu. Semakin banyak throughput, semakin baik.
• Turnaround time, waktu yang dibutuhkan untuk mengeksekusi suatu proses. Semakin kecil turnaround time, semakin baik.
• Waiting time, waktu yang dibutuhkan suatu proses selama menunggu di ready queue.Semakin kecil waiting time, semakin baik.
• Response time, waktu yang dibutuhkan sejak suatu proses datang me-request sampai proses itu menerima response pertama. Semakin kecil response time, semakin baik.

Kriteria yang optimal adalah :

1. CPU utilization maksimal
2. Throughput maksimal
3. Turnaround time minimal
4. Waiting time minimal
5. Response time minimal 

FCFS

Pertama datang, pertama dilayani (First Come, First Serve atau FCFS) tidak peduli apakah burst time nya panjang atau pendek, sebuah proses yang sedang dikerjakan diselesaikan terlebih dulu barulah proses berikutnya dilayani.
Penjadwalan FCFS merupakan penjadwalan:

1. Penjadwalan non-prevebtive (run-to-completion)
2. Penjadwalan tidak berprioritas
3. Ketentuan dari penjadwalan FCFS adalah:
4. Proses-proses diberi jatah waktu pemroses, diurut dengan waktu kedatangannya.
5. Begitu proses mendapat jatah waktu pemproses, proses dijalankan sampai proses tersebut selesai, walaupun ada proses lain yang datang, proses tersebut berada dalam antrian sistem atau disebut dengan ready queue.

Pada dasarnya algoritma penjadwalan ini cukup adil dalam hal bahasa, karena proses yang datang lebih dulu dikerjakan terlebih dahulu. Dari segi konsep sistem operasi, penjadwalan model ini tidak adil karena proses-proses yang membutuhkan waktu yang lama membuat proses-proses yang memiliki waktu proses yang lebih pendek menunggu sampai proses yang lama tersebut selesai, sedangkan proses-proses yang tidak penting membuat proses penting menunggu.
Penjadwalan FCFS cocok digunakan untuk sistem batch yang sangat jarang melakukan interaksi dengan user secara langsung, tapi tidak cocok digunakan untuk sistem interaktif karena tidak memberi waktu tanggap yang bagus, begitu juga dengan waktu sistem nyata.

Ø  Kelebihan : 

1. Algoritma yang paling sederhana, dengan skema proses yang meminta CPU mendapat prioritas.
2. Adil, dalam arti resmi (proses yang datang duluan akan dilayani lebih dulu), tapi dinyatakan tidak adil karena job-job yang perlu waktu lama membuat job-job pendek menunggu. Job-job yang tidak penting dapat membuat job-job penting menunggu lama.
3. Efisiensi, sangat efisien.
4. Baik untuk sistem batch yang sangat jarang berinteraksi dengan pemakai.

Ø  Kelemahan:

1. Waiting time rata-ratanya cukup lama.
2. Terjadi convoy effect dimana seandainya ada sebuah proses yang kecil tetapi mengantri dengan proses yang membutuhkan waktu yang lama mengakibatkan proses tersebut akan lama juga untuk dieksekusi.
3. Turn around time kurang baik.
4. Throughtput kurang baik. FIFO jarang digunakan secara mandiri, tetapi dikombinasikan dengan skema lain.
5. Sangat tidak baik (tidak berguna) untuk sistem interaktif, karena tidak memberi waktu tanggap yang baik.
6. Tidak dapat digunakan untuk sistem waktu nyata (real-time applications).

Contoh Program Penjadwalan CPU Metode FCFS

Berikut source code program dengan bahasa C++:

#include<stdio.h>
#include<string.h>
void main()

{

int n, ar[100], b[100], i, j, tmp, wt[100], ta[100], time[100];

int totWT=0, totTA=0;

float AvWT, AvTA;

char name[25][25], tmpName[25];

printf("\t======== Penjadwalan CPU Metode First Come First Serve ========\n");

puts("");

printf("+-- Nama Anggota : -----------------------------+\n"); 
printf("| 1. Restu Wijayanto (1310511032) |\n");
printf("| 2. Adi Daya Karisma (1310511041) |\n");
printf("| 3. Galih Prasetyo (1310511043) |\n");
printf("| 4. Taufiq Maulana E. (1310511044) |\n");
printf("+-----------------------------------------------+\n\n");

printf("Masukan Jumlah Proses (Angka)\t    = "); scanf("%d", &n);

puts("");



for(i=0; i<n; i++){

fflush(stdin);

printf("Nama Proses\t    = "); gets(name[i]);

printf("Arrival Time\t    = "); scanf("%d", &ar[i]);

printf("Burst Time\t    = "); scanf("%d", &b[i]);

puts("");

}



for(i=0; i<n; i++){

for(j=i+1; j<n; j++)

if(ar[i]>ar[j]){



strcpy(tmpName, name[i]);

strcpy(name[i], name[j]);

strcpy(name[j], tmpName);


tmp=ar[i];

ar[i]=ar[j];

ar[j]=tmp;



tmp=b[i];

b[i]=b[j];

b[j]=tmp;

}

}

time[0]=ar[0];

puts("\n\t- Tabel Proses -");

puts("==========================================");

printf("| No | Proses\t | Time Arrival\t | Burst |\n");

puts("""""""""""""""");


for (i=0; i<n; i++){

printf("| %2d | %s\t |  \t%d\t | %d\t |\n", i+1, name[i], ar[i], b[i]);

time[i+1]=time[i]+b[i]; 

wt[i]=time[i]-ar[i];

ta[i]=time[i+1]-ar[i];

totWT+=wt[i];

totTA+=ta[i];

}

puts("==========================================");

printf("\tWaiting Time\t= %d \n", totWT);

printf("\tTurn Arround Time\t= %d \n", totTA);

puts("\n\t- Tabel Waktu Proses -");

puts("==================================================");

printf("| No | Proses\t | Waiting Time\t | Turn Arround\t |\n");

puts("""""""""""""""""""");

for(i=0; i<n; i++){

printf("| %2d | %s\t |  \t%d\t | \t%d\t |\n", i+1, name[i], wt[i], ta[i]);

}

puts("==================================================");



puts("\n");

puts("\t- Diagram Gant -\n");

for(i=0; i<n; i++){

printf(" %s\t ", name[i]);

}

puts("");

for(i=0; i<n; i++){

printf("|=========");

}

printf("|\n");

for(i=0; i<=n; i++){

printf(" %d\t ", time[i]);

}


printf("(Dari Penjumlahan Burst)");

puts("\n");

AvWT=(float)totWT/n; 

AvTA=(float)totTA/n; 

printf("\tWaiting Time : %f\n", AvWT);

printf("\tTurn Arround Time : %f\n", AvTA);

}

Dan hasil yang didapatkan dari source code program diatas adalah screenshot berikut ini :

Dan demikianlah penjelasan mengenai penjadwalan CPU, FCFS dan sebagainya. Semoga ilmu ini dapat bermanfaat sebagai bahan pembelajaran untuk pembaca sekalian, kami selaku "Stay Slow Class" terima kasih dan sampai jumpa di posting kami selanjutnya.