Scribd
Upload
5 views6 pages

Peterson Deadlockavoidance

Peterson's Solution for Deadlock Avoidance

Uploaded by

Utkarsh Varman
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
5 views6 pages

Peterson Deadlockavoidance

Peterson's Solution for Deadlock Avoidance

Uploaded by

Utkarsh Varman
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/ 6

Operating Systems Lab (BCSE303P)

Faculty - Dr. Vallidevi K


Lab – 7a

Register No. 21BLC1030


Name: Utkarsh Varman
Date: 08/03/2024
Experiment: - Handling Critical Section without Deadlocks using Peterson’s Solution
Write a C program to implement Producer and Consumer problem using Peterson's Solution.

Code:

// C program to implement Peterson’s Algorithm


// for producer-consumer problem.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdbool.h>
#define _BSD_SOURCE
#include <sys/time.h>

#define BSIZE 8 // Buffer size


#define PWT 2 // Producer wait time limit
#define CWT 10 // Consumer wait time limit
#define RT 10 // Program run-time in seconds

int shmid1, shmid2, shmid3, shmid4;


key_t k1 = 5491, k2 = 5812, k3 = 4327, k4 = 3213;
bool* SHM1;
int* SHM2;
int* SHM3;

int myrand(int n) // Returns a random number between 1 and n


{
time_t t;
srand((unsigned)time(&t));
return (rand() % n + 1);
}

int main()
{
shmid1 = shmget(k1, sizeof(bool) * 2, IPC_CREAT | 0660); // flag
shmid2 = shmget(k2, sizeof(int) * 1, IPC_CREAT | 0660); // turn
shmid3 = shmget(k3, sizeof(int) * BSIZE, IPC_CREAT | 0660); // buffer
shmid4 = shmget(k4, sizeof(int) * 1, IPC_CREAT | 0660); // time stamp
if (shmid1 < 0 || shmid2 < 0 || shmid3 < 0 || shmid4 < 0) {
perror("Main shmget error: ");
exit(1);
}
SHM3 = (int*)shmat(shmid3, NULL, 0);
int ix = 0;
while (ix < BSIZE) // Initializing buffer
SHM3[ix++] = 0;

struct timeval t;
time_t t1, t2;
gettimeofday(&t, NULL);
t1 = t.tv_sec;

int* state = (int*)shmat(shmid4, NULL, 0);


*state = 1;
int wait_time;

int i = 0; // Consumer
int j = 1; // Producer

if (fork() == 0) // Producer code


{
SHM1 = (bool*)shmat(shmid1, NULL, 0);
SHM2 = (int*)shmat(shmid2, NULL, 0);
SHM3 = (int*)shmat(shmid3, NULL, 0);
if (SHM1 == (bool*)-1 || SHM2 == (int*)-1 || SHM3 == (int*)-1) {
perror("Producer shmat error: ");
exit(1);
}

bool* flag = SHM1;


int* turn = SHM2;
int* buf = SHM3;
int index = 0;

while (*state == 1) {
flag[j] = true;
printf("Producer is ready now.\n\n");
*turn = i;
while (flag[i] == true && *turn == i)
;

// Critical Section Begin


index = 0;
while (index < BSIZE) {
if (buf[index] == 0) {
int tempo = myrand(BSIZE * 3);
printf("Job %d has been produced\n", tempo);
buf[index] = tempo;
break;
}
index++;
}
if (index == BSIZE)
printf("Buffer is full, nothing can be produced!!!\n");
printf("Buffer: ");
index = 0;
while (index < BSIZE)
printf("%d ", buf[index++]);
printf("\n");
// Critical Section End

flag[j] = false;
if (*state == 0)
break;
wait_time = myrand(PWT);
printf("Producer will wait for %d seconds\n\n", wait_time);
sleep(wait_time);
}
exit(0);
}

if (fork() == 0) // Consumer code


{
SHM1 = (bool*)shmat(shmid1, NULL, 0);
SHM2 = (int*)shmat(shmid2, NULL, 0);
SHM3 = (int*)shmat(shmid3, NULL, 0);
if (SHM1 == (bool*)-1 || SHM2 == (int*)-1 || SHM3 == (int*)-1) {
perror("Consumer shmat error:");
exit(1);
}

bool* flag = SHM1;


int* turn = SHM2;
int* buf = SHM3;
int index = 0;
flag[i] = false;
sleep(5);
while (*state == 1) {
flag[i] = true;
printf("Consumer is ready now.\n\n");
*turn = j;
while (flag[j] == true && *turn == j)
;

// Critical Section Begin


if (buf[0] != 0) {
printf("Job %d has been consumed\n", buf[0]);
buf[0] = 0;
index = 1;

while (index < BSIZE) // Shifting remaining jobs forward


{
buf[index - 1] = buf[index];
index++;
}
buf[index - 1] = 0;
}

else
printf("Buffer is empty, nothing can be consumed!!!\n");
printf("Buffer: ");
index = 0;
while (index < BSIZE)
printf("%d ", buf[index++]);
printf("\n");
// Critical Section End

flag[i] = false;
if (*state == 0)
break;
wait_time = myrand(CWT);
printf("Consumer will sleep for %d seconds\n\n", wait_time);
sleep(wait_time);
}
exit(0);
}

// Parent process will now for RT seconds before causing child to terminate
while (1) {
gettimeofday(&t, NULL);
t2 = t.tv_sec;
if (t2 - t1 > RT) // Program will exit after RT seconds
{
*state = 0;
break;
}
}

// Waiting for both processes to exit


wait();
wait();
printf("The clock ran out.\n");

return 0;

}
Output:
Result/Conclusion:
We have implemented the C program for Peterson's Algorithm to solve the producer-consumer
problem using shared memory and processes on Ubuntu operating system. In this problem
processes share a common, fixed-size buffer in synchronization.

1. Shared memory segments are created for boolean flags, turn variable, buffer, and a time
stamp. The producer and consumer processes are created using fork().

2. The producer and consumer processes use Peterson's Algorithm for mutual exclusion to
access the shared buffer.

3. The producer generates random jobs and adds them to the buffer while the consumer
consumes jobs from the buffer.

4. The program runs for a specified duration (RT) and then signals the processes to terminate.
The parent process waits for both child processes to exit before printing a concluding
message.

You might also like