LAPORAN

TUGAS PROYEK PEMROGRAMAN

(Kasus – 1)

Mata Kuliah : Sistem Operasi

Dosen Pengampu : Elsen Ronando, S.Si.,M.Si.,M.Sc.

Disusun oleh :
Alif Rizal Pamungkas (1461600195)
Alvan Danang Cahyono (1461600203)
Imam Baehaqi (1461600228)
Galih Kantata Takwa (1461600242)
Robertus Nyarso Listiyono (1461600263)

Teknik Informatika
Fakultas Teknik
Universitas 17 Agustus 1945 Surabaya
2017
 FIFO (First-in First-Out) / FCFS

I.1 Deskripsi

First-Come First-Served Scheduling (FCFS) adalah Proses yang pertama kali

meminta jatah waktu untuk menggunakan CPU akan dilayani terlebih dahulu.
Pada skema ini, proses yang meminta CPU pertama kali akan di alokasikan ke
CPU pertama kali. Misalnya terdapat tiga proses yang dapat dengan urutan P1,
P2, dan P3 dengan waktu CPU-burst dalam mili detik yang diberikan. Sebagai
berikut :

Proses Burst Time

P1 24

P2 3

P3 3

Gant Chart dengan penjadwalan FCFS sebagai berikut :

P1 P2 P3

0 24 27 30

Waktu tunggu untuk P1 adalah 0, P2 adalah 24 dan P3 adalah 27 sehingga

rata-rata

Waktu tunggu adalah (0 + 24 + 27)/3 = 17 mili detik. Sedangkan apabila proses

dating dengan urutan P2, P3, dan P1, hasil penjadwalan CPU dapat dilihat pada
gant chart berikut :

P2 P3 P1

0 3 6 30

Waktu tunggu sekarang untuk P1 adalah 6, P2 adalah 0 dan P3 adalah 3

sehingga rata-rata waktu tunggu adalah (6 + 0 + 3)/3 = 3 mili detik. Rata-rata
waktu tunggu kasus ini jauh lebih baik dibandingkan dengan kasus sebelumnya.
Pada penjadwalan CPU dimungkinkan terjadi Convoy effect apabila proses yang
pendek berada pada proses yang panjang.

Algoritma FCFS termasuk non-preemptive. karena, sekali CPU di alokasikan

pada suatu proses, maka proses tersebut tetap akan memakai CPU sampai
proses tersebut melepaskannya, yaitu jika proses tersebut berhenti atau
meminta I/O.
I.2 Deskripsi Permasalahan

First-Come First-Served Scheduling (FCFS)

Penjadwalan ini sangat tidak memuaskan, karena proses dapat menunggu lama
Dalam kriteria adil, penjadwalan FIFO adil dalam arti resmi (dalam semantic/arti
antrian) yaitu proses yang pertama datang, akan dilayani pertama juga), tapi
dinyatakan tidak adil karena proses-proses yang perlu waktu lama membuat
proses-proses pendek menunggu. Proses-proses tidak penting dapat membuat
proses-proses penting menunggu.

*Penjadwalan sangat tidak memuaskan karena proses menunggu lama, aktu

tanggapnya sangat jelek.

*Tidak cocok untuk sistem interaktif.

*Turn around time tidak bagus.

*Throughtput tidak bagus.*Tidak dapat digunakan untuk sistem waktu nyata.

I.3 Perhitungan Manual

Kasus 1

Nama Proses Waktu Tiba Lama Eksekusi

P1 0 5
P2 1 6
P3 2 7
P4 3 8
P5 4 9

Nama Waktu Lama Mulai Selesai Waktu TA

Proses Tiba Eksekusi Eksekusi Eksekusi Tunggu

P1 0 5 0 5 0 5
P2 1 6 5 11 4 10
P3 2 7 11 18 9 16
P4 3 8 18 26 15 23
P5 4 9 26 35 22 31
 ∑TA = 85

Rata-rata TA = 17

Gantt Chart

P1 P2 P3 P4 P5
0 5 11 18 26 35

 Rumus

o Mulai Eksekusi = Lama Eksekusi - Waktu Tiba

o Selesai Eksekusi = Lama Eksekusi + Mulai Eksekusi
o Waktu Tunggu = Mulai Eksekusi - Waktu Tiba
o Turn Arround Time = Waktu Tunggu + Lama Eksekusi
o Rata - Rata Turn Arround Time = Jumlah Turn Arround Time / Banyaknya Proses

I.4 Script dan Hasil Running

</> Code
#include<iostream>

using namespace std;

int main()
{
cout<<"=-=-=-=-=-=-=-=-=-=Metode FIFO (First In First Out)=-=-=-=-
=-=-=-=-=-="<<endl<<endl;
int n,wb[20],wt[20],le[20],me[20],se[20],tat[20],avtat=0,i,j;
cout<<"Masukkan Banyaknya Proses : ";
cin>>n;

for(i=0;i<n;i++)
{
cout<<"\nMasukkan Proses Waktu Tiba P["<<i+1<<"] : ";
cin>>wb[i];
}

for(i=0;i<n;i++)
{
cout<<"\nMasukkan Waktu Lama Eksekusi/Burst Time P["<<i+1<<"] : ";
cin>>le[i];
}

cout<<"\nProses\tWaktu Tiba\tLama Eksekusi\tMulai Eksekusi\tSelesai

Eksekusi\tWaktu Tunggu\tTurnArroundTime";

me[0]=0; //MulaiEksekusi pertama dimulai dari 0

//Perhitungan Mulai Eksekusi

for(i=1;i<n;i++)
{
me[i]=0;
for(j=0;j<i;j++)
me[i]+=le[j];
}

//Perhitungan Selesai Eksekusi

for(i=0;i<n;i++)
{
se[i]=le[i]+me[i];
}

//Perhitungan Waktu Tunggu

for(i=0;i<n;i++)
{
wt[i]=me[i]-wb[i];
}

//Perhitungan Turn Arround Time

for(i=0;i<n;i++)
{
tat[i]=wt[i]+le[i];
avtat+=tat[i];

cout<<"\nP["<<i+1<<"]"<<"\t\t"<<wb[i]<<"\t\t"<<le[i]<<"\t\t"<<me[i]<<"\t\t"<<se
[i]<<"\t\t"<<wt[i]<<"\t\t"<<tat[i];
}

cout<<endl<<endl<<"\tMenampilkan Gant Chart \n";

cout<<"0->P1->"<<se[0];
for(i=1; i<n; i++)
{
cout<<"->P"<<i+1<<"->"<<se[i];
}
cout<<endl;

cout<<endl<<"\nJumlah Turn Arround Time:"<<avtat;

cout<<"\nBanyaknya Proses:"<<n;
avtat/=i;
cout<<"\nRata - Rata Turn Arround Time:"<<avtat<<endl;

cout<<endl<<"NB\t :";
cout<<"\n1. Mulai Eksekusi \t\t = Lama Eksekusi - Waktu Tiba\t "<<endl;
cout<<"2. Selesai Eksekusi \t\t = Lama Eksekusi + Mulai Eksekusi \t
"<<endl;
cout<<"3. Waktu Tunggu \t\t = Mulai Eksekusi - Waktu Tiba \t "<<endl;
cout<<"4. Turn Arround Time \t\t = Waktu Tunggu + Lama Eksekusi \t
"<<endl;
cout<<"5. Rata - Rata Turn Arround Time = Jumlah Turn Arround Time /
Banyaknya Proses \t "<<endl;

system("pause");
}

 Hasil Running
 ROUND ROBIN
II.1 Deskripsi

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 . Proses ini cukup adil, karena
tidak ada proses yang diprioritaskan . Semua proses mendapat jatah waktu
yang sama dari CPU yaitu 1/n, dan tidak akan menunggu lebih lama dari (n-
1)q; dimana q adalah lama 1 quantum .

II.2 Deskripsi Permasalahan

 Permasalahan utamanya adalah menentukan besarnya TQ. Jika TQ yang

ditentukan terlalu kecil, maka sebagian besar proses tidak akan selesai
dalam 1 quantum.
 Akibatnya akan terjadi banyak switch, padahal CPU memerlukan waktu
untuk beralih dari satu proses ke proses yang lain (= context switches time).
 Sebaliknya, jika TQ yang ditentukan terlalu besar, algoritma RR akan
berjalan seperti FCFS.
 TQ ideal adalah jika 80% dari total proses memiliki CPU burst time yang
lebih kecil dari 1 TQ.

II.3 Perhitungan Manual

Kasus 1 Time Quantum = 2
Proses AT BT
P1 0 5
P2 1 6
P3 2 7
P4 3 8
P5 4 9

Proses AT BT FT TAT WT
P1 0 5 17 17 12
P2 1 6 23 22 16
P3 2 7 30 28 21
P4 3 8 32 29 21
P5 4 9 35 31 22
 Rata-rata
TAT : 25,4

Gantt Chart

P1 P2 P3 P1 P4 P5 P2 P3 P1
0 2 4 6 8 10 12 14 16 17

P4 P5 P2 P3 P4 P5 P3 P4 P5 P5
17 19 21 23 25 27 29 30 32 34 35

 Rumus :
o Finish Time(FT) = TAT + AT
o Waiting Time (WT) = TAT - BT
o Turn Arround Time(TAT) = FT - AT
o Rata - Rata Turn Arround Time = Jumlah Turn Arround Time / Banyaknya Proses
o Rata - Rata Waiting Time = Jumlah Waiting Time / Banyaknya Proses

II.4 Script dan Hasil Running

</> Code
#include<iostream>
#include<cstdlib>
#include<queue>
#include<cstdio>

using namespace std;

typedef struct process
{
int ProcessID,ArrivalTime,BurstTime,StratTime,FinishTime,Priority;
float WaitTime,TurnArroundTime;
}process;

process Process[10],p1[10],temp;
queue<int> queue1;int accept(int ch);

void turnwait(int n);

void display(int n);
void ganttrr(int n);

int main()
{
 int i,n,ts,ch,j,x;
Process[0].TurnArroundTime=0;
Process[0].WaitTime=0;
n=accept(ch);
ganttrr(n);
turnwait(n);
display(n);
system("pause");
return 0;
}

int accept(int ch) //functions for accepting inputs from the user
{
int i,n;
printf("\nEnter the no. of process: ");
scanf("%d",&n);
if(n==0)
{
printf("\nInvalid no. of process");
exit(1);
}
for(i=1;i<=n;i++)
{
printf("\nMasukkan Proses Waktu Tiba P%d : ",i);
scanf("%d",&Process[i].ArrivalTime);
Process[i].ProcessID=i;
}
for(i=1;i<=n;i++)
{
printf("\nMasukkan Waktu Lama Eksekusi/Burst Time P%d : ",i);
scanf("%d",&Process[i].BurstTime);
}
if(ch==3)
{
for(i=1;i<=n;i++)
{
printf("\nEnter the priority for P%d: ",i);
scanf("%d",&Process[i].Priority);
}
return n;
}

printf("\nInputs given by the user are:\n");

printf("=====================================================
=========");
printf("\nProcess\tAT\tBT");
for(i=1;i<=n;i++)
printf("\nP%d\t%d\t%d",Process[i].ProcessID,Process[i].ArrivalTime,Process[i
].BurstTime);

printf("\n====================================================
========");
for(i=1;i<=n;i++) // copying of one array into another array(dummy area)
p1[i]=Process[i];
return n;
}
/* FUNCTION FOR DISPLAYING GANTT CHART FOR ROUND ROBIN
SCHEDULING */
void ganttrr(int n)
{
int i,ts,m,nextval,nextarr;
nextval=Process[1].ArrivalTime;
cout<<"\nMasukkan Quantum Time : ";
cin>>ts;

nextval=p1[1].ArrivalTime;
printf("\n\nMenampilkan Gantt Chart\n\n");
cout<<p1[1].ArrivalTime;

for(i=1;i<=n,p1[i].ArrivalTime<=nextval;i++)
queue1.push(p1[i].ProcessID);
nextarr=p1[i].ArrivalTime;
while(!queue1.empty())
{
m=queue1.front();
queue1.pop();
if(p1[m].BurstTime>=ts)
nextval=nextval+ts;
else
nextval=nextval+p1[m].BurstTime;
cout<<"->P"<<p1[m].ProcessID<<"->"<<nextval;
p1[m].BurstTime=p1[m].BurstTime-ts;
if(nextval<nextarr)
{
if(p1[m].BurstTime>0)
queue1.push(m);
if(p1[m].BurstTime<=0)
Process[m].FinishTime=nextval;
}
else
{
while(i<=n&&p1[i].ArrivalTime<=nextval)
{
queue1.push(p1[i].ProcessID);
i++;
}
 if(i<=n)
nextarr=p1[i].ArrivalTime;
if(p1[m].BurstTime>0)
queue1.push(m);
if(p1[m].BurstTime<=0)
Process[m].FinishTime=nextval;
}
}
}
/* FUNCTION FOR CALCULATING TURN AROUND TIME OR WAIT TIME */
void turnwait(int n)
{
int i;
for(i=1;i<=n;i++)
{
Process[i].TurnArroundTime=Process[i].FinishTime-
Process[i].ArrivalTime;
Process[i].WaitTime=Process[i].TurnArroundTime-Process[i].BurstTime;

Process[0].TurnArroundTime=Process[0].TurnArroundTime+Process[i].TurnA
rroundTime;
Process[0].WaitTime=Process[0].WaitTime+Process[i].WaitTime;
}
Process[0].TurnArroundTime=Process[0].TurnArroundTime/n;
Process[0].WaitTime=Process[0].WaitTime/n;
}
/* FUNCTION FOR DISPLAYING THE TABLE */
void display(int n)
{
int i;
cout<<"\n\n-------------------TABLE----------------------------------\n";
printf("\nProcess\tAT\tBT\tFT\tTAT\t\tWT");
for(i=1;i<=n;i++)

printf("\nP%d\t%d\t%d\t%d\t%f\t%f",Process[i].ProcessID,Process[i].ArrivalTi
me,Process[i].BurstTime,Process[i].FinishTime,Process[i].TurnArroundTime,
Process[i].WaitTime);
cout<<"\n\n-----------------------------------------------------------";

printf("\nRata-Rata Turn Around Time: %f",Process[0].TurnArroundTime);

printf("\nRata-Rata Waiting Time: %f\n",Process[0].WaitTime);

cout<<endl<<endl<<"NB\t :"<<endl;
cout<<"1. Finish Time(FT) \t\t = TAT + AT"<<endl;
cout<<"2. Waiting Time (WT) \t\t = TAT - BT"<<endl;
cout<<"3. Turn Arround Time(TAT) \t = FT - AT"<<endl;
cout<<"4. Rata - Rata Turn Arround Time = Jumlah Turn Arround Time /
Banyaknya Proses"<<endl;
cout<<"5. Rata - Rata Waiting Time \t = Jumlah Waiting Time / Banyaknya
Proses"<<endl;
}

 Hasil Running
 Kesimpulan
Penjadwalan proses yaitu kumpulan kebijaksanaan dan mekanisme di sistem
operasi yang berkaitan dengan urutan kerja yang dilakukan oleh sistem komputer.
Penjadwalan bertugas menentukan proses mana yang harus berjalan serta kapan
dan berapa lama proses itu berjalan. Kriteria untuk mengukur dan optimasi kerja
penjadwalan yaitu : Adil, Efesiensi, Waktu Tanggap, Turn Arround Time, dan
Throughtput. Terdapat 3 tipe penjadwalan dalam sistem operasi yaitu : Penjadwalan
Jangka Pendek, Jangka Menengah, dan Jangka Panjang. Macam-macam strategi
penjadwalan dibagi menjadi 2 yaitu Penjadwalan Nonpreemptive dan Penjadwalan
Preemprive. Algoritma penjadwalan pun dibagi menjadi 2, Fifo termasuk Algoritma
Penjadwalan Nonpreemptive dan Round Robin termasuk Algoritma Penjadwalan
Preemptive.
 DAFTAR PUSTAKA

https://ridhasariyanti636.wordpress.com/2014/04/10/makalah-so/

http://sim.untag- sby.ac.id/siakad/siakad/index.php?page=download&type=materi&id=11405

http://opensource.telkomspeedy.com/repo/abba/v06/Kuliah/SistemOperasi/BUKU/SistemOp
erasi-4.X-2/ch06s03.html

http://sekilastentangjava.blogspot.co.id/2012/04/sistem-operasi-penjadwalan.html

https://skatel.wordpress.com/2012/05/07/source-code-penjadwalanscheduling-cpu-fcfs-
program-di-c/

http://dwicahyo3396.blogspot.co.id/2014/12/algoritma-penjadwalan-cpu-round-robin.html

https://code.google.com/archive/p/project-penjadwalan-round-robin/source/default/source