Operating Systems

CSE2005
Name-Anjali Sachdeva

Reg No-16BEC0014

1. PHILOSOPHER DINING PROBLEM

 Input Code:
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>

const int N_PHILOSOPHERS = 5; // Number of philosophers

const int MEALS_TO_HEAVEN = 10; // Number of iterations before
philosophers finish
const int MAX_DELAY = 500000; // Maximum delay between meal iterations

// Semaphore ids
int chopsticks; // ID for array of IPC semaphores
int not_at_table; // Start dinner when semaphore reaches 0

int philosopher(int n); // Defined after main()

int main(){
int i, status;
pid_t phil[N_PHILOSOPHERS];
printf("The Dining-Philosophers Problem\n");

// Parent process only:

//
// Allocate chopsticks: semaphores which are initially set to value
// 1. 5 chopsticks total in an array.
chopsticks = semget(IPC_PRIVATE, N_PHILOSOPHERS, IPC_CREAT | 0600);
for(i=0; i<N_PHILOSOPHERS; i++){
semctl(chopsticks, i, SETVAL, 1);
}
not_at_table = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);

// Prevent children from starting to eat

semctl(not_at_table, 0, SETVAL, 5);

// Parent generates child processes

 for(i=0; i < N_PHILOSOPHERS; i++){
int pid = fork();
if(pid == 0){ // child has pid 0
int ret = philosopher(i); // child acts as philosopher
exit(ret); // then exits
}
else{ // parent gets pid > 0
phil[i] = pid; // parent tracks children
}
}

// Parent waits on all children to finish

for(i = 0; i < N_PHILOSOPHERS; i++) {
waitpid(phil[i], &status, 0);
}

// Eliminate the chopsticks and table semaphores

semctl(chopsticks, 0, IPC_RMID, 0);
semctl(not_at_table, 0, IPC_RMID, 0);
return 0;
}

// Code for dining philosopher child processes

int philosopher(int n){
int i, j, first, second;
struct sembuf op; // Used to perform semaphore operations
op.sem_flg = 0;
srand(n); // Seed random number generator

// Avoid deadlock via slightly different order of chopstick requests

// for last philospher
first = (n < N_PHILOSOPHERS)? n : 0;
second = (n < N_PHILOSOPHERS)? n + 1 : N_PHILOSOPHERS-1;

// Check in for dinner

op.sem_op = -1;
op.sem_num = 0;
semop(not_at_table, &op, 1);
printf("Philosopher %d at the table\n", n);

// Wait for everyone to check in before start the meal

op.sem_op = 0;
op.sem_num = 0;
semop(not_at_table, &op, 1);

// Main loop of thinking/eating cycles

for(i = 0; i < MEALS_TO_HEAVEN; i++) {
int sleep_time = rand() % MAX_DELAY;
usleep(sleep_time); // sleep for 0-9 microseconds

printf("%2d: Philosopher %d is thinking ...\n", i,n);

/* get first chopstick */
op.sem_op = -1;
op.sem_num = first;
semop(chopsticks, &op, 1);
/* get second chopstick */
op.sem_op = -1;
 op.sem_num = second;
semop(chopsticks, &op, 1);

printf("%2d: Philosopher %d is eating ...\n", i,n);

/* release first chopstick */
op.sem_op = +1;
op.sem_num = first;
semop(chopsticks, &op, 1);
/* release second chopstick */
op.sem_op = +1;
op.sem_num = second;
semop(chopsticks, &op, 1);
}

printf("Philosopher %d going to heaven\n",n);

exit(n);
}
 Output :
2. BOUNDED BUFFER PROBLEM

 Input Code:
#include<stdio.h>

#include<stdlib.h>

int mutex=1,full=0,empty=3,x=0;

int main()

int n;

void producer();

void consumer();

int wait(int);

int signal(int);

printf("\n1.Producer\n2.Consumer\n3.Exit");

while(1)

printf("\nEnter your choice:");

scanf("%d",&n);

switch(n)

case 1: if((mutex==1)&&(empty!=0))

producer();

else

printf("Buffer is full!!");
 break;

case 2: if((mutex==1)&&(full!=0))

consumer();

else

printf("Buffer is empty!!");

break;

case 3:

exit(0);

break;

return 0;

int wait(int s)

return (--s);

int signal(int s)

return(++s);

}
void producer()

mutex=wait(mutex);

full=signal(full);

empty=wait(empty);

x++;

printf("\nProducer produces the item %d",x);

mutex=signal(mutex);

void consumer()

mutex=wait(mutex);

full=wait(full);

empty=signal(empty);

printf("\nConsumer consumes item %d",x);

x--;

mutex=signal(mutex);

}
 Output:
3. READER WRITER PROBLEM

 Input Code:
#include<stdio.h>

#include<stdlib.h>

int rw_mutex=1,mutex=1,x=0;

int main()

int n;

void writer();

void reader();

int wait(int);

int signal(int);

printf("\n1.Writer\n2.Reader\n3.Exit");

while(1)

printf("\nEnter your choice:");

scanf("%d",&n);

switch(n)

case 1: if((mutex==1)&&(rw_mutex==1))

writer();

else

printf("Can't write");

break;
 case 2: if((mutex==1)&&(rw_mutex==0))

reader();

else

printf("Can't read");

break;

case 3:

exit(0);

break;

return 0;

int wait(int s)

return (--s);

int signal(int s)

return(++s);

}
void writer()

mutex=wait(rw_mutex);

x++;

printf("\nWriter writes %d",x);

if(x==1)

rw_mutex=wait(rw_mutex);

mutex=signal(mutex);

void reader()

mutex=wait(mutex);

printf("\nReader reads %d",x);

x--;

if(x==0)

rw_mutex=signal(rw_mutex);

mutex=signal(mutex);

}
 Output:
4. PRODUCER CONSUMER PROBLEM

 Input Code:
#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <time.h>

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

# define NUM_LOOPS 20

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

int sem_set_id;

nt child_pid;

int i;

struct sembuf sem_op;

int rc;

int val;

sem_set_id = semget(IPC_PRIVATE, 1, 0600);

if (sem_set_id == -1) {

perror("main: semget");

exit(1);

printf("Semaphore set created, semaphore set id '%d'.n", sem_set_id);

rc = semctl(sem_set_id, 0, SETVAL, 0);

child_pid = fork();

switch (child_pid) {

case -1:

perror("fork");

exit(1);

case 0:

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

sem_op.sem_num = 0;

sem_op.sem_op = -1;

sem_op.sem_flg = 0;

semop(sem_set_id, &sem_op,1);

printf("consumer: '%d\n",i);

val=semctl(sem_set_id,0,GETVAL,0);

printf( "consumer after completion %d\n",val);

fflush(stdout);

sleep(3);

break;

default:

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

printf("producer: '%d\n", i);

fflush(stdout);

sem_op.sem_num = 0;
 sem_op.sem_op = 1;

sem_op.sem_flg = 0;

semop(sem_set_id, &sem_op, 1);

val=semctl(sem_set_id,0,GETVAL,0);

sleep(2);

printf(" producer after completion %d\n",val);

break;

return 0;

}
 Output:
5. Banker’s Algorithm

 Input Code:
#include<stdio.h>

#define true 1

#define false 0

int m,n,i,j,count=0,process;

int max[10][10],alloc[10][10],need[10][10],c[10],avail[10],finish[10];

void readtable(int t[10][10])

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

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

scanf("%d",&t[i][j]);

void printtable(int t[10][10])

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

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

printf("\t%d",t[i][j]);

printf("\n");

void readvector(int v[10])

for(j=0;j<n;j++)
 scanf("%d",&v[j]);

void printvector(int v[10])

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

printf("\t%d",v[j]);

void init()

printf("enter the number of process\n");

scanf("%d",&m);

printf("enter the number of resources\n");

scanf("%d",&n);

printf("enter the claim table\n");

readtable(max);

printf("enter the allocation table\n");

readtable(alloc);

printf("enter the max units of each resource\n");

readvector(c);

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

finish[i]=false;

void findavail()

{
 int sum;

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

sum=0;

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

sum=sum+alloc[i][j];

avail[j]=c[j]-sum;

void findneed()

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

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

need[i][j]=max[i][j]-alloc[i][j];

void selectprocess()

int flag;
for(i=0;i<m;i++)

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

if(need[i][j]<=avail[j])

flag=1;

else

flag=0;

break;

if((flag==1)&&(finish[i]==false))

process=i;

count++;

break;

printf("current status is\n");

printtable(alloc);

if(flag==0)

printf("system is in unsafe state\n");

exit(1);
 }

printf("system is in safe state");

void executeprocess(int p)

printf("excuting process is %d",p);

printtable(alloc);

void releaseresource()

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

avail[j]=avail[j]+alloc[process][j];

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

alloc[process][j]=0;

need[process][j]=0;

main()

init();

findavail();

findneed();

do
 {

selectprocess();

finish[process]=true;

executeprocess(process);

releaseresource();

}while(count<m);

printf("\n all proces executed correctly");

}
 Output:
6. Pipes(altered code done in class)

 Input Code:
#include<stdio.h>

#include<fcntl.h>

#include<string.h>

main()

int pfd1[2],pfd2[2],p,x1,x2;

char msg3[100];

int x3;

char buf[20];

char msg1[100];

printf("input string in parent");

scanf("%s",msg1);

char msg2[100];

int i;

printf("inpur string in child");

scanf("%s",msg2);

x1=strlen(msg1);

x2=strlen(msg2);

for(i=0;i<x1+x2;i++){

if(i<x1)

msg3[i]=msg1[i];

else
 msg3[i]=msg2[i-x1];

pipe(pfd1);

p=fork();

if(p==0)//from parent to child

close(pfd1[1]);

read(pfd1[0],buf,x3);

else //parent

close(pfd1[0]);

write(pfd1[1],msg3,x3);

printf("%s",buf);

//if(p==0)//from child to parent

 Output: