Scribd
Upload
10 views10 pages

Urmish 8,9,10

The document discusses three programming concepts - process creation in C using gcc, implementation of the FCFS scheduling algorithm, and implementation of the Round Robin scheduling algorithm. Code snippets are provided for each algorithm.

Uploaded by

refalar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
10 views10 pages

Urmish 8,9,10

The document discusses three programming concepts - process creation in C using gcc, implementation of the FCFS scheduling algorithm, and implementation of the Round Robin scheduling algorithm. Code snippets are provided for each algorithm.

Uploaded by

refalar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 10

Practical No.

Aim :- Write a program for process creation using C (use gcc compiler).

Enrollment No.: 2203031050321 Page|


Practical No :- 9

Aim :-Write a program that shows the implementation of FCS & Round Robin
Algorithm.

FCFS

Code:
#include<stdio.h>
// Function to find the waiting time for all
// processes
void findWaitingTime(int processes[], int n,
int bt[], int wt[])
{
// waiting time for first process is 0
wt[0] = 0;

// calculating waiting time


for (int i = 1; i < n ; i++ )
wt[i] = bt[i-1] + wt[i-1] ;
}

// Function to calculate turn around time


void findTurnAroundTime( int processes[], int n,
int bt[], int wt[], int tat[])
{
// calculating turnaround time by adding
// bt[i] + wt[i]
for (int i = 0; i < n ; i++)
tat[i] = bt[i] + wt[i];
}

//Function to calculate average time


void findavgTime( int processes[], int n, int bt[])
{
int wt[n], tat[n], total_wt = 0, total_tat = 0;

//Function to find waiting time of all processes


findWaitingTime(processes, n, bt, wt);

//Function to find turn around time for all processes


findTurnAroundTime(processes, n, bt, wt, tat);

Enrollment No.: 2203031050321 Page|


//Display processes along with all details
printf("Processes Burst time Waiting time Turn around time\n");

// Calculate total waiting time and total turn


// around time
for (int i=0; i<n; i++)
{
total_wt = total_wt + wt[i];
total_tat = total_tat + tat[i];
printf(" %d ",(i+1));
printf(" %d ", bt[i] );
printf(" %d",wt[i] );
printf(" %d\n",tat[i] );
}
float s=(float)total_wt / (float)n;
float t=(float)total_tat / (float)n;
printf("Average waiting time = %f",s);
printf("\n");
printf("Average turn around time = %f ",t);
}

// Driver code
int main()
{
//process id's
int processes[] = { 1, 2, 3};
int n = sizeof processes / sizeof processes[0];

//Burst time of all processes


int burst_time[] = {10, 5, 8};

findavgTime(processes, n, burst_time);
return 0;
}

Output:-

Enrollment No.: 2203031050321 Page|


Round Robin
Code:-
#include <stdio.h>
#include <limits.h>
#include <stdbool.h>

struct P
{
int AT, BT, ST[20], WT, FT, TAT, pos;
};

int quant;
int main()
{
int n, i, j;
// Taking Input
printf("Enter the no. of processes :");
scanf("%d", &n);
struct P p[n];

printf("Enter the quantum \n");


scanf("%d", &quant);

printf("Enter the process numbers \n");


for (i = 0; i < n; i++)
scanf("%d", &(p[i].pos));

printf("Enter the Arrival time of processes \n");


for (i = 0; i < n; i++)
scanf("%d", &(p[i].AT));

printf("Enter the Burst time of processes \n");


for (i = 0; i < n; i++)
scanf("%d", &(p[i].BT));

// Declaring variables
int c = n, s[n][20];
float time = 0, mini = INT_MAX, b[n], a[n];

// Initializing burst and arrival time arrays


int index = -1;
for (i = 0; i < n; i++)
{
b[i] = p[i].BT;
a[i] = p[i].AT;
for (j = 0; j < 20; j++)
{
s[i][j] = -1;
Enrollment No.: 2203031050321 Page|
}
}

int tot_wt, tot_tat;


tot_wt = 0;
tot_tat = 0;
bool flag = false;

while (c != 0)
{

mini = INT_MAX;
flag = false;

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


{
float p = time + 0.1;
if (a[i] <= p && mini > a[i] && b[i] > 0)
{
index = i;
mini = a[i];
flag = true;
}
}
// if at =1 then loop gets out hence set flag to false
if (!flag)
{
time++;
continue;
}

// calculating start time


j = 0;

while (s[index][j] != -1)


{
j++;
}

if (s[index][j] == -1)
{
s[index][j] = time;
p[index].ST[j] = time;
}

if (b[index] <= quant)


{
time += b[index];
b[index] = 0;
Enrollment No.: 2203031050321 Page|
}
else
{
time += quant;
b[index] -= quant;
}

if (b[index] > 0)
{
a[index] = time + 0.1;
}

// calculating arrival,burst,final times


if (b[index] == 0)
{
c--;
p[index].FT = time;
p[index].WT = p[index].FT - p[index].AT - p[index].BT;
tot_wt += p[index].WT;
p[index].TAT = p[index].BT + p[index].WT;
tot_tat += p[index].TAT;
}

} // end of while loop

// Printing output
printf("Process number ");
printf("Arrival time ");
printf("Burst time ");
printf("\tStart time");
j = 0;
while (j != 10)
{
j += 1;
printf(" ");
}
printf("\t\tFinal time");
printf("\tWait Time ");
printf("\tTurnAround Time \n");

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


{
printf("%d \t\t", p[i].pos);
printf("%d \t\t", p[i].AT);
printf("%d \t", p[i].BT);
j = 0;
int v = 0;
while (s[i][j] != -1)
{
Enrollment No.: 2203031050321 Page|
printf("%d ", p[i].ST[j]);
j++;
v += 3;
}
while (v != 40)
{
printf(" ");
v += 1;
}
printf("%d \t\t", p[i].FT);
printf("%d \t\t", p[i].WT);
printf("%d \n", p[i].TAT);
}

// Calculating average wait time and turnaround time


double avg_wt, avg_tat;
avg_wt = tot_wt / (float)n;
avg_tat = tot_tat / (float)n;

// Printing average wait time and turnaround time


printf("The average wait time is : %lf\n", avg_wt);
printf("The average TurnAround time is : %lf\n", avg_tat);

return 0;
}

Output:-

Enrollment No.: 2203031050321 Page|


Practical No:-10

Aim:- Write a program that shows the implementation of Banker’s Algorithm .

Code:
#include <stdio.h>
int main()
{
// P0, P1, P2, P3, P4 are the names of Process
int n, r, i, j, k;
n = 5; // Indicates the Number of processes r = 3; //Indicates the Number
of resources
int alloc[5][3] = {{0, 0, 1}, // P0 // This is Allocation Matrix
{3, 0, 0}, // P1
{1, 0, 1}, // P2
{2, 3, 2}, // P3
{0, 0, 3}}; // P4

int max[5][3] = {{7, 6, 3}, // P0 // MAX Matrix


{3, 2, 2}, // P1
{8, 0, 2}, // P2
{2, 1, 2}, // P3
{5, 2, 3}}; // P4
int avail[3] = {2, 3, 2}; // These are Available Resources
int f[n], ans[n], ind = 0;
for (k = 0; k < n; k++)
{
f[k] = 0;
}
int need[n][r];
for(i = 0; i < n; i++)
Enrollment No.: 2203031050321 Page|
{

for (j = 0; j < r; j++)


need[i][j] = max[i][j] - alloc[i][j];
}
int y = 0;
for (k = 0; k < 5; k++)
{
for (i = 0; i < n; i++)
{
if (f[i] == 0)
{
int flag = 0;
for (j = 0; j < r; j++)
{
if (need[i][j] > avail[j])
{
flag = 1;
break;
}
}

if (flag == 0)
{
ans[ind++] = i;
for (y = 0; y < r; y++)
avail[y] += alloc[i][y];
f[i] = 1;
}

Enrollment No.: 2203031050321 Page|


}
}
}

printf("Th SAFE Sequence is as follows\n");


for (i = 0; i < n - 1; i++)
printf(" P%d ->", ans[i]);
printf(" P%d", ans[n - 1]);
return (0);
}

Output:

Enrollment No.: 2203031050321 Page|

You might also like