all programes

FCFS-CPU SCHEDULING
//FCFS                                                                                                         #include<stdio.h>
int main(void)
{
      int n,at[10],bt[10],ct[10],tat[10],wt[10],sum,i,j,k;
      float totaltat=0,totalwt=0;
      printf("Enter No of processors:");
      scanf(" %d",&n);
      for(i=0;i<n;i++)
      {
            printf("Enter the arrival time of processor %d:",i+1);
            scanf(" %d",&at[i]);
      }
      for(i=0;i<n;i++)
      {
            printf("Enter the burst time of processor %d:",i+1);
            scanf(" %d",&bt[i]);
      }
      //Calculation of completion times for each processor
      sum=at[0];
      for(j=0;j<n;j++)
      {
            sum=sum+bt[j];
            ct[j]=sum;
      }
      //Calculation of turn around time
      for(k=0;k<n;k++)
      {
            tat[k]=ct[k]-at[k];
            totaltat=totaltat+tat[k];
      }
      //Calculation of waiting time
      for(i=0;i<n;i++)
      {
            wt[i]=tat[i]-bt[i];
            totalwt=totalwt+wt[i];
      }
      printf("Process\tAT\tBT\tCT\tTAT\tWt\n");
      for(i=0;i<n;i++)
      {
            printf("\nP%d\t%d\t%d\t%d\t%d\t%d\t\n",i+1,at[i],bt[i],ct[i],tat[i],wt[i]);
      }
      printf("average of turn around time:%0.1f\n",totaltat/n);
      printf("average of waiting time:%0.1f\n",totalwt/n);
      return 0;
}
SJF-NON PREEMPTIVE
#include <stdio.h>

int main() {
    int n, i, j, temp, time = 0, count, completed = 0, sum_wait = 0, sum_turnaround = 0, start;
    float avg_wait, avg_turnaround;
    int at[10], bt[10], p[10]; // Arrays for arrival times, burst times, and process numbers

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    // Input arrival times and burst times for each process
    for (i = 0; i < n; i++) {
        printf("Enter the arrival time and burst time for process %d: ", i + 1);
        scanf("%d%d", &at[i], &bt[i]);
        p[i] = i + 1;
    }

    // Sort processes by arrival times, and then by burst times
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (at[i] > at[j] || (at[i] == at[j] && bt[i] > bt[j])) {
                temp = at[i];
                at[i] = at[j];
                at[j] = temp;
                temp = bt[i];
                bt[i] = bt[j];
                bt[j] = temp;
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }

    printf("\nProcess\tAT\tBT\tWT\tTAT\n");

    // Main loop to calculate waiting times and turnaround times
    while (completed < n) {
        count = 0;
        for (i = completed; i < n; i++) {
            if (at[i] <= time) {
                count++;
            } else {
                break;
            }
        }

        // Sort the ready processes by burst time
        if (count > 1) {
            for (i = completed; i < completed + count - 1; i++) {
                for (j = i + 1; j < completed + count; j++) {
                    if (bt[i] > bt[j]) {
                        temp = at[i];
                        at[i] = at[j];
                        at[j] = temp;
                        temp = bt[i];
                        bt[i] = bt[j];
                        bt[j] = temp;
                        temp = p[i];
                        p[i] = p[j];
                        p[j] = temp;
                    }
                }
            }
        }

        start = time;
        time += bt[completed];
        printf("P[%d]\t%d\t%d\t%d\t%d\n", p[completed], at[completed], bt[completed], time - at[completed] - bt[completed], time - at[completed]);
        sum_wait += time - at[completed] - bt[completed];
        sum_turnaround += time - at[completed];
        completed++;
    }

    avg_wait = (float)sum_wait / (float)n;
    avg_turnaround = (float)sum_turnaround / (float)n;

    printf("Average waiting time is %.2f\n", avg_wait);
    printf("Average turnaround time is %.2f\n", avg_turnaround);

    return 0;
}
SRTF(SJF-PREEMPTIVE)
#include <stdio.h>

int main() {
    int n, i, j, min_bt, time = 0, completed = 0, sum_wait = 0, sum_turnaround = 0;
    int at[10], bt[10], rt[10], p[10]; // Arrays for arrival times, burst times, remaining times, and process numbers
    int wait[10], turnaround[10]; // Arrays for waiting times and turnaround times
    float avg_wait, avg_turnaround;

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    // Input arrival times and burst times for each process
    for (i = 0; i < n; i++) {
        printf("Enter the arrival time and burst time for process %d: ", i + 1);
        scanf("%d%d", &at[i], &bt[i]);
        rt[i] = bt[i]; // Initialize remaining time as burst time
        p[i] = i + 1; // Process numbers
    }

    // Initialize arrays for waiting and turnaround times
    for (i = 0; i < n; i++) {
        wait[i] = 0;
        turnaround[i] = 0;
    }

    printf("\nProcess\tAT\tBT\tWT\tTAT\n");

    while (completed != n) {
        // Find process with minimum remaining time at each time unit
        min_bt = 9999; // A large number to find the minimum burst time
        int shortest = -1; // Index of the process with the shortest remaining time

        for (i = 0; i < n; i++) {
            if (at[i] <= time && rt[i] > 0 && rt[i] < min_bt) {
                min_bt = rt[i];
                shortest = i;
            }
        }

        if (shortest == -1) {
            // No process is currently available to execute
            time++;
            continue;
        }

        rt[shortest]--; // Decrement the remaining time of the shortest process

        if (rt[shortest] == 0) {
            // Process is completed
            completed++;
            int end_time = time + 1; // Time at which the process completes
            turnaround[shortest] = end_time - at[shortest]; // Turnaround time
            wait[shortest] = turnaround[shortest] - bt[shortest]; // Waiting time
            sum_wait += wait[shortest];
            sum_turnaround += turnaround[shortest];

            printf("P[%d]\t%d\t%d\t%d\t%d\n", p[shortest], at[shortest], bt[shortest], wait[shortest], turnaround[shortest]);
        }

        time++; // Increment time
    }

    avg_wait = (float)sum_wait / (float)n;
    avg_turnaround = (float)sum_turnaround / (float)n;

    printf("Average waiting time is %.2f\n", avg_wait);
    printf("Average turnaround time is %.2f\n", avg_turnaround);

    return 0;
}


ROUND ROBIN PROGRAM
#include <stdio.h>

int main() {
    int n, tq, i, total_time = 0, time = 0, flag = 0;
    int bt[10], rem_bt[10], wt[10], tat[10]; // Burst times, remaining burst times, waiting times, turnaround times
    float avg_wt = 0, avg_tat = 0;

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    printf("Enter the burst time for each process:\n");
    for (i = 0; i < n; i++) {
        printf("P[%d]: ", i + 1);
        scanf("%d", &bt[i]);
        rem_bt[i] = bt[i]; // Initialize remaining burst time as burst time
    }

    printf("Enter the time quantum: ");
    scanf("%d", &tq);

    while (1) {
        flag = 0;
        for (i = 0; i < n; i++) {
            if (rem_bt[i] > 0) {
                flag = 1; // There is a pending process

                if (rem_bt[i] > tq) {
                    time += tq;
                    rem_bt[i] -= tq;
                } else {
                    time += rem_bt[i];
                    wt[i] = time - bt[i]; // Waiting time is current time minus burst time
                    rem_bt[i] = 0;
                }
            }
        }
        
        if (flag == 0) // All processes are done
            break;
    }

    printf("\nProcess\tBT\tWT\tTAT\n");
    for (i = 0; i < n; i++) {
        tat[i] = bt[i] + wt[i]; // Turnaround time is burst time plus waiting time
        avg_wt += wt[i];
        avg_tat += tat[i];
        printf("P[%d]\t%d\t%d\t%d\n", i + 1, bt[i], wt[i], tat[i]);
    }

    avg_wt /= n;
    avg_tat /= n;

    printf("\nAverage Waiting Time: %.2f", avg_wt);
    printf("\nAverage Turnaround Time: %.2f", avg_tat);

    return 0;
}
PRIORITY PROGRAM
#include <stdio.h>

int main() {
    int n, i, j, temp, sum_wait = 0, sum_turnaround = 0;
    float avg_wait, avg_turnaround;
    int priority[20], bt[20], wt[20], tat[20];

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    // Input burst times and priorities for each process
    printf("Enter burst times and priorities for each process:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d: ", i + 1);
        scanf("%d%d", &bt[i], &priority[i]);
    }

    // Sort processes based on priority (ascending order)
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (priority[i] > priority[j]) {
                temp = priority[i];
                priority[i] = priority[j];
                priority[j] = temp;
                temp = bt[i];
                bt[i] = bt[j];
                bt[j] = temp;
            }
        }
    }

    // Calculate waiting time for each process
    wt[0] = 0; // Waiting time for first process is zero
    for (i = 1; i < n; i++) {
        wt[i] = wt[i - 1] + bt[i - 1];
        sum_wait += wt[i];
    }

    // Calculate turnaround time for each process
    for (i = 0; i < n; i++) {
        tat[i] = wt[i] + bt[i];
        sum_turnaround += tat[i];
    }

    // Calculate average waiting time and average turnaround time
    avg_wait = (float)sum_wait / n;
    avg_turnaround = (float)sum_turnaround / n;

    // Print process details
    printf("\nProcess\tBT\tPriority\tWT\tTAT\n");
    for (i = 0; i < n; i++) {
        printf("P%d\t%d\t%d\t\t%d\t%d\n", i + 1, bt[i], priority[i], wt[i], tat[i]);
    }

    // Print average waiting time and average turnaround time
    printf("\nAverage Waiting Time: %.2f\n", avg_wait);
    printf("Average Turnaround Time: %.2f\n", avg_turnaround);

    return 0;
}
BANKERS ALGORITHM
#include <stdio.h>
int main() {
    int n, m, i, j, k;

    // Get the number of processes and resources from the user
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    printf("Enter the number of resources: ");
    scanf("%d", &m);

    int alloc[n][m], max[n][m], avail[m];

    // Get the Allocation Matrix from the user
    printf("Enter the Allocation Matrix:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d:\n", i);
        for (j = 0; j < m; j++) {
            scanf("%d", &alloc[i][j]);
        }
    }

    // Get the Maximum Matrix from the user
    printf("Enter the Maximum Matrix:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d:\n", i);
        for (j = 0; j < m; j++) {
            scanf("%d", &max[i][j]);
        }
    }

    // Get the Available Resources from the user
    printf("Enter the Available Resources:\n");
    for (i = 0; i < m; i++) {
        scanf("%d", &avail[i]);
    }

    int f[n], ans[n], ind = 0;
    for (k = 0; k < n; k++) {
        f[k] = 0;
    }

    int need[n][m];
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++) {
            need[i][j] = max[i][j] - alloc[i][j];
        }
    }

    int y = 0;
    for (k = 0; k < n; k++) {
        for (i = 0; i < n; i++) {
            if (f[i] == 0) {
                int flag = 0;
                for (j = 0; j < m; j++) {
                    if (need[i][j] > avail[j]) {
                        flag = 1;
                        break;
                    }
                }

                if (flag == 0) {
                    ans[ind++] = i;
                    for (y = 0; y < m; y++) {
                        avail[y] += alloc[i][y];
                    }
                    f[i] = 1;
                }
            }
        }
    }

    int flag = 1;
    for (i = 0; i < n; i++) {
        if (f[i] == 0) {
            flag = 0;
            printf("The system is not in a safe state.\n");
            break;
        }
    }

    if (flag == 1) {
        printf("The system is in a safe state.\nSafe sequence is: ");
        for (i = 0; i < n - 1; i++) {
            printf("P%d -> ", ans[i]);
        }
        printf("P%d\n", ans[n - 1]);
    }

    return 0;
}
PRODUCER-CONSUMER PROBLEM
#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("\n 1.Producer \n 2.Consumer \n 3.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;
      }
   }
}
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("Producer produces the item %d\n",x);
   mutex=signal(mutex);
}
void consumer()
{
   mutex=wait(mutex);
   full=wait(full);
   empty=signal(empty);
   printf("Consumer consumes item %d\n",x);
   x--;
   mutex=signal(mutex);
}
FCFS-PAGE REPLACEMENT ALGORITHM
//FIFO PAGE REPLACEMENT ALGORITHM
#include<stdio.h>
#include<conio.h>
int main()
{
int i, j, k, f, pf=0, count=0, rs[25], m[10], n;
printf("\n Enter the length of reference string -- ");
scanf("%d",&n);
printf("\n Enter the reference string -- ");
 for(i=0;i<n;i++)
scanf("%d",&rs[i]);
 printf("\n Enter no. of frames -- ");
 scanf("%d",&f);
for(i=0;i<f;i++)
m[i]=-1;

printf("\n The Page Replacement Process is -- \n");
 for(i=0;i<n;i++)
{
for(k=0;k<f;k++)
{
  if(m[k]==rs[i])
  break;

}
if(k==f)
{
m[count++]=rs[i];
pf++;

}

for(j=0;j<f;j++)
printf("\t%d",m[j]);
if(k==f)
printf("\tPF No. %d",pf);
printf("\n");
if(count==f)
count=0;
}
printf("\n The number of Page Faults using FIFO are %d",pf);
getch();
}
2.LRU PAGE REPLACEMENT ALGORITHM
//LRU
#include<stdio.h>
#include<conio.h>
void main()
{
int i, j , k, min, rs[25], m[10], count[10], flag[25], n, f, pf=0, next=1;
//clrscr();
printf("Enter the length of reference string -- ");
 scanf("%d",&n);
printf("Enter the reference string -- ");
 for(i=0;i<n;i++)
{
scanf("%d",&rs[i]);
flag[i]=0;
}
printf("Enter the number of frames -- ");
 scanf("%d",&f);
for(i=0;i<f;i++)

{
count[i]=0;
m[i]=-1;
}
printf("\nThe Page Replacement process is -- \n");
 for(i=0;i<n;i++)
{
for(j=0;j<f;j++)
{
if(m[j]==rs[i])
{
flag[i]=1;
count[j]=next;
 next++;
}

}
if(flag[i]==0)
{

if(i<f)
{  m[i]=rs[i];
   count[i]=next;
   next++;
 }
else
{ min=0;
for(j=1;j<f;j++)
if(count[min] > count[j])
  min=j;

m[min]=rs[i];
 count[min]=next;
  next++;


}
pf++;
}

for(j=0;j<f;j++)
printf("%d\t", m[j]);
 if(flag[i]==0)
printf("PF No. -- %d" , pf);
 printf("\n");
}
printf("\nThe number of page faults using LRU are %d",pf);
 getch();
}



3.OPTIMAL PAGE REPLACEMENT ALGORITHM
//Optimal page replacement
#include<stdio.h>
int n;
int main()
{
int seq[30],fr[5],pos[5],find,flag,max,i,j,m,k,t,s;
int count=1,pf=0,p=0;
float pfr;
printf("Enter maximum limit of the sequence: ");
scanf("%d",&max);
printf("\nEnter the sequence: ");
 for(i=0;i<max;i++)
scanf("%d",&seq[i]);
 printf("\nEnter no. of frames: ");
 scanf("%d",&n);
fr[0]=seq[0];
pf++;
printf("%d\t",fr[0]);
i=1;
while(count<n)
{
flag=1; p++;
for(j=0;j<i;j++)
{
if(seq[i]==seq[j]) flag=0;
}
if(flag!=0)
{
 fr[count]=seq[i];
 printf("%d\t",fr[count]);
 count++;
pf++;

}
i++;
}
 
printf("\n");
for(i=p;i<max;i++)
{
flag=1;
for(j=0;j<n;j++)
{
if(seq[i]==fr[j])
flag=0;
}
if(flag!=0)

{
for(j=0;j<n;j++)
{
m=fr[j];
for(k=i;k<max;k++)
{
if(seq[k]==m)
{
    pos[j]=k;
     break;

 }
else
pos[j]=1;

}
}
for(k=0;k<n;k++)
{
if(pos[k]==1)
flag=0;
}
if(flag!=0)
s=findmax(pos);
 if(flag==0)
{
for(k=0;k<n;k++)
{
if(pos[k]==1)
{
s=k;
 break;
}
}
}
fr[s]=seq[i];
for(k=0;k<n;k++)
printf("%d\t",fr[k]);
pf++;
printf("\n");
}
}
pfr=(float)pf/(float)max;
printf("\nThe no. of page faults are %d",pf);
printf("\nPage fault rate %f",pfr);
getch();
}
int findmax(int a[])
{
int max,i,k=0;
max=a[0];
for(i=0;i<n;i++)
{
if(max<a[i])
{
  max=a[i];
   k=i;
}
}
return k;
}