Disk Scheduling

#include<stdio.h>
//#include<conio.h>
#include<math.h>

int main()
{
int req[30],head,i,move,n,ch,t1,t2,max,min,g[30],c,h,visited=201;

printf(“(1) LOOK    (2) CLOOK    (3) FCFS    (4) SSTF   (5)SCAN   (6)CSCAN   (0) EXIT Enter your choice: “);
scanf(“%d”,&ch);

while(ch)
{ printf(“Enter the current head position: “);
scanf(“%d”,&head); h=head;
printf(“Enter the number of requests: “);
scanf(“%d”,&n); move=0;
printf(“Total number of cylinders: 200.”);
printf(“Enter the requests (1 to 200):”);
tab:
for(i=0;i<n;i++)
{
scanf(“%d”,&req[i]);
if(req[i]>200||req[i]<1)
{ printf(“Enter requests only between 1-200.”); goto tab; }
}

switch(ch)
{
case 1:{
printf(“Seek Pattern for look\n”);

int j,temp,start;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(req[i]>req[j])
{
temp=req[i];
req[i]=req[j];
req[j]=temp;
}
min=req[0];
max=req[n-1];
printf(“\n\n\n”);
for(i=0,j=i+1;i<n+1;i++,j++)
{if((head>req[i])&&(head<req[j]))
{start=i;break;
}
}
i=0;
while(head!=min)//loop for goin towards left
{

move+=fabs(head-req[start]);
head=req[start];
g[i]=req[start];
req[start]=visited;
start–;i++;
}
for(j=0;j<n;j++)//loop for goin towards right
{
if(req[j]!=visited)
{//printf(” \n%d “,reqtest[j]);
move+=fabs(head-req[j]);
head=req[j];
g[i]=req[j];  i++;
}
}
printf(“Order of servicing:”);
printf(“%d: “,h);
for(i=0;i<=n;i++)
{
if(g[i]<=199)
printf(“%d “,g[i]);
}
printf(“\nTotal Head Movements: %d\n”,move);

break;
}
case 2:{
printf(“SEEK PATTERN FOR CLOOK”);
int j,temp,start;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(req[i]>req[j])
{
temp=req[i];
req[i]=req[j];
req[j]=temp;
}
min=req[0];
max=req[n-1];

printf(“\n\n\n”);
for(i=0,j=i+1;i<n+1;i++,j++)
{if((head>req[i])&&(head<req[j]))
{start=i+1;break;
}
}
i=0;
while(head!=max)//loop for goin towards left
{

move+=fabs(head-req[start]);
head=req[start];
g[i]=req[start];
req[start]=visited;
start++;i++;
}
for(j=0;j<n;j++)// for looking from right
{
if(req[j]!=visited)
{//printf(” \n%d “,reqtest[j]);
move+=fabs(head-req[j]);
head=req[j];
g[i]=req[j];  i++;
}
}
printf(“Order of servicing:”);
printf(“%d: “,h);
for(i=0;i<n;i++)
{
if(g[i]<=199)
printf(“%d “,g[i]);
}
printf(“\nTotal Head Movements: %d\n”,move);

break;
}

case 3:

printf(“SEEK PATTERN FOR FCFS”);
for(i=0,c=0;i<n;i++,c++)
{
printf(“%d “,req[i]);
move+=fabs(head-req[i]);
head=req[i];
g[c]=req[i];
}
printf(“Order of servicing:”);
printf(“%d: “,h);
for(i=0;i<n;i++)
{
if(g[i]<=199)
printf(“%d “,g[i]);
}
printf(“\nTotal Head Movements: %d\n”,move);

break;

case 4:
{ printf(“SEEK PATTERN FOR SSTF”);
int j,temp,diff,pos;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(req[i]>req[j])
{
temp=req[i];
req[i]=req[j];
req[j]=temp;
}
for(i=0;i<n;i++)
printf(” %d “,req[i]);
for(i=0;i<n;i++)
{
diff=fabs(head-req[i]);
pos=i;
for(j=0;j<n;j++)
{

if((fabs(head-req[j])<diff)&&(head!=req[j]))
{
diff=fabs(head-req[j]);
pos=j;
}
}
move+=diff;
head=req[pos];
g[i]=head;
req[pos]=visited;

}
printf(“Order of servicing:”);
printf(“%d: “,h);
for(i=0;i<n;i++)
{
if(g[i]<=199)
printf(“%d “,g[i]);
}
printf(“\nTotal Head Movements: %d\n”,move);

break;

}
case 5:
{printf(“SEEK PATTERN FOR SCAN”);
int j,reqtest[30],temp,start;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(req[i]>req[j])
{
temp=req[i];
req[i]=req[j];
req[j]=temp;
}
printf(“\n\n\n”);
reqtest[0]=0;
for(i=0,j=i+1;i<n;i++,j++)
{reqtest[j]=req[i];}

for(i=0,j=i+1;i<n+1;i++,j++)
{if((head>reqtest[i])&&(head<reqtest[j]))
{start=i;
break;}
}
i=0;
while(head!=0)//loop for goin towards left
{

move+=fabs(head-reqtest[start]);
head=reqtest[start];
g[i]=reqtest[start];
reqtest[start]=visited;
start–;i++;
}
for(j=0;j<=n;j++)//loop for goin towards left
{
if(reqtest[j]!=visited)
{//printf(” \n%d “,reqtest[j]);
move+=fabs(head-reqtest[j]);
head=reqtest[j];
g[i]=reqtest[j];  i++;
}
}

printf(“Order of servicing:”);
printf(“%d: “,h);
for(i=0;i<=n;i++)
{
if(g[i]<=199)
printf(“%d “,g[i]);
}
printf(“\nTotal Head Movements: %d\n”,move);

break;
}

case 6:{
printf(“SEEK PATTERN FOR CSCAN”);
int j,reqtest[30],temp,start;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(req[i]>req[j])
{
temp=req[i];
req[i]=req[j];
req[j]=temp;
}
min=req[0];
max=req[n-1];
printf(“\n\n\n”);
reqtest[n+1]=199;reqtest[0]=0;
for(i=0,j=i+1;i<n;i++,j++)
{reqtest[j]=req[i];}

for(i=0,j=i+1;i<n+1;i++,j++)
{if((head>reqtest[i])&&(head<reqtest[j]))
{start=i+1;break;
}
}
i=0;
while(head!=199)//loop for goin towards left
{

move+=fabs(head-reqtest[start]);
head=reqtest[start];
g[i]=reqtest[start];
reqtest[start]=visited;
start++;i++;
}
for(j=0;j<=n+1;j++)// for scan from right
{
if(reqtest[j]!=visited)
{//printf(” \n%d “,reqtest[j]);
move+=fabs(head-req[j]);
head=req[j];
g[i]=req[j];  i++;
}
}
printf(“Order of servicing:”);
printf(“%d: “,h);
for(i=0;i<=n+1;i++)
{
if(g[i]<=199)
printf(“%d “,g[i]);
}
printf(“\nTotal Head Movements: %d\n”,move);

break;
}

}/*switch*/

printf(“(1) LOOK    (2) CLOOK    (3) FCFS    (4) SSTF   (5)SCAN   (6)CSCAN   (0) EXITEnter your choice:”);
scanf(“%d”,&ch);
}/*while*/
return 0;}/*main*/

DELETE FILE

#include <unistd.h>
#include <fcntl.h>

int main()
{
int flag=1;
char *fname;
char file[50]={0};

while(flag==1)
{
printf(“\nEnter File Name to Delete:\n”);

scanf(“%s”,&file);

fname=file;

if (open(fname,O_RDWR) < 0)
{
printf (“\nOpen Error\n”);
exit(0);
}

if (unlink(fname) < 0)
{
printf(“\nUnlink Error\n”);
exit(1);
}

printf(“\n*** File Deleted ***\n”);

printf(“\nPress 1 to Continue Or 0 to Exit\n”);
scanf(“%d”,&flag);
}
}

PAGE REPLACEMENT

int checkf(int arr[], int x);
int position(int arr[], int a, int b);
int check(int arr[], int x);
int fifo();
int lru();
int fifo()
{    int queue[3]={0,0,0};
int ptr=0;
int input[20];
int i,n,j;
int flag=0, pf=0;

printf(“Enter number of pages in sequence\n”);
scanf(“%d”,&n);
printf(“Enter the page sequence\n”);
for(i=0;i<n;i++)
{    scanf(“%d”,&input[i]);
}

printf(“\nThe page replacements are as follows\n”);
i=0;
while(i<n)
{    flag=checkf(queue,input[i]);
if(flag==0)
{    if(i<3)
{    queue[i]=input[i];
}
else
{    queue[ptr]=input[i];
ptr=(ptr+1)%3;
}
pf++;
}
for(j=0;j<3;j++)
{    printf(“%d\t”,queue[j]);
}
printf(“\n”);
i++;
}

printf(“No. of page faults is %d”,pf);

return 0;
}
int checkf(int arr[],int x)
{
int i;
for(i=0;i<3;i++)
{
if(arr[i]==x)
return 1;

}
return 0;
}

int lru()
{       int queue[3]={0,0,0};
int input[20];
int i,n,j;
int flag=0,pf=0;
int pos;
printf(“Enter number of pages in sequence\n”);
scanf(“%d”,&n);
printf(“Enter the page sequence\n”);
for(i=0;i<n;i++)
{    scanf(“%d”,&input[i]);
}
printf(“\nThe page replacement sequence is as follows\n”);
i=0;
while(i<n)
{    flag=check(queue,input[i]);
if(flag==0)
{    if(i<3)
{    queue[i]=input[i];
}
else
{    pos=position(queue,input[i-1],input[i-2]);
queue[pos]=input[i];
}
pf++;
}
for(j=0;j<3;j++)
{    printf(“%d\t”,queue[j]);
}
printf(“\n”);
i++;
}
printf(“No. of page faults is %d”,pf);
return 0;
}
int check(int arr[],int x)
{
int i;
for(i=0;i<3;i++)
{    if(arr[i]==x)
return 1;
}
return 0;
}
int position(int arr[], int a, int b)
{    int i,x,y;
for(i=0;i<3;i++)
{    if(arr[i]==a)
{    x=i;
break;
}
}
for(i=0;i<3;i++)
{    if(arr[i]==b)
{    y=i;
break;
}
}
return (3-x-y);
}

int main()
{
int x=1;
printf(“\nMenu\n 1.FIFO \n 2.LRU \n”);
scanf(“%d”,&x);

if(x==1)
fifo();
else
lru();
}

Shell Programming

echo “Student Result : “
$count
$tmarks
$marks
$per

count=1
tmarks=0
marks=0
per=0

while [ $count -ne 0 ]
do

echo “Enter Marks:”
read x
tmarks=`expr $tmarks + $x`

echo “Out Of:”
read y
marks=`expr $marks + $y`

echo “Press 1 to Cont Or 0 to exit”
read count

done

echo “Your Marks : $tmarks”
echo “Out Of : $marks”
per=`expr $tmarks \* 100`
per=`expr $per \/ $marks`
echo “You Got $per%”

if [ $per -lt 60 ] && [ $per -gt 40 ]; then
echo “2nd Class”
fi

if [ $per -lt 40 ]; then
echo “Fail”
fi

if [ $per -ge 60 ]; then
echo “first class”
fi

Banker’s Algorithm

#include<stdio.h>

int main()
{
int nop=5,nor=3,available[3],allocated[5][3],need[5][3],finish[5],max[5][3],work[3];
int i,j,flag,k;

printf(“\n Enter number of resources of each type:\n”);
for(i=0;i<nor;i++)
{
scanf(“%d”,&available[i]);
work[i]=available[i];
}
for(i=0;i<nop;i++)
{
finish[i]=0;
}
for(i=0;i<nop;i++)
{
printf(“\nEnter Maximum demand of process %d”,i+1);
for(j=0;j<nor;j++)
{
printf(“\nEnter demand for resource %d:”,j+1);
scanf(“%d”,&max[i][j]);
}
}
for(i=0;i<nop;i++)
{
printf(“\nEnter resources allocated to process %d”,i+1);
for(j=0;j<nor;j++)
{
printf(“\nEnter number of resource allocated of type %d:”,j+1);
scanf(“%d”,&allocated[i][j]);
need[i][j]=max[i][j]-allocated[i][j];
}
}

printf(“Allocation\n A B C\n”);
for(i=0;i<nop;i++)
{
for(j=0;j<nor;j++)
{
printf(“%d “,allocated[i][j]);
}
printf(“\n”);
}
printf(“Max\n A B C\n”);
for(i=0;i<nop;i++)
{
for(j=0;j<nor;j++)
{
printf(“%d “,max[i][j]);
}
printf(“\n”);
}
printf(“Need\n A B C\n”);
for(i=0;i<nop;i++)
{
for(j=0;j<nor;j++)
{
printf(“%d “,need[i][j]);
}
printf(“\n”);
}
i=0;
for(;i<nop && finish[i]==0;i++)
{
flag=1;
for(j=0;j<nor && flag!=0;j++)
{
if(need[i][j]<=work[j])
{
flag=1;
}
else
{
flag=0;
}
}
if(flag!=0)
{
finish[i]=1;
//        printf(“\n%d\n”,i);
for(k=0;k<nor;k++)
{
work[k]+=allocated[i][k];
}
}
}
flag=1;
for(i=0;i<nop;i++)
{
if(finish[i]==0)
{
flag=0;

}
}
if(flag==0)
{
printf(“Processes are in unsafe state”);
}
else
{
printf(“Processes are in safe state”);
}
}

Fork Exec with Timer(better version)

#include<stdio.h>
#include<time.h>
int main(int argc,char *argv)
{
long start,end;
time(&start);
if(fork())
{
wait();
time(&end);
end=end-start;
printf(“\n Time taken: %02d:%02d:%02d”,(end/60/60)%60,(end/60)%60,end%60);
}
else
execvp(argv[1],argv+1);
return(0);
}

Fork Exec with Timer

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<wchar.h>
#include<time.h>
int main()
{
int flag,i,noa,temp;
char cmd[20]={0};
char *arg[20];
long start,end;
long st;
char buffer[20]={},s1[20]={},s2[20]={},s3[20]={};
time(&start);
if(fork()!=0)
{
wait();

time(&end);
end = end-start;

printf(“\nTime taken:%02d:%02d:%02d”,(end/60/60)%60,(end/60)%60,end%60);

printf(“\n***End Of Program***\n”);
}
else
{
noa=0;

printf(“\nEnter Command:\n”);
scanf(“%s”,&cmd);

printf(“\nEnter Total No. Of Arguments : \n”);
scanf(“%d”,&noa);
arg[0]=cmd;
if(noa>0)
{
printf(“\nEnter Arguments : \n”);
for(i=1;i<=noa;i++)
{
scanf(“%s”,&buffer);
switch(i)
{
case 1:
strcpy(s1,buffer);
break;
case 2:
strcpy(s2,buffer);
break;
case 3:
strcpy(s3,buffer);
break;
default:
break;

}

}
arg[1]=s1;
arg[2]=s2;
arg[3]=s3;
arg[noa+1]=”";
}

execvp(cmd,arg);
}
}

Fork-Exec

#include<stdio.h>

int main(int argc,char *argv[])
{
if (fork())
{
wait();
printf(“parent process\n”);
printf(“Pid %d\n”,getpid());
}
else
{
execvp(argv[1],argv+1);
printf(“pid %d \n”, getppid());
printf(“I am child”);
printf(“child pid %d”,getpid());
}
return 0;
}

======================================

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<wchar.h>

int main()
{
int flag,i,noa;
char cmd[20]={0};
char *arg[20];
char buffer[20];
if(fork()!=0)
{
wait();
printf(“\n***End Of Program***\n”);
}
else
{
flag=1;
noa=0;

while(flag==1)
{

printf(“\nEnter Command:\n”);
scanf(“%s”,cmd);

printf(“\nEnter Total No. Of Arguments : \n”);
scanf(“%d”,&noa);
if(noa>0)
{

printf(“\nEnter Arguments : \n”);
for(i=0;i<noa;i++)
{
scanf(“%s”,buffer);
arg[i]=buffer;
}
}

execvp(cmd,arg);

printf(“\n(Press 1 to Continue Or 0 to Exit) : “);
scanf(“%d”,&flag);
}
}
}

Copy variation

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
void copy(int f1,int f2)
{
char c[20];
int size;
do
{
size=read(f1,c,20);
write(f2,c,size);
}while(size==20);
}

int main(int argc,char *argv[])
{

if(argc!=3)
{
printf(“few or more arguments\n”);
exit(0);
}

if(strcmp(argv[1],argv[2])==0)
{
printf(“Same Filename”);
}

int a=open(argv[1],O_RDONLY);
int b=open(argv[2],O_WRONLY|O_CREAT,0666);

if(a==-1)
{
printf(“Unable to open or read Source file\n”);
}
int c1=access(argv[2],W_OK);

if(c1==-1)
{
printf(“Unable to write in destination file\n”);
exit(0);
}
copy(a,b);
close(a);
close(b);
return 0;
}

CPU Scheduling (SJF,FIFO,RR)

#include<stdio.h>

int main()
{
int x,i,k=0,p=1,c=1;
char W,w;
float a[10];

void SJF(float a[10],int x);
void RR(float a[10],int x);
void FCFS(float a[10],int x);

do
{
printf(“\n Enter Number Of Jobs:”);
scanf(“%d”,&x);

for(i=0;i<x;i++)
{
printf(“\n Enter CPU Burst for process %d”,i+1);
printf(“\n”);
scanf(“%f”,&(a[i]));
}
do
{
printf(“\n Enter Option:\n 1=ShortestJobFirst \n 2=FirstComeFirstServe \n 3=RoundRobin\n”);
scanf(“%d”,&k);

switch(k)
{
case 1:
SJF(a,x);
break;

case 2:
FCFS(a,x);
break;

case 3:
RR(a,x);
break;

default:
printf(“\n Wrong value”);
};
p=0;
printf(“\n Do you want to find times by any other algorithm?Y or N:”);
scanf(“%c”,&W);
if(W==’y’ | W==’Y')
{p=1;}

}while(p!=0);

c=0;
printf(“\n Do you want to find times for any other set of jobs?Y or N:”);
scanf(“%c”,&w);
if(w==’y’ | w==’Y')
{c=1;}
}
while(c!=0);

return 0;
}//End of main

void SJF(float b[10],int x)
{

int j,k,m;
float temp,tta=0,sta=0,avgta=0,swt=0,avgwt=0;

//Sorting CPU bursts
for(j=x-1;j>=0;j–)
{
for(k=0;k<j;k++)
{
if(b[k]>b[k+1])
{
temp=b[k];
b[k]=b[k+1];
b[k+1]=temp;
}
}
}

//Calculating times

for(m=0;m<x;m++)
{
printf(“\n %f”,b[m]);
tta=tta+b[m];
sta=sta+tta;
if(m<(x-1))
swt=swt+tta;
}

avgta=sta/x;
printf(“\n Average turnaround time is \t %f”,avgta);

avgwt=swt/x;
printf(“\n Average Waiting time is \t %f”,avgwt);
printf(“\n”);
}

void FCFS(float b[10],int x)
{
int i;
float tta=0,sta=0,avgta=0,swt=0,avgwt=0;
//ta denotes turnaround-t for time of,s for sum,avg for average
//wt denotes waiting time for all

for(i=0;i<x;i++)
{
tta=tta+b[i];
sta=sta+tta;
if(i<(x-1))
swt=swt+tta;
}

avgta=sta/x;
printf(“\n Average turnaround time is \t %f”,avgta);

avgwt=swt/x;
printf(“\n Average Waiting time is \t %f”,avgwt);
printf(“\n”);
}

void RR(float b[10],int x)
{

int i,complete=0;
float q,sta=0,swt=0,avgwt=0,avgta=0;

printf(“\n Enter Time quantum”);
scanf(“%f”, &q);

float wait[10],start[10],end[10];
//Initalize whole array to zero
for(i=0;i<x;i++)
{
start[i]=0;//Stores starting time of each process turn
wait[i]=0;//Stores waiting time
end[i]=0;//Stores ending time(either quantum or process-whichever is smaller)
printf(“\n process %d burst time = %f”,i,b[i]);
}

while(complete<x)
{
for(i=0;i<x;i++)//Outer loop for each pass through job array
{
if(b[i]<=q && b[i]!=0)
{

start[i]=sta;
complete++;

if (complete<=(x-1))
{
wait[i]=wait[i]+start[i]-end[i];
}
sta=sta+b[i];
b[i]=0;
end[i]=sta;
printf(“\n completing process i %d with wait time %f”,i,wait[i]);
}
if(b[i]>q)
{
start[i]=sta;

if (complete<=(x-1))//x-2 because process runs from 0 to n-1,=>if n-2 over imp
{
wait[i]=wait[i]+start[i]-end[i];//subtract prev stored value of end[i]
}
sta=sta+q;
b[i]=b[i]-q;
end[i]=sta;
printf(“\n NOT completing process i %d with wait time %f”,i,wait[i]);
}
}
}
for(i=0;i<x;i++)
{
swt=swt+wait[i];
}

avgta=sta/x;
printf(“\n Average turnaround time is \t %f”,avgta);

avgwt=swt/x;
printf(“\n Average Waiting time is \t %f”,avgwt,”\n”);

}