RAKSHIT GUPTA

20BCE0824

OS LAB DA;

DISK SCHEDULING;
#include<stdio.h>
#include<stdbool.h>
int request[50];
long SIZE;
bool flag[50];
int dist(int,int);
struct max{
int data;
int dis;
int dat;
}kate[50],kat;
struct max check(int head,int n)
{
int i;
int j=0;
for(i=0;i<n;i++)
{
if(flag[i]==0){
kate[j].dis=dist(head,request[i]);
kate[j].data=request[i];
kate[j].dat=i;
j++;
}
}
n=j;
for (i = 0; i < n-1; i++)
{
for (j = 0; j < n-i-1; j++)
{
if (kate[j].dis > kate[j+1].dis)
{
int temp=kate[j].data;
kate[j].data=kate[j+1].data;
kate[j+1].data=temp;
temp=kate[j].dis;
kate[j].dis=kate[j+1].dis;
kate[j+1].dis=temp;
temp=kate[j].dat;
kate[j].dat=kate[j+1].dat;
kate[j+1].dat=temp;
}
}
}
return kate[0];
}
int dist(int a,int b)
{
if(a>b)
return a-b;
return b-a;
}
void stsk(int n)
{
int head,i;
int seekcount=0;
printf("ENTER THE CURRENT HEAD :\n");
scanf("%d",&head);
printf("SEEK SEQUENCE = ") ;
for(i=0;i<n;i++)
{
if(request[i]<SIZE-1)
{
printf("%d ",head);
kat=check(head,n);
seekcount=seekcount+kat.dis;
head=kat.data;
flag[kat.dat]=true;
}
}
printf("%d\nTOTAL DISTANCE : %d",head,seekcount);
}
int main()
{
int n,i;
printf("ENTER THE DISK SIZE :\n");
scanf("%d",&SIZE);
printf("ENTER THE NO OF REQUEST SEQUENCE :\n");
scanf("%d",&n);
printf("ENTER THE REQUEST SEQUENCE :\n");
for(i=0;i<n;i++){
scanf("%d",&request[i]);
flag[i]=0;
}
stsk(n);
}

OUTPUT;
Code1; ( producer consumer)
#include <pthread.h>

#include <semaphore.h>

#include <stdlib.h>

#include <stdio.h>

#define MaxItems 5 // Maximum items a producer can produce or a consumer can consume

#define BufferSize 5 // Size of the buffer

sem_t empty;

sem_t full;

int in = 0;

int out = 0;

int buffer[BufferSize];

pthread_mutex_t mutex;

void *producer(void *pno)

int item;

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

item = rand(); // Produce an random item

sem_wait(&empty);
 pthread_mutex_lock(&mutex);

buffer[in] = item;

printf("Producer %d: Insert Item %d at %d\n", *((int *)pno),buffer[in],in);

in = (in+1)%BufferSize;

pthread_mutex_unlock(&mutex);

sem_post(&full);

void *consumer(void *cno)

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

sem_wait(&full);

pthread_mutex_lock(&mutex);

int item = buffer[out];

printf("Consumer %d: Remove Item %d from %d\n",*((int *)cno),item, out);

out = (out+1)%BufferSize;

pthread_mutex_unlock(&mutex);

sem_post(&empty);

int main()

pthread_t pro[5],con[5];

pthread_mutex_init(&mutex, NULL);

sem_init(&empty,0,BufferSize);

sem_init(&full,0,0);
 int a[5] = {1,2,3,4,5}; //Just used for numbering the producer and consumer

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

pthread_create(&pro[i], NULL, (void *)producer, (void *)&a[i]);

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

pthread_create(&con[i], NULL, (void *)consumer, (void *)&a[i]);

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

pthread_join(pro[i], NULL);

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

pthread_join(con[i], NULL);

pthread_mutex_destroy(&mutex);

sem_destroy(&empty);

sem_destroy(&full);

return 0;

Code2: ( Dining Philosopher problem)

#include <pthread.h>

#include <semaphore.h>

#include <stdio.h>

#define N 5

#define THINKING 2

#define HUNGRY 1

#define EATING 0

#define LEFT (phnum + 4) % N

#define RIGHT (phnum + 1) % N

int state[N];

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

sem_t mutex;

sem_t S[N];

void test(int phnum)

if (state[phnum] == HUNGRY

&& state[LEFT] != EATING

&& state[RIGHT] != EATING) {

// state that eating

state[phnum] = EATING;

sleep(2);

printf("Philosopher %d takes fork %d and %d\n",

 phnum + 1, LEFT + 1, phnum + 1);

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

// sem_post(&S[phnum]) has no effect

// during takefork

// used to wake up hungry philosophers

// during putfork

sem_post(&S[phnum]);

// take up chopsticks

void take_fork(int phnum)

sem_wait(&mutex);

// state that hungry

state[phnum] = HUNGRY;

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

// eat if neighbours are not eating

test(phnum);

sem_post(&mutex);

// if unable to eat wait to be signalled

 sem_wait(&S[phnum]);

sleep(1);

// put down chopsticks

void put_fork(int phnum)

sem_wait(&mutex);

// state that thinking

state[phnum] = THINKING;

printf("Philosopher %d putting fork %d and %d down\n",

phnum + 1, LEFT + 1, phnum + 1);

printf("Philosopher %d is thinking\n", phnum + 1);

test(LEFT);

test(RIGHT);

sem_post(&mutex);

void* philosopher(void* num)

while (1) {
 int* i = num;

sleep(1);

take_fork(*i);

sleep(0);

put_fork(*i);

int main()

int i;

pthread_t thread_id[N];

// initialize the semaphores

sem_init(&mutex, 0, 1);

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

sem_init(&S[i], 0, 0);

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

// create philosopher processes

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

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

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

pthread_join(thread_id[i], NULL);

Code3;

#include<stdio.h>

int n,nf;

int in[100];

int p[50];

int hit=0;

int i,j,k;

int pgfaultcnt=0;

void getData()

printf("\nEnter length of page reference sequence:");

scanf("%d",&n);

printf("\nEnter the page reference sequence:");

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

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

printf("\nEnter no of frames:");
 scanf("%d",&nf);

void initialize()

pgfaultcnt=0;

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

p[i]=9999;

int isHit(int data)

hit=0;

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

if(p[j]==data)

hit=1;

break;

return hit;

int getHitIndex(int data)

int hitind;
 for(k=0; k<nf; k++)

if(p[k]==data)

hitind=k;

break;

return hitind;

void dispPages()

for (k=0; k<nf; k++)

if(p[k]!=9999)

printf(" %d",p[k]);

void dispPgFaultCnt()

printf("\nTotal no of page faults:%d",pgfaultcnt);

void fifo()

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

printf("\nFor %d :",in[i]);

if(isHit(in[i])==0)

for(k=0; k<nf-1; k++)

p[k]=p[k+1];

p[k]=in[i];

pgfaultcnt++;

dispPages();

else

printf("No page fault");

dispPgFaultCnt();

void optimal()

initialize();

int near[50];

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

printf("\nFor %d :",in[i]);
if(isHit(in[i])==0)

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

int pg=p[j];

int found=0;

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

if(pg==in[k])

near[j]=k;

found=1;

break;

else

found=0;

if(!found)

near[j]=9999;

int max=-9999;

int repindex;

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

if(near[j]>max)

max=near[j];
 repindex=j;

p[repindex]=in[i];

pgfaultcnt++;

dispPages();

else

printf("No page fault");

dispPgFaultCnt();

void lru()

initialize();

int least[50];

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

printf("\nFor %d :",in[i]);

if(isHit(in[i])==0)

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

{
 int pg=p[j];

int found=0;

for(k=i-1; k>=0; k--)

if(pg==in[k])

least[j]=k;

found=1;

break;

else

found=0;

if(!found)

least[j]=-9999;

int min=9999;

int repindex;

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

if(least[j]<min)

min=least[j];

repindex=j;

p[repindex]=in[i];

pgfaultcnt++;
 dispPages();

else

printf("No page fault!");

dispPgFaultCnt();

void lfu()

int usedcnt[100];

int least,repin,sofarcnt=0,bn;

initialize();

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

usedcnt[i]=0;

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

printf("\n For %d :",in[i]);

if(isHit(in[i]))

int hitind=getHitIndex(in[i]);

usedcnt[hitind]++;

printf("No page fault!");

else

pgfaultcnt++;
 if(bn<nf)

p[bn]=in[i];

usedcnt[bn]=usedcnt[bn]+1;

bn++;

else

least=9999;

for(k=0; k<nf; k++)

if(usedcnt[k]<least)

least=usedcnt[k];

repin=k;

p[repin]=in[i];

sofarcnt=0;

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

if(in[i]==in[k])

sofarcnt=sofarcnt+1;

usedcnt[repin]=sofarcnt;

dispPages();

dispPgFaultCnt();

}
void secondchance()

int usedbit[50];

int victimptr=0;

initialize();

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

usedbit[i]=0;

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

printf("\nFor %d:",in[i]);

if(isHit(in[i]))

printf("No page fault!");

int hitindex=getHitIndex(in[i]);

if(usedbit[hitindex]==0)

usedbit[hitindex]=1;

else

pgfaultcnt++;

if(usedbit[victimptr]==1)

do

usedbit[victimptr]=0;

victimptr++;

if(victimptr==nf)

victimptr=0;
 }

while(usedbit[victimptr]!=0);

if(usedbit[victimptr]==0)

p[victimptr]=in[i];

usedbit[victimptr]=1;

victimptr++;

dispPages();

if(victimptr==nf)

victimptr=0;

dispPgFaultCnt();

int main()

int choice;

while(1)

printf("\nPage Replacement Algorithms\n1.Enter

data\n2.FIFO\n3.Optimal\n4.LRU\n5.LFU\n6.Second Chance\n7.Exit\nEnter your choice:");

scanf("%d",&choice);

switch(choice)

case 1:
 getData();

break;

case 2:

fifo();

break;

case 3:

optimal();

break;

case 4:

lru();

break;

case 5:

lfu();

break;

case 6:

secondchance();

break;

default:

return 0;

break;