Name of the experiment: Write a program to implement First-Come, First

Serve (FCFS) scheduling algorithm.

Code:
#include<stdio.h>
#include<conio.h>
#define maximum 30
int main()
{
int
idx_i,idx_j,varN,arrayBt[maximum],arrayWt[maximum],arrayTat[maxi
mum];
float varWt=0,varTat=0;
printf("enter no. of process: ");
scanf("%d",&varN);
printf("enter burst-time for process: ");
for(idx_i=0;idx_i<varN;idx_i++)
{
scanf("%d",&arrayBt[idx_i]);
}
printf("process\t burstTime\t waitingTime\t
turnAroundTime\n");
for(idx_i=0;idx_i<varN;idx_i++)
{
arrayWt[idx_i]=0;
arrayTat[idx_i]=0;
for(idx_j=0;idx_j<idx_i;idx_j++)
{
arrayWt[idx_i]=arrayWt[idx_i]+arrayBt[idx_j];
}
arrayTat[idx_i]=arrayWt[idx_i]+arrayBt[idx_i];
 varWt=varWt+arrayWt[idx_i];
varTat=varTat+arrayTat[idx_i];
printf("%d\t %d\t\t %d\t\t
%d\n",idx_i+1,arrayBt[idx_i],arrayWt[idx_i],arrayTat[idx_i]);
}
varWt=varWt/varN;
varTat=varTat/varN;
printf("\navg waiting-time: %f",varWt);
printf("\navg turn-around-time: %f\n",varTat);
getch();
}

Name of the experiment: Write a program to implement Shortest Job First

(SJF) non preemptive scheduling algorithm.
Code:
#include<stdio.h>
#include<conio.h>
#define maximum 30
int main()
{
int
idx_i,idx_j,varN,varT,arrayP[maximum],arrayBt[maximum],arrayWt[m
aximum],arrayTat[maximum];
float varAwt=0,varAtat=0;
printf("enter no. of process: ");
scanf("%d",&varN);
printf("enter process: ");
for(idx_i=0; idx_i<varN; idx_i++)
{
scanf("%d",&arrayP[idx_i]);
}
 printf("enter burst-time of process: ");
for(idx_i=0; idx_i<varN; idx_i++)
{
scanf("%d",&arrayBt[idx_i]);
}

for(idx_i=0; idx_i<varN; idx_i++)

{
for(idx_j=0; idx_j<varN-idx_i-1; idx_j++)
{
if(arrayBt[idx_j]>arrayBt[idx_j+1])
{
varT=arrayBt[idx_j];
arrayBt[idx_j]=arrayBt[idx_j+1];
arrayBt[idx_j+1]=varT;

varT=arrayP[idx_j];
arrayP[idx_j]=arrayP[idx_j+1];
arrayP[idx_j+1]=varT;

}
}
}

printf("\nprocess\tburstTime\twaitingTime\tturnAroundTime\n");
for(idx_i=0; idx_i<varN; idx_i++)
{
arrayWt[idx_i]=0;
arrayTat[idx_i]=0;
 for(idx_j=0; idx_j<idx_i; idx_j++)
{
arrayWt[idx_i]=arrayWt[idx_i]+arrayBt[idx_j];
}
arrayTat[idx_i]=arrayWt[idx_i]+arrayBt[idx_i];
varAwt=varAwt+arrayWt[idx_i];
varAtat=varAtat+arrayTat[idx_i];

printf("%d\t%d\t\t%d\t\t%d\n",arrayP[idx_i],arrayBt[idx_i],array
Wt[idx_i],arrayTat[idx_i]);
}
varAwt=varAwt/varN;
varAtat=varAtat/varN;
printf("\navg waiting-time =%f\n",varAwt);
printf("avg turn-around-time=%f\n",varAtat);
getch();
}

Name of the experiment: Write a program to implement Shortest Remaining

Job First (Preemptive SJF) scheduling algorithm.
Code:
#include <stdio.h>
#define maximum 30
int main()
{
int arrayPr[maximum], arrayAt[maximum], arrayBt[maximum],
arrayWt[maximum], arrayTat[maximum], arrayTemp[maximum];
int idx_i, varSmallest, varCount = 0, varTime, varN;
double varWt = 0, varTat = 0, varEnd;
float varAwt, varAtat;
printf("enter no. of processes : ");
 scanf("%d", &varN);

printf("enter process : ");

for(idx_i=0; idx_i<varN; idx_i++)
{
scanf("%d", &arrayPr[idx_i]);
}

printf("enter arrival-time : ");

for(idx_i=0; idx_i<varN; idx_i++)
{
scanf("%d", &arrayAt[idx_i]);
}
printf("enter burst-time : ");
for(idx_i=0; idx_i<varN; idx_i++)
{
scanf("%d", &arrayBt[idx_i]);
arrayTemp[idx_i] = arrayBt[idx_i];;
}

arrayBt[9] = 9999;
int idx_k=0;
for(varTime = 0; varCount != varN; varTime++)
{
varSmallest = 9;
for(idx_i = 0; idx_i < varN; idx_i++)
{
if(arrayAt[idx_i] <= varTime && arrayBt[idx_i] <
arrayBt[varSmallest] && arrayBt[idx_i] > 0)
 {
varSmallest = idx_i;
}
}
arrayBt[varSmallest]--;
if(arrayBt[varSmallest] == 0)
{
varCount++;
varEnd = varTime + 1;
varWt = varWt + varEnd - arrayAt[varSmallest] -
arrayTemp[varSmallest];
arrayWt[idx_k] = varWt;
varTat = varTat + varEnd - arrayAt[varSmallest];
arrayTat[idx_k] = varTat;
idx_k++;
}
}

printf("\nprocess\tarrivalTime\tburstTime\twaitingTime\tturnArou
ndTime\n");
for(idx_i=0; idx_i<varN; idx_i++)
{

printf("%d\t%d\t\t%d\t\t%d\t\t%d\n",arrayPr[idx_i],arrayAt[idx_i
],arrayBt[idx_i],arrayWt[idx_i],arrayTat[idx_i]);
}

varAwt = varWt / varN;

varAtat = varTat / varN;
 printf("\n\navg waiting-time: %lf\n", varAwt);
printf("avg turn-around-time: %lf\n", varAtat);
return 0;
}

Name of the experiment: Write a program to implement Priority scheduling

algorithm.
Code:
#include<stdio.h>
#include<conio.h>
#define maximum 30
int main()
{
int
idx_i,idx_j,varN,varT,arrayBt[maximum],arrayWt[maximum],arrayPr[
maximum],arrayTat[maximum],varPos;
float varAwt=0,varAtat=0;
printf("enter no. of process : ");
scanf("%d",&varN);
printf("enter burst-time : ");
for(idx_i=0; idx_i<varN; idx_i++)
{
scanf("%d",&arrayBt[idx_i]);
}
printf("enter priority : ");
for(idx_i=0; idx_i<varN; idx_i++)
{
scanf("%d",&arrayPr[idx_i]);
}
for(idx_i=0; idx_i<varN; idx_i++)
 {
varPos=idx_i;
for(idx_j=idx_i+1; idx_j<varN; idx_j++)
{
if(arrayPr[idx_j]<arrayPr[varPos])
{
varPos=idx_j;
}
}
varT=arrayPr[idx_i];
arrayPr[idx_i]=arrayPr[varPos];
arrayPr[varPos]=varT;

varT=arrayBt[idx_i];
arrayBt[idx_i]=arrayBt[varPos];
arrayBt[varPos]=varT;
}

arrayWt[0]=0;

printf("\nprocess\tburstTime\tpriority\twaitingTime\tturnAroundT
ime\n");
for(idx_i=0; idx_i<varN; idx_i++)
{
arrayWt[idx_i]=0;
arrayTat[idx_i]=0;
for(idx_j=0; idx_j<idx_i; idx_j++)
{
arrayWt[idx_i]=arrayWt[idx_i]+arrayBt[idx_j];
 }
arrayTat[idx_i]=arrayWt[idx_i]+arrayBt[idx_i];
varAwt=varAwt+arrayWt[idx_i];
varAtat=varAtat+arrayTat[idx_i];

printf("%d\t%d\t\t%d\t\t%d\t\t%d\n",idx_i+1,arrayBt[idx_i],array
Pr[idx_i],arrayWt[idx_i],arrayTat[idx_i]);
}
varAwt=varAwt/varN;
varAtat=varAtat/varN;
printf("\navg waiting-time = %f\n",varAwt);
printf("avg turn-around-time = %f\n",varAtat);
getch();

Name of the experiment: Write a program to implement Round Robin

scheduling algorithm.
Code:
#include<stdio.h>
#include<conio.h>
int main()
{
int
varN,idx_i,varQt,varCount=0,varTemp,varSq=0,arrayBt[10],arrayWt[
10],arrayTat[10],arrayRem_bt[10];
float varAwt=0,varAtat=0;
printf("enter no. of process: ");
scanf("%d",&varN);
printf("enter burst-time of process: ");
for(idx_i=0; idx_i<varN; idx_i++)
{
scanf("%d",&arrayBt[idx_i]);
arrayRem_bt[idx_i]=arrayBt[idx_i];
}
printf("enter quantum time: ");
scanf("%d",&varQt);
while(1)
{
for(idx_i=0,varCount=0; idx_i<varN; idx_i++)
{
varTemp=varQt;
if(arrayRem_bt[idx_i]==0)
{
varCount++;
continue;
}
if(arrayRem_bt[idx_i]>varQt)
arrayRem_bt[idx_i]=arrayRem_bt[idx_i]-varQt;
else if(arrayRem_bt[idx_i]>=0)
{
varTemp=arrayRem_bt[idx_i];
arrayRem_bt[idx_i]=0;
}
varSq=varSq+varTemp;
arrayTat[idx_i]=varSq;
}
if(varN==varCount)
break;
 }

printf("\nprocess\tburstTime\tturnAroundTime\twaitingTime\n");
for(idx_i=0; idx_i<varN; idx_i++)
{
arrayWt[idx_i]=arrayTat[idx_i]-arrayBt[idx_i];
varAwt=varAwt+arrayWt[idx_i];
varAtat=varAtat+arrayTat[idx_i];
printf("%d\t %d\t\t %d\t\t
%d\n",idx_i+1,arrayBt[idx_i],arrayTat[idx_i],arrayWt[idx_i]);
}
varAwt=varAwt/varN;
varAtat=varAtat/varN;
printf("\navg waiting-time = %f",varAwt);
printf("\navg turn-around-time = %f\n",varAtat);
getch();
}

Name of the experiment: Write a program to implement Banker’s algorithm.

Code:
#include <stdio.h>
int main()
{
int varN, varM, idx_i, idx_j, idx_k;
varN = 5;
varM = 3;
int arrayAlloc[5][3] = { { 1, 2, 1 },
{ 3, 1, 1 },
{ 4, 1, 3 },
{ 3, 2, 2 },
 { 1, 1, 3 }
};

int arrayMax[5][3] = { { 8, 6, 4 },
{ 4, 3, 3 },
{ 10, 1, 3 },
{ 3, 3, 3 },
{ 5, 4, 4 }
};

int arrayAvail[3] = { 3, 3, 2 };

int arrayF[varN], arrayAns[varN], index = 0;

for (idx_k = 0; idx_k < varN; idx_k++)
{
arrayF[idx_k] = 0;
}
int arrayNeed[varN][varM];
for (idx_i = 0; idx_i < varN; idx_i++)
{
for (idx_j = 0; idx_j < varM; idx_j++)
arrayNeed[idx_i][idx_j] = arrayMax[idx_i][idx_j] -
arrayAlloc[idx_i][idx_j];
}
int varY = 0;
for (idx_k = 0; idx_k < 5; idx_k++)
{
for (idx_i = 0; idx_i < varN; idx_i++)
{
 if (arrayF[idx_i] == 0)
{

int varFlag = 0;
for (idx_j = 0; idx_j < varM; idx_j++)
{
if (arrayNeed[idx_i][idx_j] >
arrayAvail[idx_j])
{
varFlag = 1;
break;
}
}

if (varFlag == 0)
{
arrayAns[index++] = idx_i;
for (varY = 0; varY < varM; varY++)
arrayAvail[varY] +=
arrayAlloc[idx_i][varY];
arrayF[idx_i] = 1;
}
}
}
}

int varFlag = 1;

for(int idx_i=0; idx_i<varN; idx_i++)

 {
if(arrayF[idx_i]==0)
{
varFlag=0;
printf("the system is not safe");
break;
}
}

if(varFlag==1)
{
printf("safe sequence is\n");
for (idx_i = 0; idx_i < varN - 1; idx_i++)
printf(" p%d ->", arrayAns[idx_i]);
printf(" P%d", arrayAns[varN - 1]);
}
printf("\n");

return 0;
}

Name of the experiment: Write a program to implement Producer Consumer

Problem.
Code:
#include<stdio.h>
#include<stdlib.h>

#define sizeOfBuffer 10
int varIn=0;
int varOut=0;
int arrayBuffer[sizeOfBuffer];
int varNextProduce=1;
int varNextConsumed;

int funcProducer()
{
while(((varIn+1)%sizeOfBuffer)==varOut)
{
printf("buffer full!\n");
return 0;
}
arrayBuffer[varIn]=varNextProduce;

printf("producer produces item %d\n",arrayBuffer[varIn]);

varIn=(varIn+1)%sizeOfBuffer;
varNextProduce++;
}

int funcConsumer()
{
while(varIn==varOut)
{
printf("buffer empty!\n");
return 0;
}
 varNextConsumed=arrayBuffer[varOut];

printf("consumer consumes item %d\n",varNextConsumed);

varOut=(varOut+1)%sizeOfBuffer;
}

int main()
{
int varN, idx_i;

for(idx_i=1; idx_i>0; idx_i++)

{
printf("enter choice : ");
scanf("%d",&varN);

switch(varN)
{
case 1:
funcProducer();
break;

case 2:
funcConsumer();
break;

default:
exit(0);
 break;
}
}
return 0;
}

Name of the experiment: Write a program to implement Peterson’s Solution.

Code:
#include<stdio.h>
#include <stdbool.h>
#define numOfProcess 2
bool varFlag[numOfProcess];
int varTurn;
void funcProcess(int idx_i)
{
int varOther=1-idx_i;
varFlag[idx_i]=true;
varTurn=varOther;
while(varFlag[varOther] && varTurn==varOther);
printf("process %d is in critical section.\n", idx_i);
varFlag[idx_i]=false;
}
int main()
{
varFlag[0]=false;
varFlag[1]=false;
varTurn = 0;
funcProcess(0);
funcProcess(1);
 return 0;
}

Name of the experiment: Write a program to implement Semaphore.

Code:
#include<stdio.h>
#include<stdlib.h>
int varMutex = 1, varFull = 0, varEmpty = 3, varX = 0;
int main()
{
int varN;
void funcProducer();
void funcConsumer();
int funcWait(int);
int funcSignal(int);
printf("1. producer\n2. consumer\n3. exit");
while(1)
{
printf("\nenter choice: ");
scanf("%d",&varN);
switch(varN)
{
case 1:
if(varMutex==1 && varEmpty!=0)
funcProducer();
else
printf("buffer full");
break;
case 2:
 if(varMutex==1 && varFull!=0)
funcConsumer();
else
printf("buffer empty");
break;
case 3:
exit(0);
break;
}
}
return 0;
}
int funcWait(int varS)
{
return(--varS);

}
int funcSignal(int varS)
{
return(++varS);
}
void funcProducer()
{
varMutex = funcWait(varMutex);
varFull = funcSignal(varFull);
varEmpty = funcWait(varEmpty);
varX++;
printf("\nproducer produces the item %d",varX);
 varMutex = funcSignal(varMutex);
}
void funcConsumer()
{
varMutex = funcWait(varMutex);
varFull = funcWait(varFull);
varEmpty = funcSignal(varEmpty);
printf("\nconsumer consumes the item %d",varX);
varX--;
varMutex = funcSignal(varMutex);
}

Name of the experiment: A shell program to find the largest number.

Code:
echo "enter a number : "
read -a arrNum
echo "print all the numbers : "${arrNum[*]}
maximum=${arrNum[0]}
varN=${#arrNum[@]}
for((idx_i=1;idx_i<varN;idx_i++))
{
if [ ${arrNum[idx_i]} -gt $maximum ]
then
maximum=${arrNum[idx_i]}
fi
}
echo "maximum number is : " $maximum
Name of the experiment: A shell program to find the factorial of a given
number using recursion.
Code:
echo " enter a number : "
read varN
function funcf()
{
local var_n=$1
if [[ $var_n -eq 0 ]];
then
echo 1
else
echo $((var_n*$(funcf $var_n-1)))
fi
}
echo $(funcf $varN)

Name of the experiment: A shell program to find the factorial of a given

number without using recursion.
Code:
echo "enter a number : "
read varNum
varFact=1
for((idx_i=2;idx_i<=varNum;idx_i++))
{
varFact=$((varFact*idx_i))
}
echo $varFact

Name of the experiment: A shell program to find the fibonacci series of a given
number using recursion.
Code:
funcFibonacci()
{
varN=$1
if((varN<=0))
then
echo 0
elif((varN<=1))
then
echo 1
else
echo $(( $(funcFibonacci $((varN-1)) )+$(funcFibonacci $((varN-
2))) ))
fi
}
echo -n "enter no. of terms in fibonacci series: "
read varNum
echo "fibonacci series: "
for((idx_i=0;idx_i<$varNum;idx_i++))
do
echo -n "$(funcFibonacci $idx_i) "
done

Name of the experiment: A shell program to find the fibonacci series of a given
numberwithout using recursion.
Code:
echo "enter n: "
read varN
varA=0
varB=1
echo "fibonacci series .... "
echo $varA
echo $varB
for(( idx_i=2;idx_i<=$varN;idx_i++))
do
varC=$(( varA+varB ))
echo $varC
varA=$varB
varB=$varC
done