[go: up one dir, main page]
Scribd
Upload
30 views9 pages

Program:: A. Implementation of Producer Consumer Problem Using Semaphore

This document contains implementations of common concurrency problems using semaphores in C including: 1) The producer-consumer problem using a buffer and semaphores to control access. 2) The readers-writers problem using semaphores to allow multiple concurrent readers or a single writer. 3) The dining philosophers problem using semaphores to control access to shared forks between philosophers. 4) The bankers algorithm for deadlock avoidance using matrices to track resource allocation and availability.

Uploaded by

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

Program:: A. Implementation of Producer Consumer Problem Using Semaphore

This document contains implementations of common concurrency problems using semaphores in C including: 1) The producer-consumer problem using a buffer and semaphores to control access. 2) The readers-writers problem using semaphores to allow multiple concurrent readers or a single writer. 3) The dining philosophers problem using semaphores to control access to shared forks between philosophers. 4) The bankers algorithm for deadlock avoidance using matrices to track resource allocation and availability.

Uploaded by

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

a. Implementation of Producer Consumer problem using Semaphore.

//Producer Consumer Problem -OS Lab

Program:

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
int buf[5],f,r;
sem_t mutex,full,empty;
void *produce(void *arg)
{
int i;
for(i=0;i<=5;i++)
{
sem_wait(&empty);
sem_wait(&mutex);
printf("produced item is %d\n",i);
buf[(++r)%5]=i;
sleep(1);
sem_post(&mutex);
sem_post(&full);
printf("full %u\n",full);
}
}
void *consume(void *arg)
{
int item,i;
for(i=0;i<=5;i++)
{
sem_wait(&full);
//printf("full %u\n",full);
sem_wait(&mutex);
item=buf[(++f)%5];
printf("consumed item is %d\n",item);
sleep(1);
sem_post(&mutex);
sem_post(&empty);
}
}
main()
{
pthread_t tid1,tid2;
sem_init(&mutex,0,1);
sem_init(&full,0,0);
sem_init(&empty,0,5);
pthread_create(&tid1,NULL,produce,NULL);
pthread_create(&tid2,NULL,consume,NULL);
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
}

b. Implementation of Readers Writers problem using Semaphores.

//Readers Writers Problem -OS Lab

Program:
#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>

sem_t mutex,writeblock;
int data = 0,rcount = 0;

void *reader(void *arg)


{
int f;
f = ((int)arg);
sem_wait(&mutex);
rcount = rcount + 1;
if(rcount==1)
sem_wait(&writeblock);
sem_post(&mutex);
printf("Data read by the reader%d is %d\n",f,data);
sleep(1);
sem_wait(&mutex);
rcount = rcount - 1;
if(rcount==0)
sem_post(&writeblock);
sem_post(&mutex);
}

void *writer(void *arg)


{
int f;
f = ((int) arg);
sem_wait(&writeblock);
data++;
printf("Data writen by the writer%d is %d\n",f,data);
sleep(1);
sem_post(&writeblock);
}

main()
{
int i,b;
pthread_t rtid[5],wtid[5];
sem_init(&mutex,0,1);
sem_init(&writeblock,0,1);
for(i=0;i<=2;i++)
{
pthread_create(&wtid[i],NULL,writer,(void *)i);
pthread_create(&rtid[i],NULL,reader,(void *)i);
}
for(i=0;i<=2;i++)
{
pthread_join(wtid[i],NULL);
pthread_join(rtid[i],NULL);
}
}
// Dining Philosophers problem
#include<stdio.h>
#include<semaphore.h>
#include<pthread.h>

#define N 5
#define THINKING 0
#define HUNGRY 1
#define EATING 2
#define LEFT (ph_num+4)%N
#define RIGHT (ph_num+1)%N

sem_t mutex;
sem_t S[N];

void * philospher(void *num);


void take_fork(int);
void put_fork(int);
void test(int);
int state[N];
int phil_num[N]={0,1,2,3,4};

int main()
{
int i;
pthread_t thread_id[N];
sem_init(&mutex,0,1);
for(i=0;i<N;i++)
sem_init(&S[i],0,0);
for(i=0;i<N;i++)
{
pthread_create(&thread_id[i],NULL,philospher,&phil_num[i]);
printf("Philosopher %d is thinkingn",i+1);
}
for(i=0;i<N;i++)
pthread_join(thread_id[i],NULL);
}

void *philospher(void *num)


{
while(1)
{
int *i = num;
sleep(1);
take_fork(*i);
sleep(0);
put_fork(*i);
}
}

void take_fork(int ph_num)


{
sem_wait(&mutex);
state[ph_num] = HUNGRY;
printf("Philosopher %d is Hungryn",ph_num+1);
test(ph_num);
sem_post(&mutex);
sem_wait(&S[ph_num]);
sleep(1);
}

void test(int ph_num)


{
if (state[ph_num] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING)
{
state[ph_num] = EATING;
sleep(2);
printf("Philosopher %d takes fork %d and %dn",ph_num+1,LEFT+1,ph_num+1);
printf("Philosopher %d is Eatingn",ph_num+1);
sem_post(&S[ph_num]);
}
}

void put_fork(int ph_num)


{
sem_wait(&mutex);
state[ph_num] = THINKING;
printf("Philosopher %d putting fork %d and %d downn",ph_num+1,LEFT+1,ph_num+1);
printf("Philosopher %d is thinkingn",ph_num+1);
test(LEFT);
test(RIGHT);
sem_post(&mutex);
}

Implement Banker's algorithm for deadlock avoidance.

#include <stdio.h>
int curr[5][5], maxclaim[5][5], avl[5];
int alloc[5] = {0, 0, 0, 0, 0};
int maxres[5], running[5], safe=0;
int count = 0, i, j, exec, r, p, k = 1;

int main()
{
printf("\nEnter the number of processes: ");
scanf("%d", &p);

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


running[i] = 1;
count++;
}
printf("\nEnter the number of resources: ");
scanf("%d", &r);

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


printf("\nEnter the resource for instance %d: ", k++);
scanf("%d", &maxres[i]);
}

printf("\nEnter maximum resource table:\n");


for (i = 0; i < p; i++) {
for(j = 0; j < r; j++) {
scanf("%d", &maxclaim[i][j]);
}
}

printf("\nEnter allocated resource table:\n");


for (i = 0; i < p; i++) {
for(j = 0; j < r; j++) {
scanf("%d", &curr[i][j]);
}
}

printf("\nThe resource of instances: ");


for (i = 0; i < r; i++) {
printf("\t%d", maxres[i]);
}

printf("\nThe allocated resource table:\n");


for (i = 0; i < p; i++) {
for (j = 0; j < r; j++) {
printf("\t%d", curr[i][j]);
}

printf("\n");
}

printf("\nThe maximum resource table:\n");


for (i = 0; i < p; i++) {
for (j = 0; j < r; j++) {
printf("\t%d", maxclaim[i][j]);
}

printf("\n");
}

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


for (j = 0; j < r; j++) {
alloc[j] += curr[i][j];
}
}

printf("\nAllocated resources:");
for (i = 0; i < r; i++) {
printf("\t%d", alloc[i]);
}

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


avl[i] = maxres[i] - alloc[i];
}
printf("\nAvailable resources:");
for (i = 0; i < r; i++) {
printf("\t%d", avl[i]);
}
printf("\n");

//Main procedure goes below to check for unsafe state.


while (count != 0) {
safe = 0;
for (i = 0; i < p; i++) {
if (running[i]) {
exec = 1;
for (j = 0; j < r; j++) {
if (maxclaim[i][j] - curr[i][j] > avl[j]) {
exec = 0;
break;
}
}
if (exec) {
printf("\nProcess%d is executing\n", i + 1);
running[i] = 0;
count--;
safe = 1;

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


avl[j] += curr[i][j];
}
break;
}
}
}
if (!safe) {
printf("\nThe processes are in unsafe state.\n");
break;
} else {
printf("\nThe process is in safe state");
printf("\nSafe sequence is:");

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


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

printf("\n");
}
}
}

You might also like