Loading

Archive for 10 Jul 2012

C Program for Producer Consumer Problem

Posted on Tuesday 10 July 2012 by

C - Program to Implement Producer-Consumer Problem


#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<string.h>
#define SIZE 10

main()
{
    pid_t pid;
    ssize_t byte;
    char bin[SIZE], bout[SIZE];
    int fields[2],ch=0,count = 0,a;
    pipe(fields);
    pid = fork();
    if(pid==0)
    {
        xyz:
        printf("\n\tEnter your choice:\n\t1.Producer,\n\t2.Consumer,\n\t3.Exit.");
        printf("\n\tEnter Your choice: ");
        scanf("%d",&ch);
        if(ch==1)
        {
            close(fields[0]);
            while(count<SIZE)
            {
                printf("\n\tEnter the string: ");
                gets(bin);
                write(fields[1], bin, SIZE);
                count++;
            }
            close(fields[1]);
            printf("\n\tPipe is full.");
            goto xyz;
        }
        else
            wait(0);
        if(ch==3)
            exit(0);
    }
    else
    {
        close(fields[1]);
        wait();
        printf("\n\tThe string is: ");
        count=0;
        while(count++<SIZE)
        {
            byte = read(fields[0], bout, SIZE);
            if(byte!=0)
            {
                printf("\t");
                puts(bout);
            }
            else
            {
                printf("\n\tSTRING IS EMPTY");
                goto xyz;
            }
            sleep(1);
        }
        count=0;
        goto xyz;
    }
}

Leave a comment

C Program for Dinning Philosophers Problem

by

C - Program to Implement Dinning Philosophers Problem


#include<stdio.h>
#include<unistd.h>
#include<pthread.h>

pthread_mutex_t work_mutex[5];

struct chops
{
    int left;
    int right;
}p[5];

void *philosopher5()
{
    while(1)
    {
        if((p[5].left==1) || (p[5].right==1))
        {
            printf("\n\tPhilosopher5 is thinking...");
            sleep(2);
        }
        if((p[5].left==0) && (p[5].right==0))
        {
            pthread_mutex_lock(&work_mutex[4]);
            pthread_mutex_lock(&work_mutex[0]);
            p[5].left=1;
            p[1].right=1;
            p[5].right=1;
            p[4].left=1;
            printf("\n\tPhilosopher5 is eating....");
            sleep(6);
            printf("\n\tphilosopher5 is releasing chopstics.");
            p[5].left=0;
            p[1].right=0;
            p[5].right=0;
            p[4].left=0;
            pthread_mutex_unlock(&work_mutex[4]);
            pthread_mutex_unlock(&work_mutex[0]);
            sleep(5);
        }
    }
}

void *philosopher4()
{
    while(1)
    {
        if((p[4].left==1) || (p[4].right==1))
        {
            printf("\n\tphilosopher4 is thinking...");
            sleep(2);
        }
        if((p[4].left==0) && (p[4].right==0))
        {
            pthread_mutex_lock(&work_mutex[3]);
            pthread_mutex_lock(&work_mutex[4]);
            p[4].left=1;
            p[5].right=1;
            p[4].right=1;
            p[3].left=1;
            printf("\n\tPhilosopher4 is eating....");
            sleep(6);
            printf("\n\tphilosopher4 is releasing chopstics.");
            p[4].left=0;
            p[5].right=0;
            p[4].right=0;
            p[3].left=0;
            pthread_mutex_unlock(&work_mutex[3]);
            pthread_mutex_unlock(&work_mutex[4]);
            sleep(5);
        }
    }
}

void *philosopher3()
{
    while(1)
    {
        if((p[3].left==1) || (p[3].right==1))
        {
            printf("\n\tPhilosopher3 is thinking...");
       
    sleep(2);
        }
        if((p[3].left==0) && (p[3].right==0))
        {
            pthread_mutex_lock(&work_mutex[3]);
            pthread_mutex_lock(&work_mutex[2]);
            p[3].left=1;
            p[4].right=1;
            p[3].right=1;
            p[2].left=1;
            printf("\n\tPhilosopher3 is eating....");
            sleep(6);
            printf("\n\tphilosopher3 is releasing chopstics.");
            p[3].left=0;
            p[4].right=0;
            p[3].right=0;
            p[2].left=0;
            pthread_mutex_unlock(&work_mutex[3]);
            pthread_mutex_unlock(&work_mutex[2]);
            sleep(5);
        }
    }
}

void *philosopher2()
{
    while(1)
    {
        if((p[2].left==1) || (p[2].right==1))
        {
            printf("\n\tPhilosopher2 is thinking...");
            sleep(2);
        }
        if((p[2].left==0) && (p[2].right==0))
        {
            pthread_mutex_lock(&work_mutex[2]);
            pthread_mutex_lock(&work_mutex[1]);
            p[2].left=1;
            p[3].right=1;
            p[2].right=1;
            p[1].left=1;
            printf("\n\tPhilosopher2 is eating....");
            sleep(6);
            printf("\n\tphilosopher2 is releasing chopstics.");
            p[2].left=0;
            p[3].right=0;
            p[2].right=0;
            p[1].left=0;
            pthread_mutex_unlock(&work_mutex[2]);
            pthread_mutex_unlock(&work_mutex[1]);
            sleep(5);
        }
    }
}

void *philosopher1()
{
    while(1)
    {
        if((p[1].left==1) || (p[1].right==1))
        {
            printf("\n\tPhilosopher1 is thinking...");
            sleep(2);
        }
        if((p[1].left==0) && (p[1].right==0))
        {
            pthread_mutex_lock(&work_mutex[1]);
            pthread_mutex_lock(&work_mutex[0]);
            p[1].left=1;
            p[2].right=1;
            p[1].right=1;
            p[5].left=1;
            printf("\n\tPhilosopher1 is eating....");
            sleep(6);
            printf("\n\tphilosopher1 is releasing chopstics.");
            p[1].left=0;
            p[2].right=0;
            p[1].right=0;
            p[5].left=0;
            pthread_mutex_unlock(&work_mutex[1]);
            pthread_mutex_unlock(&work_mutex[0]);
            sleep(5);
        }
    }
}

main()
{
    int res,i;
    pthread_t ph1,ph2,ph3,ph4,ph5;
    for(i=0;i<5;i++)
    {
        res=pthread_mutex_init(&work_mutex[i],NULL);
        if(res!=0)
        {
            printf("\n\tError in creation of mutex.");
            //exit(EXIT_FAILURE);
        }
    }
    for(i=1;i<=5;i++)
    {
        p[i].left=0;
        p[i].right=0;
    }
    printf("\n\tProgram to demonstrate thread:");
    printf("\n\tCreating 5 new threads...");
    pthread_create(&ph1,NULL,philosopher1,NULL);
    pthread_create(&ph2,NULL,philosopher2,NULL);
    pthread_create(&ph3,NULL,philosopher3,NULL);
    pthread_create(&ph4,NULL,philosopher4,NULL);
    pthread_create(&ph5,NULL,philosopher5,NULL);
    printf("\n\tWaiting for thread to join....");
    res=pthread_join(ph1,NULL);
    exit(EXIT_SUCCESS);
}

Leave a comment

Simulation of Page replacement algorithms ( FIFO, LRU, Optimal)

by

C  Program for Simulation of Page replacement algorithms
(FIFO, LRU, Optimal)

#include<stdio.h>

void FIFO(char [],char [],int,int);
void lru(char [],char [],int,int);
void opt(char [],char [],int,int);

int main()
{
   int ch,YN=1,i,l,f;
   char F[10],s[25];
   clrscr();
   //system("clear");
   printf("\n\n\tEnter the no of empty frames: ");
   scanf("%d",&f);
   printf("\n\n\tEnter the length of the string: ");
   scanf("%d",&l);
   printf("\n\n\tEnter the string: ");
   scanf("%s",s);
   for(i=0;i<f;i++)
     F[i]=-1;
      do
    {
     // system("clear");
      printf("\n\n\t*********** MENU ***********");
      printf("\n\n\t1:FIFO\n\n\t2:LRU\n\n\t3:OPT\n\n\t4:EXIT");
      printf("\n\n\tEnter your choice: ");
      scanf("%d",&ch);
      //system("clear");
      switch(ch)
       {
      case 1:
          for(i=0;i<f;i++)
           {
             F[i]=-1;
           }

          FIFO(s,F,l,f);
          break;
      case 2:
          for(i=0;i<f;i++)
           {
             F[i]=-1;
           }
          lru(s,F,l,f);
          break;
      case 3:
          for(i=0;i<f;i++)
           {
             F[i]=-1;
           }

          opt(s,F,l,f);
          break;
      case 4:
          exit(0);
       }
      printf("\n\n\tDo u want to continue IF YES PRESS 1\n\n\tIF NO PRESS 0 : ");
      scanf("%d",&YN);
    }while(YN==1);return(0);
}

//FIFO
void FIFO(char s[],char F[],int l,int f)
{
   int i,j=0,k,flag=0,cnt=0;
   printf("\n\tPAGE\t    FRAMES\t  FAULTS");
   for(i=0;i<l;i++)
    {
       for(k=0;k<f;k++)
    {
      if(F[k]==s[i])
        flag=1;
    }

       if(flag==0)
    {
      printf("\n\t%c\t",s[i]);
      F[j]=s[i];
      j++;

      for(k=0;k<f;k++)
       {
        printf("   %c",F[k]);
       }
      printf("\tPage-fault%d",cnt);
      cnt++;
    }

       else
    {
      flag=0;
      printf("\n\t%c\t",s[i]);
      for(k=0;k<f;k++)
       {
        printf("   %c",F[k]);
       }

      printf("\tNo page-fault");
    }
       if(j==f)
    j=0;
    }

}


//LRU
void lru(char s[],char F[],int l,int f)
{
   int i,j=0,k,m,flag=0,cnt=0,top=0;
   printf("\n\tPAGE\t    FRAMES\t  FAULTS");
   for(i=0;i<l;i++)
    {
       for(k=0;k<f;k++)
    {
      if(F[k]==s[i])
       {
        flag=1;
         break;
       }
    }

       printf("\n\t%c\t",s[i]);
       if(j!=f && flag!=1)
    {
      F[top]=s[i];
      j++;

      if(j!=f)
       top++;
    }
       else
    {
       if(flag!=1)
        {
          for(k=0;k<top;k++)
           {
        F[k]=F[k+1];
           }

           F[top]=s[i];
        }
       if(flag==1)
        {
           for(m=k;m<top;m++)
           {
        F[m]=F[m+1];
           }

           F[top]=s[i];
        }
    }
       for(k=0;k<f;k++)
    {
     printf("   %c",F[k]);
    }

       if(flag==0)
    {
      printf("\tPage-fault%d",cnt);
      cnt++;
    }
       else
     printf("\tNo page fault");
       flag=0;
    }

}


//optimal
void opt(char s[],char F[],int l,int f)
{
   int i,j=0,k,m,flag=0,cnt=0,temp[10];

   printf("\n\tPAGE\t    FRAMES\t  FAULTS");
   for(i=0;i<10;i++)
     temp[i]=0;

   for(i=0;i<f;i++)
     F[i]=-1;

   for(i=0;i<l;i++)
    {
       for(k=0;k<f;k++)
    {
      if(F[k]==s[i])
        flag=1;
    }

       if(j!=f && flag==0)
    {
      F[j]=s[i];
      j++;
    }

       else if(flag==0)
    {
       for(m=0;m<f;m++)
        {
          for(k=i+1;k<l;k++)
           {
          if(F[m]!=s[k])
           {
             temp[m]=temp[m]+1;
           }
          else
           break;
           }
        }
       m=0;
       for(k=0;k<f;k++)
        {
           if(temp[k]>temp[m])
        {
          m=k;
        }
        }

       F[m]=s[i];
    }

       printf("\n\t%c\t",s[i]);
       for(k=0;k<f;k++)
    {
       printf("  %c",F[k]);
    }
       if(flag==0)
    {
      printf("\tPage-fault %d",cnt);
      cnt++;
    }
       else
     printf("\tNo Page-fault");
       flag=0;

       for(k=0;k<10;k++)
     temp[k]=0;
     }
}

Posted in , , , | 5 Comments

Simulation of Memory allocation algorithms ( First Fit, Best Fit , Next Fit )

by

C - Program for Simulation of Memory Allocation Algorithms

(First Fit, Best Fit, Next Fit)



#include<stdio.h>
#include<stdlib.h>

void display(int ,int [10]);
void firstfit(int ,int [10],int [10],int);
void nextfit(int ,int [10],int [10],int);
void bestfit(int ,int [10],int [10],int);
void worstfit(int,int [10],int [10],int);

int main()
{
  int npr,nh=0,i,j,k,pr[10],hol[10],ch,temp[10];
  do{ 
      printf("\n\n----------MENU------------\n1.INPUT"
             "\n2.FIRST-FIT \n3.BEST FIT\n4.NEXT FIT"
             "\n5.WORST FIT\n6.EXIT\n\nENTER YOUR CHOICE:");
      scanf("%d",&ch);
    for(i=0;i<nh;i++)temp[i]=hol[i];
    switch(ch)
      {
         case 1:
                printf("\n Enter the number of processes:");
                scanf("%d",&npr);
                printf("\nNumber of holes:");
                scanf("%d",&nh);
                for(i=0;i<npr;i++)
                  {
                     printf("\nProcess %d:",i+1);  
                     scanf("%d",&pr[i]);  
                  }
                for(i=0;i<nh;i++)
                  {
                     printf("\nHole %d:",i+1);  
                     scanf("%d",&hol[i]);  
                      temp[i]=hol[i];
                  }
                break;
        case 2:
                firstfit(npr,temp,pr,nh);
                break;
        case 3: bestfit(npr,temp,pr,nh);
                break;
         case 4:nextfit(npr,temp,pr,nh);
                break;
         case 5:worstfit(npr,temp,pr,nh);
                 break;
         case 6:exit (0);//break;
        default:printf("\nWrong choice......!");
     }
   }while(ch!=6);
return 0;    
}

//First Fit
void firstfit(int npr,int hol[10],int pr[10],int nh)
{
   int i,j,k,flag=0;
   for(i=0;i<npr;i++)
   {
      flag=0;
      for(j=0;j<nh;j++)
      {
             if(pr[i]<hol[j])
              {
                hol[j]=hol[j]-pr[i];printf("\nMemory is Allocated to Process %d :(%d)",i+1,pr[i]);
                flag=1;break;             
              }
            else if(pr[i]==hol[j])
              {
                 flag=1;printf("\nMemory is Allocated to Process %d :(%d)",i+1,pr[i]);
                for(k=j;k<nh-1;k++)
                 {
                   hol[k]=hol[k+1];
                 }  nh--;
                 break;
              } 
        }
    if(flag==0)
    {printf("\n Hole is not Available.....");
    break;}
display(nh,hol);  
   }
}        

//Best fit
void bestfit(int npr,int hol[10],int pr[10],int nh){
int i,j,k,min,flag;
for(i=0;i<npr;i++)
   {
     flag=0;
       for(j=0;j<nh;j++)
        {
            if(pr[i]<=hol[j])
              {
                flag=1;  min=j;
                 for(k=j;k<nh;k++)
                 {
                   if((hol[min]>hol[k])&&(pr[i]<=hol[k]))min=k;
                        
                 }
               if(pr[i]<hol[min])
               {printf("\nMemory is Allocated to Process %d :(%d)",i+1,pr[i]);
                hol[min]=hol[min]-pr[i];
               break;             
               }
              else if(pr[i]==hol[min])
              {printf("\nMemory is Allocated to Process %d :(%d)",i+1,pr[i]);         
                for(k=min;k<nh-1;k++)
                   hol[k]=hol[k+1];
                nh--;
                 break;
              }         
               }     
          }       
    if(flag==0)
    {printf("\n Hole is not Available.....");
    break;}
display(nh,hol);  
      }
}

//Next Fit
void nextfit(int npr,int hol[10],int pr[10],int nh){
int i,j=0,k,flag=0;
for(i=0;i<npr;i++)
   {
     flag=0;
       for(;j<nh;)
        {
               if(pr[i]<hol[j])
               {
                hol[j]=hol[j]-pr[i];
               //j=(j+1)%nh;
flag=1;printf("\nMemory is Allocated to Process %d :(%d)",i+1,pr[i]);             
               break;             
               }
              else if(pr[i]==hol[j])
              {
            flag=1;printf("\nMemory is Allocated to Process %d :(%d)",i+1,pr[i]);
                for(k=j;k<nh-1;k++)
                   hol[k]=hol[k+1];
                nh--;
               //j=(j+1)%nh;
   break;
              }         
                j=(j+1)%nh;

          } 
    if(flag==0)
    {printf("\n Hole is not Available.....");
    break;}
    display(nh,hol);  
      }
//display(nh,hol);      }
 } 
  
//worst fit
void worstfit(int npr,int hol[10],int pr[10],int nh)
{
int i,j,k,max,flag;
for(i=0;i<npr;i++)
   {
     flag=0;
       for(j=0;j<nh;j++)
        {
            if(pr[i]<=hol[j])
     {
                printf("\nMemory is Allocated to Process %d :(%d)",i+1,pr[i]);
                flag=1;  max=j;
                 for(k=j;k<nh;k++)
                 {
                   if((hol[max]<hol[k])&&(pr[i]<=hol[k]))max=k;
                 }
               if(pr[i]<hol[max])
               {
              //printf("\nCPU is Allocated for process %d",i+1);
              hol[max]=hol[max]-pr[i];
               break;             
               }
              else if(pr[i]==hol[max])
              {
               //printf("\nCPU is Allocated for process %d",i+1);
               
                for(k=max;k<nh-1;k++)
                   hol[k]=hol[k+1];
                nh--;
                 break;
              }         
            }
          } 
    if(flag==0)
    {printf("\n Hole is not Available.....");
    break;}
    display(nh,hol);  
      }
//display(nh,hol);
}
void display(int nh,int hol[10])
{
 printf("\nHoles:");int i=0;
 for(i=0;i<nh;i++){printf("%d\t",hol[i]);}
}

1 Comment

CPU Scheduling Algoritms C Program

by

 

C - Program to Implement CPU Scheduling Algorithms

**********************************************************************************
Simulation of following CPU scheduling algorithms:
a. FCFS
b. SJF (preemptive and non-preemptive)
c. Priority Scheduling (preemptive and non-preemptive)
d. Round Robin Scheduling

**********************************************************************************

#include<stdio.h>
#include<stdlib.h>
#define MAX 20

typedef struct process
{
    int BT,AT,TAT,WT,PNO,PID;
    char name[10];
}process;

typedef struct RQ
{
    process pr[MAX];
    int f,r;
}RQ;

void get_PCB(process [],int *);
void FCFS(process [],int);
void sort_AT(process [],int);
void sort_BT(RQ []);
void disp_table(process [],int );
void SJF_NP(process [],int);
void SJF_P(process [],int);
void RR(process p[],int n,int);
float cal_avgwt(process [],int );
float cal_avgtat(process [],int );

void menu()
{
    printf("\n\t\t****MENU*****");
    printf("\n\t\t1. FCFS");
    printf("\n\t\t2. SJF NP");
    printf("\n\t\t3. RR");
    printf("\n\t\t4. SJF P");
    printf("\n\t\t5. EXIT");
    printf("\n\t\tEnter Choice: \t");
}
void main()
{
    int ch,TQ,n;
    process P[MAX];
    float avg_WT,avg_TAT;
    clrscr();
    printf("\nEnter Time Quantum");
    scanf("%d",&TQ);
    get_PCB(P,&n);
    do
    {
        clrscr();
        menu();
        scanf("%d",&ch);
        switch(ch)
        {
            case 1:
            {
                sort_AT(P,n);
                FCFS(P,n);
                disp_table(P,n);
                avg_WT=cal_avgwt(P,n);
                avg_TAT=cal_avgtat(P,n);
                printf("\nAVERAGE WT  : %f",avg_WT);
                printf("\nAVERAGE TAT : %f",avg_TAT);
                break;
            }
            case 2:
            {
                SJF_NP(P,n);
                disp_table(P,n);
                avg_WT=cal_avgwt(P,n);
                avg_TAT=cal_avgtat(P,n);
                printf("\nAVERAGE WT  : %f",avg_WT);
                printf("\nAVERAGE TAT : %f",avg_TAT);
                break;
            }
            case 3:
            {
                RR(P,n,TQ);
                disp_table(P,n);
                avg_WT=cal_avgwt(P,n);
                avg_TAT=cal_avgtat(P,n);
                printf("\nAVERAGE WT  : %f",avg_WT);
                printf("\nAVERAGE TAT : %f",avg_TAT);
                break;
            }
            case 4:
            {
                SJF_P(P,n);
                disp_table(P,n);
                avg_WT=cal_avgwt(P,n);
                avg_TAT=cal_avgtat(P,n);
                printf("\nAVERAGE WT  : %f",avg_WT);
                printf("\nAVERAGE TAT : %f",avg_TAT);
                break;
            }
            case 5:
                break;
        }
        getch();
    }while(ch!=5);
}


float cal_avgwt(process p[],int n)
{
    float avg=0;
    int i;
    for(i=0;i<n;i++)
    {
        avg+=p[i].WT;
    }
    avg=avg/n;
    return avg;
}
float cal_avgtat(process p[],int n)
{
    float avg=0;
    int i;
    for(i=0;i<n;i++)
    {
        avg+=p[i].TAT;
    }
    avg=avg/n;
    return avg;
}
int get_first_process(process p[],int n)
{
    int min,j,in;
    min=p[0].AT;
    for(j=0;j<n;j++)
    {
        if(p[j].AT<min)
        {
            in=j;
        }
       }
       return in;
}
void check_arrival(RQ *r,process p[],int time,int n)
{
    int i,j,flag=0;
    for(i=0;i<n;i++)
    {
        for(j=0;j<=r->r;j++)
        {
            if(strcmp(p[i].name,r->pr[j].name)==0)
                flag=1;
            else
                break;
        }
        if(p[i].AT == time && flag==0)
        {
            r->r=r->r + 1;
            r->pr[r->r]=p[i];
        }
        flag=0;
    }
}
void RR(process p[],int n,int tq)
{
    int count=0,i,start,time=0;
    RQ r;
    r.f=r.r=-1;
    start=get_first_process(p,n);
    r.pr[0]=p[start];
    r.f=r.r=0;
    check_arrival(&r,p,time,n);
    while(r.f!=-1)
    {
        for(count=0;count<tq;count++)
        {
            r.pr[r.f].BT--;
            time++;
            if(r.pr[r.f].BT==0)
                break;
            check_arrival(&r,p,time,n);
        }
        if(r.pr[r.f].BT!=0)
        {
            r.pr[r.r+1]=r.pr[r.f];
            r.r++;
        }
        else
        {
            p[r.pr[r.f].PID].TAT=time - r.pr[r.f].AT;
            p[r.pr[r.f].PID].WT=p[r.pr[r.f].PID].TAT - p[r.pr[r.f].PID].BT;
        }
        if(r.f==r.r)
            r.f=r.r=-1;
        else
            r.f++;
    }
}
void sort_BT(RQ *r)
{
    int i,j;
    process temp;
    for(i=r->f;i<=r->r;i++)
    {
        for(j=i+1;j<=r->r;j++)
        {
            if(r->pr[j].BT<r->pr[i].BT)
            {
                temp=r->pr[j];
                r->pr[j]=r->pr[i];
                r->pr[i]=temp;
            }
        }
    }
}

void SJF_NP(process p[],int n)
{
    int time=0,start;
    RQ r;
    r.f=r.r=-1;
    start=get_first_process(p,n);
    r.pr[0]=p[start];
    //p[start].WT=0;
    //p[start].TAT=p[start].BT;
    r.f=r.r=0;
    check_arrival(&r,p,time,n);
    while(r.f!=-1)
    {
        p[r.pr[r.f].PID].WT=time - r.pr[r.f].AT;
        p[r.pr[r.f].PID].TAT=p[r.pr[r.f].PID].WT + r.pr[r.f].BT;
        while(r.pr[r.f].BT != 0)
        {
            time++;
            check_arrival(&r,p,time,n);
            r.pr[r.f].BT--;
        }
        if(r.f==r.r)
            r.f=r.r=-1;
        else
            r.f++;
        sort_BT(&r);
    }
}
int get_total_time(process p[],int n)
{
    int i,sum=0;
    for(i=0;i<n;i++)
    {
        sum+=p[i].BT;
    }
    return sum;
}
void SJF_P(process p[],int n)
{
    int time=0,start,sum,i;
    RQ r;
    r.f=r.r=-1;
    start=get_first_process(p,n);
    r.pr[0]=p[start];
    //p[start].WT=0;
    //p[start].TAT=p[start].BT;
    r.f=r.r=0;
    check_arrival(&r,p,time,n);
    sum=get_total_time(p,n);
    for(i=0;i<sum;i++)
    {
        r.pr[r.f].BT--;
        time++;
        if(r.pr[r.f].BT==0)
        {
            p[r.pr[r.f].PID].TAT=time - r.pr[r.f].AT;
            p[r.pr[r.f].PID].WT=p[r.pr[r.f].PID].TAT - p[r.pr[r.f].PID].BT;
            r.f++;
        }
        check_arrival(&r,p,time,n);
        sort_BT(&r);
    }
}
void sort_AT(process p[],int n)
{
    int i,j;
    process temp;
    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(p[j].AT<p[i].AT)
            {
                temp=p[j];
                p[j]=p[i];
                p[i]=temp;
            }
        }
    }
}
void disp_table(process p[],int n)
{
    int i;
    printf("\n\n P_NAME \t AT \t BT \t WT \t TAT \t PNO");
    for(i=0;i<n;i++)
    {
        printf("\n %-10s \t %d \t %d \t %d \t %d \t %d",p[i].name,p[i].AT,p[i].BT,p[i].WT,p[i].TAT,p[i].PNO);
    }
}
void get_PCB(process p[],int *n)
{
    int i;
    printf("\n Enter total no of processes\n");
    scanf("%d",n);
    for(i=0;i<*n;i++)
    {
        printf("\n Enter Following details for Process %d",i+1);
        printf("\n Name :\t");
        scanf("%s",p[i].name);
        printf("\n Arrival Time :\t");
        scanf("%d",&p[i].AT);
        printf("\n Burst Time :\t");
        scanf("%d",&p[i].BT);
        printf("\n Priority :\t");
        scanf("%d",&p[i].PNO);
        p[i].PID=i;
    }
}
void FCFS(process p[],int n)
{
    int i,j,sum=0;
    p[0].TAT = p[0].BT;
    p[0].WT = 0;
    sum = p[0].BT;
    for(i=1;i<n;i++)
    {
        p[i].WT=sum - p[i].AT;
        p[i].TAT=p[i].WT + p[i].BT;
        sum+=p[i].BT;
    }
}



3 Comments

Bankers Algorithm C Program

by

C - Program to Implement Bankers Algorithm for Deadlock Avoidance


#include<stdio.h>
#include<conio.h>
 
struct process
{
    int all[6],max[6],need[6],finished,request[6];
}p[10];
int avail[6],sseq[10],ss=0,check1=0,check2=0,n,pid,work[6];
int nor,nori;
void main()
{
    int safeseq(void);
    int ch,i=0,j=0,k,pid,ch1;
    int violationcheck=0,waitcheck=0;
    do
    {
        clrscr();
        printf("\n\n\t 1. Input");
        printf("\n\n\t 2. Safe State or Not");
        printf("\n\n\t 3. print");
        printf("\n\n\t 4. Exit");
        printf("\n\n\t Enter ur choice : ");
        scanf("%d",&ch);
        switch(ch)
        {
            case 1:
                printf("\n\n\t Enter number of processes : ");
                scanf("%d",&n);
                printf("\n\n\t Enter the Number of Resources : ");
                scanf("%d",&nor);
                printf("\n\n\t Enter the Available Resouces : ");
                for(j=0;j<n;j++)
                {
                    for(k=0;k<nor;k++)
                    {
                        if(j==0)
                        {
                            printf("\n\n\t For Resource type %d : ",k);
                            scanf("%d",&avail[k]);
                        }
                        p[j].max[k]=0;
                        p[j].all[k]=0;
                        p[j].need[k]=0;
                        p[j].finished=0;
                        p[j].request[k]=0;
                    }
                }
                for(i=0;i<n;i++)
                {
                    printf("\n\n\t Enter Max and Allocated resources for P%d : ",i);
                    for(j=0;j<nor;j++)
                    {
                        printf("\n\n\t Enter the Max of resource %d : ",j);
                        scanf("%d",&p[i].max[j]);
                        printf("\n\n\t Allocation of resource %d    : ",j);
                        scanf("%d",&p[i].all[j]);
                        if(p[i].all[j]>p[i].max[j])
                        {
                            printf("\n\n\t Allocation should be less < or == max");
                            j--;
                        }
                        else
                        p[i].need[j]=p[i].max[j]-p[i].all[j];
                        avail[j]=avail[j]-p[i].all[j];
                    }
                }
                break;
            case 2:
                if(safeseq()==1)
                    printf("\n\n\t The System is in safe state ");
                else
                    printf("\n\n\t The System is Not in safe state ");
                break;
            case 3:
                printf("\n\n\t Number of processes : %d",n);
                printf("\n\n\t Number of Resoures : %d",nor);
                printf("\n\n\t Pid \t   Max \t   Allocated \t Need ");
                for(i=0;i<n;i++)
                {
                    printf("\n\n\t  P%d : ",i);
                    for(j=0;j<nor;j++)
                        printf(" %d ",p[i].max[j]);
                    printf("\t");
                    for(j=0;j<nor;j++)
                        printf(" %d ",p[i].all[j]);
                    printf("\t");
                    for(j=0;j<nor;j++)
                        printf(" %d ",p[i].need[j]);
                }
                printf("\n\n\t Available : ");
                for(i=0;i<nor;i++)
                    printf(" %d ",avail[i]);
                break;
            case 4: exit(0);
        }
    getch();
    }while(ch!=4);
}
int safeseq()
{
    int i,j,k;
    ss=0;
    for(j=0;j<nor;j++)
        work[j]=avail[j];
    for(j=0;j<n;j++)
        p[j].finished=0;
    for(k=0;k<nor;k++)
    {
        for(j=0;j<n;j++)
        {
            if(p[j].finished==0)
            {
                check1=0;
                for(k=0;k<nor;k++)
                    if(p[j].need[k]<=work[k])
                        check1++;
                    if(check1==nor)
                    {
                        for(k=0;k<nor;k++)
                        {
                            work[k]=work[k]+p[j].all[k];
                            p[j].finished=1;
                        }
                        sseq[ss]=j;
                        ss++;
                    }
            }
        }
    }
    check2=0;
    for(i=0;i<n;i++)
        if(p[i].finished==1)
            check2++;
        printf("\n\n\t");
        if(check2>=n)
        {
            printf("\n\n\t The system is in safe state");
            for(j=0;j<n;j++)
                printf("P%d, ",sseq[j]);
            return 1;
        }
        else
            printf("\n\n\t The system is Not in safe state");
        return 0;
}

Leave a comment