C/C++ Program for Priority Scheduling

Algorithm
By Admin | November 16, 2014
6 Comments

Here you will get C and C++ program for priority scheduling algorithm.

What is Priority Scheduling Algorithm?

In priority scheduling algorithm each process has a priority associated

with it and as each process hits the queue, it is stored in based on its
priority so that process with higher priority are dealt with first. It should
be noted that equal priority processes are scheduled in FCFS order.

Also Read: C Program for Shortest Job First (SJF) Scheduling

Algorithm

Also Read: C/C++ Program for First Come First Served (FCFS)
Scheduling Algorithm

To prevent high priority processes from running indefinitely the scheduler

may decrease the priority of the currently running process at each clock
tick (i.e., at each clock interrupt). If this action causes its priority to drop
below that of the next highest process, a process switch
occurs. Alternatively, each process may be assigned a maximum time
quantum that it is allowed to run. When this quantum is used up, the next
highest priority process is given a chance to run.

Limitations

The problem occurs when the operating system gives a particular task a
very low priority, so it sits in the queue for a larger amount of time, not
being dealt with by the CPU. If this process is something the user needs,
there could be a very long wait, this process is known as Starvation or
Infinite Blocking.

Solution

Many operating systems use a technique called aging, in which a low

priority process slowly gains priority over time as it sits in the queue.
Even if, the priority of the process is low, there is a surety of
its execution.

C Program
#include<stdio.h>

int main()
{

1 #include<stdio.h>
2
3 int main()
4 {
5 int bt[20],p[20],wt[20],tat[20],pr[20],i,j,n,total=0,pos,temp,avg_wt,avg_tat;
6 printf("Enter Total Number of Process:");
7 scanf("%d",&n);
8
9 printf("\nEnter Burst Time and Priority\n");
10 for(i=0;i<n;i++)
11 {
12 printf("\nP[%d]\n",i+1);
13 printf("Burst Time:");
14 scanf("%d",&bt[i]);
15 printf("Priority:");
16 scanf("%d",&pr[i]);
17 p[i]=i+1; //contains process number
18 }
19
20 //sorting burst time, priority and process number in ascending order using selection sort
21 for(i=0;i<n;i++)
22 {
23 pos=i;
24 for(j=i+1;j<n;j++)
25 {
26 if(pr[j]<pr[pos])
27 pos=j;
28 }
29
30 temp=pr[i];
31 pr[i]=pr[pos];
32 pr[pos]=temp;
33
34 temp=bt[i];
35 bt[i]=bt[pos];
36 bt[pos]=temp;
37
38 temp=p[i];
39 p[i]=p[pos];
40 p[pos]=temp;
41 }
42
43 wt[0]=0; //waiting time for first process is zero
44
45 //calculate waiting time
46 for(i=1;i<n;i++)
47 {
48 wt[i]=0;
49 for(j=0;j<i;j++)
50 wt[i]+=bt[j];
51
52 total+=wt[i];
53 }
54
55 avg_wt=total/n; //average waiting time
56 total=0;
57
58 printf("\nProcess\t Burst Time \tWaiting Time\tTurnaround Time");
59 for(i=0;i<n;i++)
60 {
61 tat[i]=bt[i]+wt[i]; //calculate turnaround time
62 total+=tat[i];
63 printf("\nP[%d]\t\t %d\t\t %d\t\t\t%d",p[i],bt[i],wt[i],tat[i]);
64 }
65
66 avg_tat=total/n; //average turnaround time
67 printf("\n\nAverage Waiting Time=%d",avg_wt);
68 printf("\nAverage Turnaround Time=%d\n",avg_tat);
69
70 return 0;
71 }

C++ Program
#include<iostream>

using namespace std;

1 #include<iostream>
2
3 using namespace std;
4
5 int main()
6 {
7 int bt[20],p[20],wt[20],tat[20],pr[20],i,j,n,total=0,pos,temp,avg_wt,avg_tat;
8 cout<<"Enter Total Number of Process:";
9 cin>>n;
10
11 cout<<"\nEnter Burst Time and Priority\n";
12 for(i=0;i<n;i++)
13 {
14 cout<<"\nP["<<i+1<<"]\n";
15 cout<<"Burst Time:";
16 cin>>bt[i];
17 cout<<"Priority:";
18 cin>>pr[i];
19 p[i]=i+1; //contains process number
20 }
21
22 //sorting burst time, priority and process number in ascending order using selection sort
23 for(i=0;i<n;i++)
24 {
25 pos=i;
26 for(j=i+1;j<n;j++)
27 {
28 if(pr[j]<pr[pos])
29 pos=j;
30 }
31
32 temp=pr[i];
33 pr[i]=pr[pos];
34 pr[pos]=temp;
35
36 temp=bt[i];
37 bt[i]=bt[pos];
38 bt[pos]=temp;
39
40 temp=p[i];
41 p[i]=p[pos];
42 p[pos]=temp;
43 }
44
45 wt[0]=0; //waiting time for first process is zero
46
47 //calculate waiting time
48 for(i=1;i<n;i++)
49 {
50 wt[i]=0;
51 for(j=0;j<i;j++)
52 wt[i]+=bt[j];
53
54 total+=wt[i];
55 }
56
57 avg_wt=total/n; //average waiting time
58 total=0;
59
60 cout<<"\nProcess\t Burst Time \tWaiting Time\tTurnaround Time";
61 for(i=0;i<n;i++)
62 {
63 tat[i]=bt[i]+wt[i]; //calculate turnaround time
64 total+=tat[i];
65 cout<<"\nP["<<p[i]<<"]\t\t "<<bt[i]<<"\t\t "<<wt[i]<<"\t\t\t"<<tat[i];
66 }
67
68 avg_tat=total/n; //average turnaround time
69 cout<<"\n\nAverage Waiting Time="<<avg_wt;
70 cout<<"\nAverage Turnaround Time="<<avg_tat;
71
72 return 0;
73 }

Output
source code penjadwalan/scheduling cpu
fcfs program di C++
Posted in bahasa-c, Operating System by Kang Anas

penjadwalan proses CPU dengan FCFS ini menggunakan bahasa C++ disini dilengkapi
dengan source code yang telah saya kerja kan sendri dengan teman, awal nya pengen
pakai java tapi berhubung masih belum nguasai java ya sudah pakai yang sederhana,
menggunakan consule.., Ikuti artikel tentang penjadwalan proses CPU dengan FCFS

1. Penjadwalan CPU dengan FCFS

1.1 Dasar Teori

Penjadwalan CPU adalah permasalahan

menentukan proses mana pada ready queue yang
dialokasikan ke CPU. Pada saat CPU
menganggur, maka sistem operasi harus
menyeleksi prosesproses yang ada di memori
utama (ready queue) untuk dieksekusi dan
mengalokasikan CPU untuk salah satu dari proses
tersebut. Seleksi semacam ini disebut dengan
shortterm scheduler (CPU scheduler). Keputusan
untuk menjadwalkan CPU mengikuti empat
keadaan dibawah ini :

1. Apabila proses berpindah dari keadaan running

ke waiting;

2. Apabila proses berpindah dari keadaan running

ke ready;

3. Apabila proses berpindah dari keadaan waiting

ke ready;

4. Apabila proses berhenti.

Setiap algoritma diukur turnaround time dan

waiting time untuk membandingkan
performansi dengan algoritma lain. Dan untuk
mengukur turnaround time dan waiting time,
digunakan Gant Chart. CPU time (Burst Time)
membutuhkan semua proses diasumsikan
diketahui. Arrival time untuk setiap proses pada
ready queue diasumsikan diketahui.

1.2 Algoritma

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
dialokasikan ke CPU pertama kali. Misalnya terdapat
tiga proses yang dapat dengan urutan P1, P2, dan P3
dengan waktu CPU-burst dalam milidetik 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 milidetik.

Sedangkan apabila proses datang 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 milidetik. 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 dialokasikan pada suatu proses, maka proses
tersebut tetap akan memakai CPU sampai proses
tersebut melepaskannya, yaitu jika proses tersebut
berhenti atau meminta I/O.

1.3 Listing/source code Program C++ yang sudah benar

#include<stdio.h>#include<string.h>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[20][20], tmpName[20];

printf(\t.:: Program Penjadwalan CPU FCFS ::.\n);

puts();

printf(Banyak Proses\t= ); scanf(%d, &n);

puts();

// Masukkan data yang diproses

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();

// SORTING Data

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

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

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

//tukar nama

strcpy(tmpName, name[i]);

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

strcpy(name[j], tmpName);

//tukar arrival time

tmp=ar[i];

ar[i]=ar[j];

ar[j]=tmp;

//tukar burst

tmp=b[i];

b[i]=b[j];

b[j]=tmp;

time[0]=ar[0];

puts(\n\t.:: Process Table ::.);

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]; //menghitung time pada ganchart

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

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

totWT+=wt[i];

totTA+=ta[i];

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

printf(\tTotal waiting time\t= %d \n, totWT);

printf(\tTurn arround time\t= %d \n, totTA);

puts(\n\t.:: Time Process Table ::.);

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(======================================
============);

//untuk Gant Chart

puts(\n);

puts(\t.:: Gant-Chart ::.\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(//diperoleh dari penjumlahan Burst);

puts(\n);

AvWT=(float)totWT/n; //average waiting time

AvTA=(float)totTA/n; //average turn arround time

printf(\tAverage Waiting Time : %f\n, AvWT);

printf(\tAverage Turn Arround TIme : %f\n, AvTA);

1.4 Hasil Output

Penjadwalan CPU FCFS dengan
bahasa pemrograman C++

1.2 Analisa

Pertama masukkan banyak proses kemudia

inputan ini di looping sebanyak inputan tadi,
didalam proses looping terdapat inputan yaitu
nama proses, arrival dan burst yang
menggunakan array.

Untuk mengetahui nilai dari waiting time

maka nilai dari arrival time dikurangi
dengan nilai burst yang sudah dijumlah
kan, seperti pada Gant Chart nya.

Untuk mencari nilai rata-rata waktu

tunggu maka nilai waiting time
dijumlahkan semua kemudian di bagi
dengan jumlah waiting time tersebut.

Untuk mencari rata-rata time around maka

nilai dari burst dijumlahkan kemudian di
bagi dengan jumlah burst tadi.

1.3 Kesimpulan
Program ini merupakan program penjadwalan
cpu dengan FCFS maksud nya proses yang
pertama kali memintah jatah waktu maka akan di
kerjakan terlebih dahulu baru proses berikutnya,
dengan menggunakan penjadwalan cpu fcfs ini
terdapat kekurangan nya yaitu :

Waktu tunggu rata-rata cukup lama

Terjadinya convoy effect, yaitu proses-

proses menunggu lama untuk menunggu 1
proses besar yang sedang dieksekusi oleh
CPU

Di penjadwalan cpu fcfs ini menerapkan

konsep non-preemptive, yaitu setiap proses
yang sedang dieksekusi oleh CPU tidak
dapat di-interrupt oleh proses yang lain.
Source code penjadwalan CPU dengan sjf (shortest job
first)
Posted by HERU Posted on 8 - Jun 2 comments
Source code penjadwalan CPU dengan sjf (shortest job first)

1. Penjadwalan CPU
Penjadwalan CPU adalah pemilihan proses dari antrian 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. Penjadwalan CPU mungkin
dijalankan ketika proses:

1. running ke waiting time

2. running ke ready state
3. waiting ke ready state
4. terminates

Proses 1 dan 4 adalah proses Non Preemptive, dimana proses tersebut tidak bisa di- interrupt,
sedangkan 2 dan 3 adalah proses Preemptive, dimana proses boleh di interrupt.

Pada saat CPU menganggur, maka sistem operasi harus menyeleksi proses-proses yang ada di
memori utama (ready queue) untuk dieksekusi dan mengalokasikan CPU untuk salah satu
dari proses tersebut. Seleksi semacam ini disebut dengan shortterm scheduler (CPU
scheduler).

Komponen yang lain dalam penjadwalan CPU adalah dispatcher, Dispatcher adalah suatu
modul yang akan memberikan kontrol pada CPU terhadap penyeleksian proses yang
dilakukan selama short-term scheduling . Waktu yang diperlukan oleh dispatcher untuk
menghentikan suatu proses dan memulai proses yang lain disebut dengan dispatch latency.
Jika dalam suatu proses Burst CPU jauh lebih besar daripada Burst I/O maka disebut CPU
Bound. Demikian juga sebaliknya disebut dengn I/O Bound.

2. Penjadwalan CPU dengan sjf (shortest job first)

Dalam Sistem Operasi dikenal istilah multiprograming, yang bertujuan untuk

memaksimalkan penggunaan CPU dengan cara mengatur alokasi waktu yang digunakan oleh
CPU,sehingga proses berjalan sepanjang waktu dan memperkecil waktu idle. Oleh karena itu
perlu adanyapenjadwalan proses-proses yang ada pada sistem. Untuk sistem yang hanya
mempunyai prosesortunggal (uniprosesor), hanya ada satu proses yang dapat berjalan setiap
waktunya. Jika ada proseslebih dari satu maka proses yang lain harus menunggu sampai CPU
bebas dan siap untuk dijadwalkankembali

Penjadwalan berkaitan dengan permasalahan memutuskan proses mana yang

akandilaksanakan dalam suatu sistem. Proses yang belum mendapat jatah alokasi dari CPU
akan mengantridi ready queue. Algoritma penjadwalan berfungsi untuk menentukan proses
manakah yang ada di ready queue yang akan dieksekusi oleh CPU. Bagian berikut ini akan
memberikan ilustrasialgoritma penjadwalan Shortest Job First.
3. Algoritma Penjadwalan Proses Shortest Job First (SJF)

Pada algoritma ini setiap proses yang ada di ready queue akan dieksekusi berdasarkan burst
time terkecil. Hal ini mengakibatkan waiting time yang pendek untuk setiap proses dan
karena haltersebut maka waiting time rata-ratanya juga menjadi pendek, sehingga dapat
dikatakan bahwaalgoritma ini adalah algoritma yang optimal.

Contoh 1 :

Process Arrival time Burst time

P1 0.0 7

P2 2.0 4

P3 4.0 1

P4 5.0 4

Contoh: Ada 4 buah proses yang datang berurutan yaitu P1 dengan arrival time pada 0.0 ms
dan burst time 7 ms, P2 dengan arrival time pada 2.0 ms dan burst time 4 ms, P3 dengan
arrivaltime pada 4.0 ms dan burst time 1 ms, P4 dengan arrival time pada 5.0 ms dan burst
time 4 ms.Hitunglah waiting time rata-rata dan turnaround time dari keempat proses tersebut
denganmengunakan algoritma SJF.

Gambar Shortest Job First (Non-Preemptive) :

P1 P3 P2 P4
0 7 8 12 16

Average waiting time rata-rata untuk ketiga porses tersebut adalah sebesar (9+1+0+2)/4=3
ms.

Contoh 2 :

Nama Proses Waktu Tiba Lama Eksekusi

A 0 10

B 0 5

C 0 7

D 0 1
 E 0 3

Nama Waktu Lama Mulai Selesai Waktu

TA
Proses Tiba Eksekusi Eksekusi Eksekusi Tunggu

D 0 1 0 1 0 1

E 0 3 1 4 1 4

B 0 5 4 9 4 9

C 0 7 9 16 9 16

A 0 10 16 26 16 26

TA 56

Rata-Rata 56/5 =
11.2

Tampak di sini bahwa SJF ini menyebabkan rata-rata lama tanggap semua proses itu menjadi
11.2satuan waktu. Rata-rata ini akan lebih singkat jika dibandingkan dengan rata-rata lama
tanggap untuk penjadwalan FIFO.

Algoritma ini dapat dibagi menjadi dua bagian yaitu :

1. Preemptive
Penjadwalan Preemptive mempunyai arti kemampuan sistem operasi untuk memberhentikan
sementara proses yang sedang berjalan untuk memberi ruang kepada prosesyang prioritasnya
lebih tinggi.

Jika ada proses yang sedang dieksekusi oleh CPU dan terdapat proses di ready queuedengan
burst time yang lebih kecil daripada proses yang sedang dieksekusi tersebut, makaproses
yang sedang dieksekusi oleh CPU akan digantikan oleh proses yang berada di readyqueue
tersebut.
Preemptive SJF sering disebut juga Shortest-Remaining- Time-Firstscheduling.2.

2. Non-preemptive
Penjadwalan Non Preemptive ialah salah satu jenis penjadwalan dimana sistemoperasi tidak
pernah melakukan context switch dari proses yang sedang berjalan ke proses yang lain.
Dengan kata lain, proses yang sedang berjalan tidak bisa di- interupt .CPU tidak
memperbolehkan proses yang ada di ready queue untuk menggeser prosesyang sedang
dieksekusi oleh CPU meskipun proses yang baru tersebut mempunyai burst time yang lebih
kecil.
Program Penjadwalan Proses Menggunakan Shortest Job First Dengan C++

Berikut ini adalah source code program penghitungan waiting time, turn around time dan
response time sistem penjadwalan proses menggunakan Shortest Job First dengan C++.

Ini listing programnya :

#include
#include
void main()
{
int i,j,n,brust_time[10],start_time[10],end_time[10],wait_time[10],temp,tot;
float avg;

printf("Enter the No. of jobs:\n\n");

scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("\n \n Enter %d process burst time:\n",i);
scanf("%d",&brust_time[i]);
}

for(i=1;i<=n;i++)
{
for(j=i+1;j<=n;j++)
{
if(brust_time[i]>brust_time[j])
{
temp=brust_time[i];
brust_time[i]=brust_time[j];
brust_time[j]=temp;
}
}

if(i==1)
{
start_time[1]=0;
end_time[1]=brust_time[1];
wait_time[1]=0;
}

else
{
start_time[i]=end_time[i-1];
end_time[i]=start_time[i]+brust_time[i];
wait_time[i]=start_time[i];
}
}
printf("\n\n BURST TIME \t STARTING TIME \t END TIME \t WAIT TIME\n");
printf("\n ********************************************************\n");
for(i=1;i<=n;i++)
{
printf("\n %5d %15d %15d %15d",brust_time[i],start_time[i],end_time[i],wait_time[i]);
}
printf("\n ********************************************************\n");
for(i=1,tot=0;i<=n;i++)
tot+=wait_time[i];
avg=(float)tot/n;
printf("\n\n\n AVERAGE WAITING TIME=%f",avg);
for(i=1,tot=0;i<=n;i++)
tot+=end_time[i];
avg=(float)tot/n;
printf("\n\n AVERAGE TURNAROUND TIME=%f",avg);
for(i=1,tot=0;i<=n;i++)
tot+=start_time[i];
avg=(float)tot/n;
printf("\n\n AVERAGE RESPONSE TIME=%f\n\n",avg);
getch();
}

Output :

4. Analisa
Berdasarkan program di atas dapat di simpulkan bahwa semua proses telah masuk pada ready
queque namun dalam algoritma SJF (shortest job first) maka suatu proses akan di eksekusi
berdasarkan burst time atau lamanya eksekusi, dan kemudian proses yang time burst nya
paling kecil akan di utamakan di bandingkan dengan proses yang time burst nya besar.

5. Kesimpulan
Pada program penjadwalan sjf ini setiap proses yang ada di ready queue akan dieksekusi
berdasarkan burst time terkecil. Hal ini mengakibatkan waiting time yang pendek untuk
setiap proses dan karena haltersebut maka waiting time rata-ratanya juga menjadi pendek,
sehingga dapat dikatakan bahwaalgoritma ini adalah algoritma yang optimal.

Ada beberapa kekurangan dari algoritma ini yaitu:

1. Susahnya untuk memprediksi burst time proses yang akan dieksekusi selanjutnya.
2. Proses yang mempunyai burst time yang besar akan memiliki waiting time yang besar pula
karena yang dieksekusi terlebih dahulu adalah proses dengan burst time yang lebih kecil.