OS lab All Program

All program are well executed and no error will come, in some program warning will come so ignore those warning, if any error came then your bad luck...

Reference: 👉👉 Manual

Programs:👇👇👇👇

1a. FCFS

  #include<stdio.h>
    //#include<conio.h>
    void main()
    {
    int bt[20], wt[20], tat[20], i, n;
    float wtavg, tatavg;
    printf("\nEnter the number of processes -- ");
    scanf("%d", &n);
    for(i=0;i<n;i++)
    {
    printf("\nEnter Burst Time for Process %d -- ", i);
    scanf("%d", &bt[i]);
    }
    wt[0] = wtavg = 0;
    tat[0] = tatavg = bt[0];
    for(i=1;i<n;i++)
    {
    wt[i] = wt[i-1] +bt[i-1];
    tat[i] = tat[i-1] +bt[i];
    wtavg = wtavg + wt[i];
    tatavg = tatavg + tat[i];
    }
    printf("\t PROCESS \tBURST TIME \t WAITING TIME\t TURNAROUND TIME\n");
    for(i=0;i<n;i++)
    printf("\n\t P%d \t\t %d \t\t %d \t\t %d", i, bt[i], wt[i], tat[i]);
    printf("\nAverage Waiting Time -- %f", wtavg/n);
    printf("\nAverage Turnaround Time -- %f", tatavg/n);
    //getch();
    }

1b. SJF

  #include<stdio.h>
    //#include<conio.h>
    void main()
    {
    int p[20], bt[20], wt[20], tat[20], i, k, n, temp;
    float wtavg, tatavg;
    printf("\nEnter the number of processes -- ");
    scanf("%d", &n);
    for(i=0;i<n;i++)
    {
    p[i]=i;
    printf("Enter Burst Time for Process %d -- ", i);
    scanf("%d", &bt[i]);
    }
    
    for(i=0;i<n;i++)
    for(k=i+1;k<n;k++)
    if(bt[i]>bt[k])
    {
    temp=bt[i];
    bt[i]=bt[k];
    bt[k]=temp;
    temp=p[i];
    p[i]=p[k];
    p[k]=temp;
    }
    wt[0] = wtavg = 0;
    tat[0] = tatavg = bt[0];
    for(i=1;i<n;i++)
    {
    wt[i] = wt[i-1] +bt[i-1];
    tat[i] = tat[i-1] +bt[i];
    wtavg = wtavg + wt[i];
    tatavg = tatavg + tat[i];
    }
    printf("\n\t PROCESS \tBURST TIME \t WAITING TIME\t TURNAROUND TIME\n");
    for(i=0;i<n;i++)
    printf("\n\t P%d \t\t %d \t\t %d \t\t %d", p[i], bt[i], wt[i], tat[i]);
    printf("\nAverage Waiting Time -- %f", wtavg/n);
    printf("\nAverage Turnaround Time -- %f", tatavg/n);
    //getch();
    }

1.C) Round Robin

  #include<stdio.h>
    void main()
    {
    int i,j,n,bu[10],wa[10],tat[10],t,ct[10],max;
    float awt=0,att=0,temp=0;
    //clrscr();
    printf("Enter the no of processes -- ");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
    printf("\nEnter Burst Time for process %d -- ", i+1);
    scanf("%d",&bu[i]);
    ct[i]=bu[i];
    }
    printf("\nEnter the size of time slice -- ");
    scanf("%d",&t);
    max=bu[0];
    for(i=1;i<n;i++)
    if(max<bu[i])
    max=bu[i];
    for(j=0;j<(max/t)+1;j++)
    for(i=0;i<n;i++)
    
    if(bu[i]!=0)
    if(bu[i]<=t)
    {
    tat[i]=temp+bu[i];
    temp=temp+bu[i];
    bu[i]=0;
    }
    else
    {
    bu[i]=bu[i]-t;
    temp=temp+t;
    }
    for(i=0;i<n;i++)
    {
    wa[i]=tat[i]-ct[i];
    att+=tat[i];
    awt+=wa[i];
    }
    printf("\nThe Average Turnaround time is -- %f",att/n);
    printf("\nThe Average Waiting time is -- %f ",awt/n);
    printf("\n\tPROCESS\t BURST TIME \t WAITING TIME\tTURNAROUND TIME\n");
    for(i=0;i<n;i++)
    printf("\t%d \t %d \t\t %d \t\t %d \n",i+1,ct[i],wa[i],tat[i]);
    //getch();
    }

1.D) Priority

  #include<stdio.h>
    void main()
    {
    int p[20],bt[20],pri[20], wt[20],tat[20],i, k, n, temp;
    float wtavg, tatavg;
    //clrscr();
    printf("Enter the number of processes --- ");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
    p[i] = i;
    printf("Enter the Burst Time & Priority of Process %d --- ",i);
    scanf("%d %d",&bt[i], &pri[i]);
    }
    for(i=0;i<n;i++)
    for(k=i+1;k<n;k++)
    if(pri[i] > pri[k])
    {
    temp=p[i];
    p[i]=p[k];
    p[k]=temp;
    temp=bt[i];
    bt[i]=bt[k];
    bt[k]=temp;
    temp=pri[i];
    pri[i]=pri[k];
    pri[k]=temp;
    
    }
    wtavg = wt[0] = 0;
    tatavg = tat[0] = bt[0];
    for(i=1;i<n;i++)
    {
    wt[i] = wt[i-1] + bt[i-1];
    tat[i] = tat[i-1] + bt[i];
    wtavg = wtavg + wt[i];
    tatavg = tatavg + tat[i];
    }
    printf("\nPROCESS\t\tPRIORITY\tBURST TIME\tWAITING TIME\tTURNAROUND TIME");
    for(i=0;i<n;i++)
    printf("\n%d \t\t %d \t\t %d \t\t %d \t\t %d ",p[i],pri[i],bt[i],wt[i],tat[i]);
    printf("\nAverage Waiting Time is --- %f",wtavg/n);
    printf("\nAverage Turnaround Time is --- %f",tatavg/n);
    //getch();
    }

2 a) C program using open, read, write, close system calls

  #include<sys/stat.h>
  #include<stdio.h>
  #include<fcntl.h>
  #include<sys/types.h>
  int main()
  {
  int n,i=0;
  int f1,f2;
  char c,strin[100];
  f1=open("data",O_RDWR|O_CREAT|O_TRUNC);
  while((c=getchar())!='\n')
  {
  strin[i++]=c;
  }
  strin[i]='\0';
  
  write(f1,strin,i);
  close(f1);
  f2=open("data",O_RDONLY);
  read(f2,strin,0);
  printf("\n%s\n",strin);
  close(f2);
  return 0;
  }

2b) C program using lseek

  #include<stdio.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <sys/types.h>
    int main()
    {
    int file=0;
    if((file=open("testfile.txt",O_RDONLY)) < -1)
    return 1;
    char buffer[19];
    if(read(file,buffer,19) != 19) return 1;
    printf("%s\n",buffer);
    if(lseek(file,10,SEEK_SET) < 0) return 1;
    if(read(file,buffer,19) != 19) return 1;
    printf("%s\n",buffer);
    return 0;
    }

2c) C program using opendir(), closedir(), readdir()

  #include<stdio.h>
    #include<fcntl.h>
    #include<dirent.h>
    void main()
    {
    char d[10]; int c,op; DIR *e;
    struct dirent *sd;
    printf("**menu**\n1.create dir\n2.remove dir\n 3.read dir\n enter ur choice");
    scanf("%d",&op);
    switch(op)
    {
    case 1: printf("enter dir name\n"); scanf("%s",&d);
    c=mkdir(d,777);
    if(c==1)
    printf("dir is not created");
    else
    printf("dir is created"); break;
    
    case 2: printf("enter dir name\n"); scanf("%s",&d);
    c=rmdir(d);
    if(c==1)
    printf("dir is not removed");
    else
    printf("dir is removed"); break;
    case 3: printf("enter dir name to open");
    scanf("%s",&d);
    e=opendir(d);
    if(e==NULL)
    printf("dir does not exist"); else
    {
    printf("dir exist\n"); while((sd=readdir(e))!=NULL) printf("%s\t",sd->d_name);}
    closedir(e);
    break;
    }
    }

3a) Bankers Algorithm for Deadlock Avoidance

  #include<stdio.h>
    struct file
    {
    
    int all[10];
    int max[10];
    int need[10];
    int flag;
    };
    void main()
    {
    struct file f[10];
    int fl;
    int i, j, k, p, b, n, r, g, cnt=0, id, newr;
    int avail[10],seq[10];
    //clrscr();
    printf("Enter number of processes -- ");
    scanf("%d",&n);
    printf("Enter number of resources -- ");
    scanf("%d",&r);
    for(i=0;i<n;i++)
    {
    printf("Enter details for P%d",i);
    printf("\nEnter allocation\t -- \t");
    for(j=0;j<r;j++)
    scanf("%d",&f[i].all[j]);
    printf("Enter Max\t\t -- \t");
    for(j=0;j<r;j++)
    scanf("%d",&f[i].max[j]);
    
    f[i].flag=0;
    }
    printf("\nEnter Available Resources\t -- \t");
    for(i=0;i<r;i++)
    scanf("%d",&avail[i]);
    printf("\nEnter New Request Details -- ");
    printf("\nEnter pid \t -- \t");
    scanf("%d",&id);
    printf("Enter Request for Resources \t -- \t");
    for(i=0;i<r;i++)
    {
    scanf("%d",&newr);
    f[id].all[i] += newr;
    avail[i]=avail[i] - newr;
    }
    for(i=0;i<n;i++)
    {
    for(j=0;j<r;j++)
    {
    f[i].need[j]=f[i].max[j]-f[i].all[j];
    if(f[i].need[j]<0)
    f[i].need[j]=0;
    }
    }
    cnt=0;
    
    fl=0;
    while(cnt!=n)
    {
    g=0;
    for(j=0;j<n;j++)
    {
    if(f[j].flag==0)
    {
    b=0;
    for(p=0;p<r;p++)
    {
    if(avail[p]>=f[j].need[p])
    b=b+1;
    else
    b=b-1;
    }
    if(b==r)
    {
    printf("\nP%d is visited",j);
    seq[fl++]=j;
    f[j].flag=1;
    for(k=0;k<r;k++)
    avail[k]=avail[k]+f[j].all[k];
    cnt=cnt+1;
    printf("(");
    
    for(k=0;k<r;k++)
    printf("%3d",avail[k]);
    printf(")");
    g=1;
    }
    }
    }
    if(g==0)
    {
    printf("\n REQUEST NOT GRANTED -- DEADLOCK OCCURRED"); printf("\n SYSTEM IS IN UNSAFE STATE"); 
    goto y;
    }
    }
    printf("\nSYSTEM IS IN SAFE STATE");
    printf("\nThe Safe Sequence is -- (");
    for(i=0;i<fl;i++)
    printf("P%d ",seq[i]);
    printf(")");
    y: printf("\nProcess\t\tAllocation\t\tMax\t\t\tNeed\n");
    for(i=0;i<n;i++)
    {
    printf("P%d\t",i);
    for(j=0;j<r;j++)
    printf("%6d",f[i].all[j]);
    for(j=0;j<r;j++)
    
    printf("%6d",f[i].max[j]);
    for(j=0;j<r;j++)
    printf("%6d",f[i].need[j]);
    printf("\n");
    }
    //getch();
    }

3b) Bankers Algorithm for Deadlock Prevention

  #include<stdio.h>
    //#include<conio.h>
    void main()
    {
    int
    allocated[15][15],max[15][15],need[15][15],avail[15],tres[15],work[15],flag[15];
    int pno,rno,i,j,prc,count,t,total;
    
    count=0;
    //clrscr();
    printf("\n Enter number of process:");
    scanf("%d",&pno);
    printf("\n Enter number of resources:");
    scanf("%d",&rno);
    for(i=1;i<=pno;i++)
    {
    flag[i]=0;
    }
    printf("\n Enter total numbers of each resources:");
    for(i=1;i<= rno;i++)
    scanf("%d",&tres[i]);
    
    printf("\n Enter Max resources for each process:");
    for(i=1;i<= pno;i++)
    {
    printf("\n for process %d:",i);
    for(j=1;j<= rno;j++)
    scanf("%d",&max[i][j]);
    }
    
    printf("\n Enter allocated resources for each process:");
    for(i=1;i<= pno;i++)
    {
    printf("\n for process %d:",i);
    for(j=1;j<= rno;j++)
    scanf("%d",&allocated[i][j]);
    }
    printf("\n available resources:\n");
    for(j=1;j<= rno;j++)
    {
    avail[j]=0;
    total=0;
    for(i=1;i<= pno;i++)
    {
    total+=allocated[i][j];
    
    }
    avail[j]=tres[j]-total;
    work[j]=avail[j];
    printf(" %d \t",work[j]);
    }
    do
    {
    for(i=1;i<= pno;i++)
    {
    for(j=1;j<= rno;j++)
    {
    need[i][j]=max[i][j]-allocated[i][j];
    }
    }
    printf("\n Allocated matrix Max need");
    for(i=1;i<= pno;i++)
    {
    printf("\n");
    for(j=1;j<= rno;j++)
    {
    printf("%4d",allocated[i][j]);
    }
    printf("|");
    for(j=1;j<= rno;j++)
    {
    printf("%4d",max[i][j]);
    }
    printf("|");
    for(j=1;j<= rno;j++)
    {
    printf("%4d",need[i][j]);
    }
    }
    prc=0;
    for(i=1;i<= pno;i++)
    {
    if(flag[i]==0)
    {
    prc=i;
    
    for(j=1;j<= rno;j++)
    {
    if(work[j]< need[i][j])
    {
    prc=0;
    break;
    }
    }
    }
    if(prc!=0)
    break;
    }
    if(prc!=0)
    {
    printf("\n Process %d completed",i);
    count++;
    printf("\n Available matrix:");
    for(j=1;j<= rno;j++)
    {
    work[j]+=allocated[prc][j];
    allocated[prc][j]=0;
    max[prc][j]=0;
    flag[prc]=1;
    printf(" %d",work[j]);
    }
    }
    }while(count!=pno&&prc!=0);
    if(count==pno)
    printf("\nThe system is in a safe state!!");
    else
    printf("\nThe system is in an unsafe state!!");
    //getch();
    }

4) Producer Consumer problem using semaphores

  #include<stdio.h>
    void main () 
    {
    int buffer[10], bufsize, in, out, produce, consume, choice = 0;
    in = 0;
    out = 0;
    bufsize = 10;
    while (choice != 3)
        {
    printf ("\n1. Produce \t 2. Consume \t3. Exit");
    printf ("\nEnter your choice: ");
    scanf ("%d", &choice);
    switch (choice)
      {
    case 1:
        if ((in + 1) % bufsize == out)
    printf ("\nBuffer is Full");
        else
          {
    printf ("\nEnter the value: ");
    scanf ("%d", &produce);
    buffer[in] = produce;
    in = (in + 1) % bufsize;
    }
    break;
    case 2:
        if (in == out)
    printf ("\nBuffer is Empty");
        else
          {
    consume = buffer[out];
    printf ("\nThe consumed value is %d", consume);
    out = (out + 1) % bufsize;
    }}}}

5a) PIPES

  #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #define MSG_LEN 64
    int main(){
    int result;
    int fd[2];
    char message[MSG_LEN];
    char recvd_msg[MSG_LEN];
    result = pipe (fd);
    if (result < 0)
    {
    perror("pipe ");
    exit(1);
    }
    strncpy(message,"Linux World!! ",MSG_LEN);
    result=write(fd[1],message,strlen(message));
    if (result < 0)
    {
    perror("write");
    exit(2);
    }
    strncpy(message,"Understanding ",MSG_LEN);
    result=write(fd[1],message,strlen(message));
    if (result < 0)
    {
    
    perror("write");
    exit(2);
    }
    strncpy(message,"Concepts of ",MSG_LEN);
    result=write(fd[1],message,strlen(message));
    if (result < 0)
    {
    perror("write");
    exit(2);
    }
    strncpy(message,"Piping ", MSG_LEN);
    result=write(fd[1],message,strlen(message));
    if (result < 0)
    {
    perror("write");
    exit(2);
    }
    result=read (fd[0],recvd_msg,MSG_LEN);
    if (result < 0)
    {
    perror("read");
    exit(3);
    }
    printf("%s\n",recvd_msg);
    return 0;
    }

5b) FIFOs

  #include<stdio.h>
    int main()
    
    {
    int i=0,j=0,k=0,i1=0,m,n,rs[30],flag=1,p[30];
    system("clear");
    printf("FIFO page replacement algorithm....\\n");
    printf("\n enter the no. of frames:");
    scanf("%d",&n);
    printf("enter the reference string:");
    while(1)
    {
    scanf("%d",&rs[i]);
    if(rs[i]==0)
    break;
    i++;
    }
    m=i;
    for(j=0;j<n;j++)
    p[j]=0;
    for(i=0;i<m;i++)
    
    {
    flag=1;
    for(j=0;j<n;j++)
    if(p[j]==rs[i]) {
    printf("data already in page....\n");
    flag=0;
    break; }
    if(flag==1) {
    p[i1]=rs[i];
    i1++;
    k++;
    
    if(i1==n)
    i1=0;
    for(j=0;j<n;j++) {
    printf("\n page %d:%d",j+1,p[j]);
    if(p[j]==rs[i])
    printf("*"); }
    printf("\n\n");
    }}
    printf("total no page faults=%d",k);
    }

5c) Message Queues( writer process)

  #include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    struct mesg_buffer {
    long msg_type;
    char msg_text[100];
    } message;
    int main()
    {
    key_t key;
    int msgid;
    key = ftok("progfile", 65);
    msgid = msgget(key, 0666 | IPC_CREAT);
    message.msg_type = 1;
    printf("Write Data : ");
    gets(message.msg_text);
    msgsnd(msgid, &message, sizeof(message), 0);
    printf("Data send is : %s \n", message.msg_text);
    return 0;
    }

Message Queues( Reader process)

  #include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    struct mesg_buffer {
    long mesg_type;
    char mesg_text[100];
    } message;
    int main()
    {
    key_t key;
    int msgid;
    key = ftok("progfile", 65);
    msgid = msgget(key, 0666 | IPC_CREAT);
    msgrcv(msgid, &message, sizeof(message), 1, 0);
    printf("Data Received is : %s \n",
    message.mesg_text);
    msgctl(msgid, IPC_RMID, NULL);
    return 0;
    }

5d) Shared Memory

  #include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<string.h>
    #include<sys/ipc.h>
    #include<sys/shm.h>
    #include<sys/types.h>
    #define SEGSIZE 100
    int main(int argc, char *argv[ ])
    {
    int shmid,cntr;
    key_t key;
    char *segptr;
    char buff[]="poooda......";
    key=ftok(".",'s');
    if((shmid=shmget(key, SEGSIZE, IPC_CREAT | IPC_EXCL | 0666))== -1)
    {
    if((shmid=shmget(key,SEGSIZE,0))==-1)
    {
    perror("shmget");
    exit(1);
    }
    }
    else
    {
    printf("Creating a new shared memory seg \n");
    printf("SHMID:%d",shmid);
    }
    system("ipcs –m");
    
    if((segptr=(char*)shmat(shmid,0,0))==(char*)-1)
    {
    perror("shmat");
    exit(1);
    }
    printf("Writing data to shared memory...\n");
    strcpy(segptr,buff);
    printf("DONE\n");
    printf("Reading data from shared memory...\n");
    printf("DATA:-%s\n",segptr);
    printf("DONE\n");
    printf("Removing shared memory Segment...\n");
    if(shmctl(shmid,IPC_RMID,0)== -1)
    printf("Can‟t Remove Shared memory Segment...\n");
    else
    printf("Removed Successfully");
    }

6a) PAGING

  #include<stdio.h>
    //#include<conio.h>
    void main()
    {
    int ms, ps, nop, np, rempages, i, j, x, y, pa, offset;
    int s[10], fno[10][20];
    //clrscr();
    printf("\nEnter the memory size -- ");
    scanf("%d",&ms);
    printf("\nEnter the page size -- ");
    scanf("%d",&ps);
    nop = ms/ps;
    printf("\nThe no. of pages available in memory are -- %d ",nop);
    
    printf("\nEnter number of processes -- ");
    scanf("%d",&np);
    rempages = nop;
    for(i=1;i<=np;i++)
    {
    printf("\nEnter no. of pages required for p[%d]-- ",i);
    scanf("%d",&s[i]);
    if(s[i] >rempages)
    {
    printf("\nMemory is Full");
    break;
    }
    rempages = rempages - s[i];
    printf("\nEnter pagetable for p[%d] --- ",i);
    for(j=0;j<s[i];j++)
    scanf("%d",&fno[i][j]);
    }
    printf("\nEnter Logical Address to find Physical Address ");
    printf("\nEnter process no. and pagenumber and offset -- ");
    scanf("%d %d %d",&x,&y, &offset);
    if(x>np || y>=s[i] || offset>=ps)
    printf("\nInvalid Process or Page Number or offset");
    else
    {
    pa=fno[x][y]*ps+offset;
    
    printf("\nThe Physical Address is -- %d",pa);
    }
    //getch();
    }

6b) SEGMENTATION

  #include<stdio.h>
    #include<stdlib.h>
    //#include<conio.h>
    struct list
    {
    int seg;
    
    int base;
    int limit;
    struct list *next;
    } *p;
    void insert(struct list *q,int base,int limit,int seg)
    {
    if(p==NULL)
    {
    p=malloc(sizeof(struct list));
    p->limit=limit;
    p->base=base;
    p->seg=seg;
    p->next=NULL;
    }
    else
    {
    while(q->next!=NULL)
    {
    q=q->next;
    printf("yes");
    }
    q->next=malloc(sizeof(struct list));
    q->next ->limit=limit;
    q->next ->base=base;
    q->next ->seg=seg;
    q->next ->next=NULL;
    }
    }
    int find(struct list *q,int seg)
    {
    while(q->seg!=seg)
    {
    q=q->next;
    }
    return q->limit;
    }
    int search(struct list *q,int seg)
    {
    while(q->seg!=seg)
    {
    
    q=q->next;
    }
    return q->base;
    }
    void main()
    {
    p=NULL;
    int seg,offset,limit,base,c,s,physical;
    printf("Enter segment table/n");
    printf("Enter -1 as segment value for termination\n");
    do
    {
    printf("Enter segment number");
    scanf("%d",&seg);
    if(seg!=-1)
    {
    printf("Enter base value:");
    scanf("%d",&base);
    printf("Enter value for limit:");
    scanf("%d",&limit);
    insert(p,base,limit,seg);
    }
    }
    while(seg!=-1);
    printf("Enter offset:");
    scanf("%d",&offset);
    printf("Enter bsegmentation number:");
    scanf("%d",&seg);
    c=find(p,seg);
    s=search(p,seg);
    if(offset<c)
    {
    physical=s+offset;
    printf("Address in physical memory %d\n",physical);
    }
    else
    {
    printf("error");
    }}

OS lab All Program

1 Comments

Menu Footer Widget

OS lab All Program

You may like these posts

1 Comments

Follow Us

Menu Footer Widget