//1..

Dinning philospher

#include <stdio.h>

#include <pthread.h>

#include <semaphore.h>

#include <unistd.h>

#define N 5 // Number of philosophers

#define THINKING 0

#define HUNGRY 1

#define EATING 2

#define LEFT (ph_num + 4) % N // Left neighbor

#define RIGHT (ph_num + 1) % N // Right neighbor

sem_t mutex; // Semaphore for mutual exclusion

sem_t S[N]; // Semaphore array for each philosopher (for waiting on forks)

int state[N]; // Array to track the state of each philosopher

int phil[N] = {0, 1, 2, 3, 4}; // Philosopher numbers

void test(int ph_num) {

if (state[ph_num] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {

// Philosopher can start eating if neighbors are not eating

state[ph_num] = EATING;

printf("Philosopher %d takes fork %d and %d\n", ph_num + 1, LEFT + 1, ph_num + 1);

printf("Philosopher %d is Eating\n", ph_num + 1);

sleep(2); // Simulating eating

// Signal the philosopher that they can eat

sem_post(&S[ph_num]);

}
void take_fork(int ph_num) {

sem_wait(&mutex); // Lock the mutex

state[ph_num] = HUNGRY;

printf("Philosopher %d is Hungry\n", ph_num + 1);

// Test if this philosopher can eat

test(ph_num);

sem_post(&mutex); // Release the mutex

// Wait if unable to eat

sem_wait(&S[ph_num]);

sleep(1);

void put_fork(int ph_num) {

sem_wait(&mutex); // Lock the mutex

state[ph_num] = THINKING; // Philosopher is thinking

printf("Philosopher %d puts down fork %d and %d\n", ph_num + 1, LEFT + 1, ph_num + 1);

printf("Philosopher %d is Thinking\n", ph_num + 1);

// Test if the left and right neighbors can now eat

test(LEFT);

test(RIGHT);

sem_post(&mutex); // Release the mutex

void* philosopher(void* num) {

while (1) {

int* ph_num = num;

sleep(1); // Thinking
 take_fork(*ph_num); // Trying to eat

sleep(0); // Eating

put_fork(*ph_num); // Done eating, putting down the forks

int main() {

pthread_t thread_id[N];

// Initialize the semaphores

sem_init(&mutex, 0, 1); // Semaphore for mutual exclusion

for (int i = 0; i < N; i++) {

sem_init(&S[i], 0, 0); // Semaphore for each philosopher (initial value 0)

// Create philosopher threads

for (int i = 0; i < N; i++) {

pthread_create(&thread_id[i], NULL, philosopher, &phil[i]);

printf("Philosopher %d is Thinking\n", i + 1);

// Join philosopher threads

for (int i = 0; i < N; i++) {

pthread_join(thread_id[i], NULL);

return 0;

}
//2…FCFS

#include<stdio.h>

void findwaitingtime(int n, int bt[],int at[],int wt[],int tat[]){

int ct[n];

int st[n];

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

if(i == 0){

st[i] = at[i];

else{

if(ct[i-1]>at[i]){

st[i]=ct[i-1];

else{

st[i]=at[i];

ct[i]=st[i]+bt[i];

tat[i]=ct[i]-at[i];

wt[i]=tat[i]-bt[i];

void ganttchartAndAvg(int n,int bt[],int at[]){

int wt[n];

int tat[n];

double twt=0,ttat=0;

findwaitingtime(n,bt,at,wt,tat);

printf("Gantt chart:");

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

printf("P%d", i);

}
 printf("\n");

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

ttat += tat[i];

twt += wt[i];

printf("Average waiting time =%.2f\n",twt/n);

printf("Average turn around time =%.2f\n",ttat/n);

int main(){

int n;

printf("Enter the number of process");

scanf("%d",&n);

int at[n],bt[n];

printf("Enter the arrival times");

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

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

printf("Enter the burst times");

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

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

ganttchartAndAvg(n, bt,at);

return 0;

}
//3…sjf---NP

#include <stdio.h>

#include <stdbool.h>

void findWaitingTime(int n, int bt[], int at[], int wt[],int tat[]){

int completed[n], finish_time[n];

int current_time = 0;

int total_completed = 0;

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

completed[i] = 0;

while (total_completed < n){

int shortest = -1;

int min_bt = 10000;

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

if (at[i] <= current_time && !completed[i] && bt[i] < min_bt){

min_bt = bt[i];

shortest = i;

if (shortest != -1){

current_time += bt[shortest];

finish_time[shortest] = current_time;

wt[shortest] = finish_time[shortest] - at[shortest] - bt[shortest];

if (wt[shortest] < 0){

wt[shortest] = 0;

completed[shortest] = 1;

total_completed++;

else{

current_time++;
 }

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

tat[i] = bt[i] + wt[i];

void findAverageTimes(int n, int bt[], int at[])

int wt[n], tat[n];

int twt = 0, ttat = 0;

findWaitingTime(n, bt, at, wt,tat);

printf("\nProcess\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time\n");

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

twt += wt[i];

ttat += tat[i];

printf("P%d\t\t%d\t\t%d\t\t%d\t\t%d\n", i + 1, bt[i],at[i], wt[i], tat[i]);

float avg_waiting_time = (float)twt / n;

float avg_turnaround_time = (float)ttat / n;

printf("\nAverage Waiting Time: %.2f\n", avg_waiting_time);

printf("Average Turnaround Time: %.2f\n", avg_turnaround_time);

int main() {

int n;

printf("Enter number of processes: ");

scanf("%d", &n);

int bt[n], at[n];

printf("Enter burst time for each process: ");

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

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

printf("Enter arrival time for each process: ");

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

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

findAverageTimes(n, bt, at);

return 0;

//4….producer_consumer

#include <pthread.h>

#include <semaphore.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE];

int in = 0, out = 0;

sem_t empty;

sem_t full;

pthread_mutex_t mutex;

void *producer(void *arg) {

int item;

for (int i = 0; i < 10; i++) {

item = rand() % 100; // Produce a random item

sem_wait(&empty); // Decrement empty semaphore

pthread_mutex_lock(&mutex); // Lock the buffer

buffer[in] = item; // Produce an item

printf("Producer produced: %d\n", item);

in = (in + 1) % BUFFER_SIZE; // Move to the next index

 pthread_mutex_unlock(&mutex); // Unlock the buffer

sem_post(&full); // Increment full semaphore

sleep(1); // Simulate time taken to produce

return NULL;

void *consumer(void *arg) {

int item;

for (int i = 0; i < 10; i++) {

sem_wait(&full); // Decrement full semaphore

pthread_mutex_lock(&mutex); // Lock the buffer

item = buffer[out]; // Consume an item

printf("Consumer consumed: %d\n", item);

out = (out + 1) % BUFFER_SIZE; // Move to the next index

pthread_mutex_unlock(&mutex); // Unlock the buffer

sem_post(&empty); // Increment empty semaphore

sleep(2); // Simulate time taken to consume

return NULL;

int main() {

pthread_t prod_thread, cons_thread;

// Initialize semaphores and mutex

sem_init(&empty, 0, BUFFER_SIZE);

sem_init(&full, 0, 0);

pthread_mutex_init(&mutex, NULL);

// Create producer and consumer threads

pthread_create(&prod_thread, NULL, producer, NULL);

pthread_create(&cons_thread, NULL, consumer, NULL);

// Wait for both threads to finish

pthread_join(prod_thread, NULL);
 pthread_join(cons_thread, NULL);

// Destroy semaphores and mutex

sem_destroy(&empty);

sem_destroy(&full);

pthread_mutex_destroy(&mutex);

return 0;

//5…priority

#include <stdio.h>

int main(){

int n, i, j;

printf("Number of processes: ");

scanf("%d", &n);

int burst_time[n], arrival_time[n], priority[n], process[n];

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

process[i] = i;

printf("Enter burst time, arrival time and priority of P%d: ", i);

scanf("%d %d %d", &burst_time[i], &arrival_time[i], &priority[i]);

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

for (j = i + 1; j < n; j++) {

if (priority[i] > priority[j]) {

int temp = priority[i];

priority[i] = priority[j];

priority[j] = temp;

temp = burst_time[i];

burst_time[i] = burst_time[j];

burst_time[j] = temp;
 temp = arrival_time[i];

arrival_time[i] = arrival_time[j];

arrival_time[j] = temp;

temp = process[i];

process[i] = process[j];

process[j] = temp;

int waiting_time[n], turnaround_time[n];

waiting_time[0] = 0;

turnaround_time[0] = burst_time[0];

for (i = 1; i < n; i++) {

waiting_time[i] = waiting_time[i - 1] + burst_time[i - 1];

turnaround_time[i] = waiting_time[i] + burst_time[i];

printf("Gantt Chart: ");

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

printf("P%d ", process[i]);

printf("\n");

float avg_waiting_time = 0, avg_turnaround_time = 0;

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

avg_waiting_time += waiting_time[i];

avg_turnaround_time += turnaround_time[i];

printf("Average waiting time: %.2f\n", avg_waiting_time/n);

printf("Average turnaround time: %.2f\n", avg_turnaround_time/n);

return 0;

}
//6….bankers algo

#include <stdio.h>

#define MAX 10

void calculateNeed(int need[MAX][MAX], int max[MAX][MAX], int alloc[MAX][MAX], int n, int m) {

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

for (int j = 0; j < m; j++) {

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

int isSafe(int alloc[MAX][MAX], int max[MAX][MAX], int avail[MAX], int n, int m) {

int need[MAX][MAX];

calculateNeed(need, max, alloc, n, m);

int f[MAX] = {0};

int ans[MAX];

int ind = 0;

for (int k = 0; k < n; k++) {

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

if (f[i] == 0) {

int flag = 0;

for (int j = 0; j < m; j++) {

if (need[i][j] > avail[j]) {

flag = 1;

break;

if (flag == 0) {

ans[ind++] = i;

for (int y = 0; y < m; y++) {

avail[y] += alloc[i][y];

}
 f[i] = 1;

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

if (f[i] == 0) {

printf("The following system is not safe\n");

return 0;

printf("Following is the SAFE Sequence\n");

for (int i = 0; i < n - 1; i++) {

printf(" P%d ->", ans[i]);

printf(" P%d\n", ans[n - 1]);

return 1;

int main() {

int n, m;

printf("Enter number of processes: ");

scanf("%d", &n);

printf("Enter number of resources: ");

scanf("%d", &m);

int alloc[MAX][MAX], max[MAX][MAX], avail[MAX];

printf("Enter Allocation Matrix:\n");

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

for (int j = 0; j < m; j++) {

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

}
 printf("Enter MAX Matrix:\n");

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

for (int j = 0; j < m; j++) {

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

printf("Enter Available Resources:\n");

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

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

isSafe(alloc, max, avail, n, m);

return 0;

// 7….. round robin

#include<stdio.h>

#include<conio.h>

#define max 30

int main(){

int n,i,j,temp,sq=0,tq,count=0;

int at[max],bt[max],ct[max],tat[max],wt[max],rem_bt[max] ;

float awt = 0 , atat =0;

printf("Enter the number of process : ");

scanf("%d",&n);

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

printf("Enter the Arrival and Burst time of process %d : ",i+1);

scanf("%d%d",&at[i],&bt[i]);

rem_bt[i] = bt[i];
 }

printf("Enter Time Quantum : ");

scanf("%d",&tq);

while(count < n){

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

if(rem_bt[i] == 0){

continue;

if(rem_bt[i] > tq){

rem_bt[i] -= tq;

sq += tq;

else{

sq += rem_bt[i];

rem_bt[i] = 0;

ct[i] = sq;

count++;

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

tat[i] = ct[i] - at[i];

wt[i] = tat[i] - bt[i];

awt += wt[i];

atat += tat[i];

printf("Process\tArrival Time\tBurst Time\tCompletion Time\tTurn Around Time\tWaiting

Time\n");
 for(i=0 ; i<n ; i++){

printf("%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n",i+1,at[i],bt[i],ct[i],tat[i],wt[i]);

awt = awt/n;

atat = atat/n;

printf("Average Waiting Time = %f\n",awt);

printf("Average Turn Around Time = %f",atat);

return 0;

// 8 inter process through pipe

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

int main() {

int pipefds[2];

pid_t pid;

char write_msg[] = "Hello from Parent!";

char read_msg[50];

// Create the pipe

if (pipe(pipefds) == -1) {

perror("pipe");

exit(EXIT_FAILURE);

// Fork a child process

pid = fork();
if (pid == -1) {

perror("fork");

exit(EXIT_FAILURE);

if (pid == 0) { // Child process

// Close the write end of the pipe

close(pipefds[1]);

// Read the message from the parent

read(pipefds[0], read_msg, sizeof(read_msg));

printf("Child received: %s\n", read_msg);

// Close the read end of the pipe

close(pipefds[0]);

} else { // Parent process

// Close the read end of the pipe

close(pipefds[0]);

// Write the message to the child

write(pipefds[1], write_msg, strlen(write_msg) + 1);

printf("Parent sent: %s\n", write_msg);

// Close the write end of the pipe

close(pipefds[1]);

// Wait for the child process to finish

wait(NULL);

return 0;}
//…sjf preemtive…9

#include <stdio.h>

#define MAX 100

struct Process {

int id; // Process ID

int at; // Arrival Time

int bt; // Burst Time

int rt; // Remaining Time

int ct; // Completion Time

int wt; // Waiting Time

int tat; // Turnaround Time

};

int main() {

int n, total = 0, completed = 0, current_time = 0, min_rt, shortest;

float avg_wt = 0, avg_tat = 0;

struct Process p[MAX];

// Input: number of processes

printf("Enter the number of processes: ");

scanf("%d", &n);

// Input: arrival time and burst time of each process

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

printf("Enter Arrival Time and Burst Time for Process %d: ", i + 1);

scanf("%d %d", &p[i].at, &p[i].bt);

p[i].id = i + 1; // Process ID

p[i].rt = p[i].bt; // Initialize remaining time with burst time

}
// Start processing with SJF Preemptive

while (completed != n) {

// Find the process with the shortest remaining time that has arrived

shortest = -1;

min_rt = MAX;

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

if (p[i].at <= current_time && p[i].rt > 0 && p[i].rt < min_rt) {

min_rt = p[i].rt;

shortest = i;

if (shortest == -1) {

current_time++; // No process is ready to execute, so just increment time

continue;

// Execute the selected process

p[shortest].rt--;

current_time++;

// If the process finishes executing

if (p[shortest].rt == 0) {

completed++;

p[shortest].ct = current_time; // Completion time

p[shortest].tat = p[shortest].ct - p[shortest].at; // Turnaround time

p[shortest].wt = p[shortest].tat - p[shortest].bt; // Waiting time

avg_wt += p[shortest].wt;
 avg_tat += p[shortest].tat;

// Print the results

printf("\nProcess\tArrival Time\tBurst Time\tCompletion Time\tTurnaround Time\tWaiting Time\

n");

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

printf("P%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", p[i].id, p[i].at, p[i].bt, p[i].ct, p[i].tat, p[i].wt);

avg_wt /= n;

avg_tat /= n;

printf("\nAverage Waiting Time = %.2f", avg_wt);

printf("\nAverage Turnaround Time = %.2f\n", avg_tat);

return 0;

// 10 …Write a C program to simulate multi-level queue scheduling algorithm considering the

following scenario: all the processes in the system are divided into two categories – system processes
and user processes. System processes are to be given higher priority than user processes. Use FCFS
scheduling for the processes in each queue.

#include <stdio.h>

#define MAX 100

// Structure to represent a process

struct Process {

int id; // Process ID

int at; // Arrival Time

int bt; // Burst Time

int ct; // Completion Time

 int wt; // Waiting Time

int tat; // Turnaround Time

int isSystemProcess; // Flag to indicate if the process is a system process (1 for system, 0 for user)

};

// Function to sort processes by arrival time (FCFS)

void sortByArrival(struct Process p[], int n) {

struct Process temp;

for (int i = 0; i < n - 1; i++) {

for (int j = i + 1; j < n; j++) {

if (p[i].at > p[j].at) {

temp = p[i];

p[i] = p[j];

p[j] = temp;

// Function to calculate completion, turnaround, and waiting time

void calculateTimes(struct Process p[], int n) {

int currentTime = 0;

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

if (currentTime < p[i].at) {

currentTime = p[i].at;

p[i].ct = currentTime + p[i].bt; // Completion time

p[i].tat = p[i].ct - p[i].at; // Turnaround time

p[i].wt = p[i].tat - p[i].bt; // Waiting time

currentTime = p[i].ct; // Update current time

}
}

// Function to simulate multi-level queue scheduling

void multiLevelQueueScheduling(struct Process p[], int n) {

// Separate system and user processes into two queues

struct Process systemQueue[MAX], userQueue[MAX];

int systemCount = 0, userCount = 0;

// Classify the processes

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

if (p[i].isSystemProcess == 1) {

systemQueue[systemCount++] = p[i];

} else {

userQueue[userCount++] = p[i];

// Sort both queues by arrival time (FCFS scheduling)

sortByArrival(systemQueue, systemCount);

sortByArrival(userQueue, userCount);

// Process the system queue first (higher priority)

printf("\nScheduling system processes (higher priority):\n");

calculateTimes(systemQueue, systemCount);

printf("ID\tAT\tBT\tCT\tTAT\tWT\n");

for (int i = 0; i < systemCount; i++) {

printf("P%d\t%d\t%d\t%d\t%d\t%d\n", systemQueue[i].id, systemQueue[i].at,

systemQueue[i].bt, systemQueue[i].ct, systemQueue[i].tat, systemQueue[i].wt);

// Process the user queue next (lower priority)

 printf("\nScheduling user processes (lower priority):\n");

calculateTimes(userQueue, userCount);

printf("ID\tAT\tBT\tCT\tTAT\tWT\n");

for (int i = 0; i < userCount; i++) {

printf("P%d\t%d\t%d\t%d\t%d\t%d\n", userQueue[i].id, userQueue[i].at, userQueue[i].bt,

userQueue[i].ct, userQueue[i].tat, userQueue[i].wt);

int main() {

int n;

struct Process p[MAX];

// Input: number of processes

printf("Enter number of processes: ");

scanf("%d", &n);

// Input: arrival time, burst time, and process type for each process

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

printf("Enter Arrival Time and Burst Time for Process %d: ", i + 1);

scanf("%d %d", &p[i].at, &p[i].bt);

printf("Enter 1 if Process %d is a System Process, otherwise enter 0: ", i + 1);

scanf("%d", &p[i].isSystemProcess);

p[i].id = i + 1; // Assign process ID

// Simulate the multi-level queue scheduling

multiLevelQueueScheduling(p, n);

return 0;