ProjectsGeek

Download Mini projects with Source Code, Java projects with Source Codes

Operating System

Bankers Algorithm using C Language OS problem

by Leave a Comment

Bankers Algorithm using C Language OS problem

 

 Bankers Algorithm for deadlock detection and avoidance.

 Bankers Algorithm code

# include  
 # include  
 # include  
 # define maxn 10  
 typedef struct banker  
 {  
  int available[maxn] ;  
  int claim[maxn][maxn] ;  
  int allocation[maxn][maxn] ;  
  int need[maxn][maxn] ;  
  int request[maxn];  
 }banker ;  
 void display(int,int,int resource[maxn],banker);  
 void bankersalgo(int nm,int resource [maxn],int rs);  
 int safe(int rs,int nm,int resource [maxn],banker) ;  
 void main()  
 {  
  int ch=0,nm=0,i,j,k,resource[maxn],request[maxn],rs ,flag=0;  
  char temp1;  
  struct banker bankers,b ;  
  clrscr() ;  
  do  
  {  
    printf("\t\t\t\t***MAIN MENU***\n") ;  
    printf("\t\t\t\t1.ENTER MATRICES\n");  
    printf("\t\t\t\t2.DISPLAY MATRICES \n");  
    printf("\t\t\t\t3.BANKERS ALGORITM (SAFETY & ALLOCATION\n" );  
    printf("\t\t\t\t4.EXIT\n");  
    printf("\t\t\t\tENTER UR CHOICE!!\n");  
    scanf("%d",&ch);  
    switch (ch)  
    {  
    case 1:  
     clrscr();  
     printf("ENTER NO OF PROCESS!!\n") ;  
     scanf("%d",&nm);  
     printf("ENTER NO OF RESOURCE !!\n") ;  
     scanf("%d",&rs);  
     for(i=0;i<rs;i++) <br="">     {  
       printf("ENTER RESOURCE MATRIX %d!!\n",i) ;  
       scanf("%d",&resource[i]) ;  
     }  
     printf("ENTER CLAIM MATRIX!!\n") ;  
     for(i=0;i<nm;i++) <br="">     {  
       for(j=0;j<rs;j++) <br="">       {  
         printf("\nENTER %d %d!!\n",i,j) ;  
         scanf("%d",&bankers.claim[i][j]) ;  
         if(bankers.claim[i][j]>resource[j])  
         {  
           printf(" WRONG VALUES ENTERED") ;  
           j--;  
         }  
       }  
     }  
     for(i=0;i<nm;i++) <br="">     {  
       for(j=0;j<rs;j++) <br="">       {  
         bankers.allocation[i][j]=0;  
         bankers.available[j]=resource[j];  
       }  
     }  
       clrscr();  
       display(nm,rs,resource,bankers);  
       printf("\nENTER ALLOCATION MATRIX!!\n") ;  
       for(i=0;i<nm;i++) <br="">       {  
         for(j=0;j<rs;j++) <br="">         {  
           printf("\nENTER %d %d!!",i,j) ;  
           scanf("%d",&bankers.allocation[i][j]) ;  
           if((bankers.allocation[i][j]>bankers.claim[i][j]) && (bankers.allocation[i][j]>bankers.available[j]))  
           {  
             printf(" WRONG VALUES ENTERED") ;  
             j--;  
           }  
           else  {  
             bankers.available[j]=bankers.available[j]-bankers.allocation[i][j];  
             bankers.need[i][j]=bankers.claim[i][j]-bankers.allocation[i][j];  
             }  
         }  
         display(nm,rs,resource,bankers);  
       }  
       break ;  
    case 2:  
     display(nm,rs,resource,bankers);  
     break ;  
    case 3:  
     i=safe(rs,nm,resource,bankers) ;  
     display(nm,rs,resource,bankers);  
     do  
     {  
     if(i==1)  
     {  
       printf("\n Enter the request process no P");  
       scanf("%d",&j);  
       printf("\n Enter process %d's request",j);  
       for(k=0;k<rs;k++) <br="">       {  
         scanf("%d",&request[k]);  
         if((request[k]>bankers.need[j][k])&& (request[k]>bankers.available[k]))  
         {  
           printf("\n Not valid request");  
           k--;  
         }  
       }  
           b=bankers;  
           for(k=0;k<rs;k++) <br="">           {  
             b.allocation[j][k]+=request[k];  
             b.need[j][k]-=request[k];  
             b.available[k]-=request[k];  
           }  
           display(nm,rs,resource,b);  
           printf("\n The new state's safety is checking");  
           i=safe(rs,nm,resource,b);  
           if(i==1)  
           {    display(nm,rs,resource,b);  
             bankers=b;  
             printf(" This is a Current state ");  
           }  
           else  
           {  
             display(nm,rs,resource,bankers);  
             printf(" This is a Current safe state ");  
           }  
          printf("\nDo u want to add more request on current system(0/1)");  
          scanf("%d",&flag);  
       }  
     else  
     {  
       printf("\n Current system is unsafe state");  
       exit(0);  
      }  
      }while(flag==1);  
      break ;  
    default :  
      printf("ENTER RIGHT OPTION!!\n") ;  
   }  
  }while(ch!=4 );  
 }  
 void display(int nm,int rs,int resource[maxn],banker bankers)  
 {  
   int i,j;  
   clrscr();  
   printf("Total instances of resources are:-");  
   for(i=0;i<rs;i++) <br="">     printf("\t%d",resource[i]);  
   printf("\nClaim \t Alloc \t Need");  
   for(i=0;i<nm;i++) <br="">   {  
     printf("\n");  
     for(j=0;j<rs;j++) <br="">       printf(" %d",bankers.claim[i][j]);  
     printf("\t");  
     for(j=0;j<rs;j++) <br="">       printf(" %d",bankers.allocation[i][j]);  
     printf("\t");  
     for(j=0;j<rs;j++) <br="">     {  
       bankers.need[i][j]=bankers.claim[i][j]-bankers.allocation[i][j];  
       printf(" %d",bankers.need[i][j]);  
     }  
   }  
   printf("\nCurrent avialble is :");  
   for(i=0;i<rs;i++) <br="">     printf("%d ", bankers.available[i]);  
   getch();  
 }  
 int safe(int rs,int nm,int resource[maxn],banker bankers)  
 {  
  int array[maxn],possible=1,i=0,j=0,k=0 ,flag[10];  
  banker b=bankers;  
  for(i=0;i<nm;i++) <br="">  {   array[i]=0;  
   flag[i]=0;  
  }  
  for(i=0;i<nm;i++) <br="">  {  
    if(flag[i]==0)  
    {  
     for(j=0;j<rs;j++) <br="">     {  
       if(b.need[i][j]<=b.available[j])  
       {  
         possible=0 ;  
       }  
       else  
       {  
         possible=1;  
         break;  
       }  
     }  
     if(possible==1)  
     {  
       printf("\n%d PROCESS CAN NOT PROCESSED",i) ;  
     }  
     else  
     {  
       printf("\nPROCESS%d IS PROCESSING",i) ;  
       for(j=0;j<rs;j++) <br="">       {  
         b.available[j]+=b.allocation[i][j];  
         b.allocation[i][j]=0;  
         b.claim[i][j]=0;  
       }  
       flag[i]=1;  
       array[k++]=i;  
       i=-1;  
       display(nm,rs,resource,b);  
     }  
    }  
  }  
 for(i=0;i<4;i++)  
 {  
   if(flag[i])  
     k=1;  
   else {  
     k=0;  
     break;  
     }  
 }  
 if(k==1)  
 {  
   printf("\n System is in safe state with sequence");  
 }  
 for(i=0;i<nm;i++) <br="">   printf(" %d",array[i]);  
 getch();  
 return k;  
 }

 


 

 

Other Projects to Try:

  1. Paging Algorithms using C language OS problem
  2. Krushkals algorithm Code in C Language
  3. Prims algorithm Code in C Language
  4. Operations on matrices like addition, multiplication, saddle point, magic square ,inverse & transpose
  5. Set operations – Union, Intersection, Difference, Symmetric Difference using C

Inter process Communication(IPC)-Client Code

by Leave a Comment

Inter process Communication(IPC) client Server  Code Operating System Problem

 

Inter process Communication Client Code using C language

 

  • Interprocess Communication for Producer Consumer problem in UNIX (Pipes or Shared Memory)
  • Students must submit the term work in the form of journal.
  • Each assignment has to be well documented with problem definition, theory and code documentation.
  • Staff in charge will assess the assignments continuously and grade or mark each assignment on completion date declared for each assignments.

IPC Client Code using C language

 

 #include  
 #include  
 #include  
 #include  
 #define SIZE 124  
 int main()  
 {  
   char *buff,*str;  
   buff=(char*)malloc(124);  
   str=(char*)malloc(124);  
 *str='\0';    
 int shmid,i=0;  
   if((shmid=shmget(9999,SIZE,IPC_CREAT|0666))<0)  
   printf("\nERROR IN SHMID\n");  
   if((buff=shmat(shmid,NULL,0))<0)  
     printf("ERROR IN SHM ATTACH\n");  
 while(1)  
   {  
     if(*str!='\0')  
     {  
     printf("\nTHE SERVER JUST SEND THIS MESSAGE\n\n");  
     fputs(str,stdout);  
     break;  
     }  
 strncpy(str,buff,SIZE);  
   }  
 *str='\0';  
 *buff='\0';  
 printf("\nREPLY \n\n");  
 fgets(str,SIZE,stdin);  
 strncpy(buff,str,SIZE);  
 sleep(1);  
 *buff='\0';  
 return(0);  
 }  
 Server   
 #include  
 #include  
 #include  
 #include  
 #define SIZE 124  
 int main()  
 {  
   char *buff,*str;  
   buff=(char*)malloc(124);  
   str=(char*)malloc(124);  
   int shmid;  
   if((shmid=shmget(9999,SIZE,IPC_CREAT|0666))<0)  
   printf("\nERROR IN SHMID\n");  
   if((buff=shmat(shmid,NULL,0))<0)  
     printf("ERROR IN SHM ATTACH\n");  
   printf("\nWRITE YOUR MSG\n");  
   fgets(str,SIZE,stdin);  
   strncpy(buff,str,SIZE);  
 sleep(1);  
 *buff='\0';  
 *str='\0';  
 printf("\n SERVER IS WAITING FOR REPLY........\n");  
 while(1)  
 {  
 if(*str!='\0')  
 {  
 printf("\nCLIENT JUST GAVE REPLY\n");  
 fputs(str,stdout);  
 break;  
 }  
 strncpy(str,buff,SIZE);  
 }  
   return(0);  
 }

 

Other Projects to Try:

  1. Regular Expression to DFA Code in C Language
  2. Lexical analyzer Code in C Language
  3. Dijkstra Algorithm in C Language
  4. string operations such as Copy, Length, Reversing, Palindrome, Concatenation
  5. Macro Processor Pass Two in C Language

Paging Algorithms using C language OS problem

by 2 Comments

 Paging Algorithms Operating System

 

Write the simulation Paging Algorithms program for demand paging and show the page scheduling and total number of page faults according to MFU page replacement algorithm. Assume the memory of ‘n’ frames.

Paging Algorithms using C language

 # include  
 # include  
 # include  
 # define maxn 50  
 typedef struct  page  
 {  
   int frame ;  
   int count[maxn],curr[maxn] ;  
 }page ;  
 struct page p ;  
 void fifo(int pages,int page[]) ;  
 void lru(int pages ,int page[]) ;  
 void optimal(int pages,int page[]) ;  
 void main()  
 {  
  int ch=0,pages=0,i,j,page[maxn],frames=0,temp3,temp4 ;  
  char temp ;  
  clrscr() ;  
  do  
  {  
    printf("\t\t\t\****main menu****\n") ;  
    printf("\t\t\t1.enter the page information\n");  
    printf("\t\t\t2.dispaly page info\n");  
    printf("\t\t\t3.fifo\n" );  
    printf("\t\t\t4.\lru\n") ;  
    printf("\t\t\t5.\optimal\n") ;  
    printf("\t\t\t6.exit\n");  
    printf("\t\t\tenter ur choice\n");  
   scanf("%d",&ch);  
   switch (ch)  
   {  
    case 1:  
      clrscr();  
      printf("enter the no of pages\n");  
      scanf("%d",&pages) ;  
      printf("enter pages\n");  
      for(i=0;i<pages;i++) <br="">      {  
       printf("page %d\n",i);  
       scanf("%d",&page[i]) ;  
      }  
      printf("enter number of frames .....\n");  
      scanf("%d",&p.frame) ;  
      break ;  
    case 2:  
      printf("no of pages%d\n",pages);  
       printf("page sequence \n");  
       for(i=0;i<pages;i++) <br="">       {  
       printf("page %d\n",page[i]);  
       }  
       printf("no of frames/%d",p.frame);  
      break ;  
    case 3:  
       fifo(pages,page) ;  
       break ;  
    case 4:  
       lru(pages ,page);  
      break ;  
    case 5:  
        optimal(pages ,page);  
      break ;  
    case 6:  
      break ;  
   }  
 }while(ch!=6 );  
 }  
 void fifo(int pages,int page[])  
 {  
  int i,j,k,flag=0,temp=0,fault=0 ;  
  for(i=0;i<p.frame;i++) <br="">

  {  
     p.curr[i]=-1 ;  
     p.count[i]=100 ;  
     printf("\tpage%d",i+1) ;  
  }  
  printf("\tfault\n\n");  
  for(i=0;i<pages;i++) <br="">  {  
     flag=0 ;  
     temp=0 ;  
     for(j=0;j<p.frame;j++) <br="">

     {  
           if(p.curr[j]==page[i])  
           {  
             flag=1 ;  
             break ;  
           }  
           if(temp<p.count[j]) <br="">

           {  
               temp=p.count[j] ;  
               k=j ;  
           }  
     }  
     for(j=0;j<p.frame;j++) <br="">

     {  
         if(flag==0 && k==j)  
         {  
           p.curr[j]=page[i] ;  
           p.count[j]=1 ;  
           fault++ ;  
         }  
         else  
         if(j<fault) <br="">         p.count[j]++;  
         if(p.curr[j]!=-1)  
         printf("\t%d",p.curr[j]) ;  
     }  
     if(flag==0)  
     printf("\t\t\t*") ;  
     printf("\n") ;  
  }  
  printf("no of page fault%d",fault);  
 }  
 void lru(int pages ,int page[])  
 {  
  int i,j,k,flag=0,temp=0,fault=0 ;  
  for(i=0;i<p.frame;i++) <br="">

  {  
     p.curr[i]=-1 ;  
     p.count[i]=100 ;  
     printf("\tpage%d",i+1) ;  
  }  
  printf("\tfault\n\n");  
  for(i=0;i<pages;i++) <br="">  {  
     flag=0 ;  
     temp=0 ;  
     for(j=0;j<p.frame;j++) <br="">

     {  
           if(p.curr[j]==page[i])  
           {  
             flag=1 ;  
             p.count[j]=0 ;  
             break ;  
           }  
           if(temp<p.count[j]) <br="">

           {  
               temp=p.count[j] ;  
               k=j ;  
           }  
     }  
     for(j=0;j<p.frame;j++) <br="">

     {  
         if(flag==0 && k==j)  
         {  
           p.curr[j]=page[i] ;  
           p.count[j]=1 ;  
           fault++ ;  
         }  
         else  
         if(j<fault) <br="">         p.count[j]++;  
         if(p.curr[j]!=-1)  
         printf("\t%d",p.curr[j]) ;  
     }  
     if(flag==0)  
     printf("\t\t\t*") ;  
     printf("\n") ;  
  }  
  printf("no of page fault%d",fault);  
 }  
 void optimal(int pages,int page[])  
 {  
  int i,j,k,flag=0,temp=0,fault=0,s ;  
  for(i=0;i<p.frame;i++) <br="">

  {  
     p.curr[i]=-1 ;  
     p.count[i]=100 ;  
     printf("\tpage%d",i+1) ;  
  }  
  printf("\tfault\n\n");  
  for(i=0;i<pages;i++) <br="">  {  
     flag=0 ;  
     temp=0 ;  
     for(j=0;j<p.frame;j++) <br="">

     {  
           if(p.curr[j]==page[i])  
           {  
             flag=1 ;  
             p.count[j]=0 ;  
             break ;  
           }  
           if(temp<p.count[j]) <br="">

           {  
               temp=p.count[j] ;  
               k=j ;  
           }  
     }  
     for(j=0;j<p.frame;j++) <br="">

     {  
         if(flag==0 && k==j)  
         {  
           p.curr[j]=page[i] ;  
           p.count[j]=0 ;  
           fault++ ;  
         }  
         else  
         if(j<fault) <br="">         {  
           p.count[j]=0 ;  
           for(s=i+1;s<pages;s++) <br="">           {  
             if(page[i]==p.curr[j])  
             break ;  
             else  
             p.count[j]++ ;  
           }  
         }  
         p.count[j]++;  
         if(p.curr[j]!=-1)  
         printf("\t%d",p.curr[j]) ;  
     }  
     if(flag==0)  
     printf("\t\t\t*") ;  
     printf("\n") ;  
  }  
  printf("no of page fault%d",fault);  
 }

 

Other Projects to Try:

  1. Bankers Algorithm using C Language OS problem
  2. How to Implement Hash Table using C language
  3. Operations on matrices like addition, multiplication, saddle point, magic square ,inverse & transpose
  4. Hash table code in C Language
  5. string operations such as Copy, Length, Reversing, Palindrome, Concatenation

Readers Writers Problem using Semaphores

by 2 Comments

Readers Writers Problem using Semaphores

 

Reader Priority problem

 

Readers Writers Problem using SemaphoresReaders Writers problem in operating system for solving synchronization problem can be solved. This program is for unix machine as their only you can run this code. This program demonstrate reader priority code for reader writer problem.
Problem statement for implement Readers Writers problem using semaphores with reader  priority using C language. Use mutex and semaphores to implement above problem in c language environment.

In the reader priority case, the reader will always be given priority to other processes. Writer has to wait every time if their is any read request to be completed. So by this simulation of readers writers problem we can see how actually this problem can be tackled in real time. 

In the context of concurrent programming, the “reader priority case” refers to a scenario where readers are given precedence over writers when accessing a shared resource, such as a database or a file. This means that if there are both read and write requests pending, the system will prioritize servicing the read requests first before attending to any write requests.

In this scenario, whenever a writer wants to access the shared resource, it has to wait if there are any ongoing read operations. This ensures that readers are not kept waiting indefinitely and that their access to the resource is not unnecessarily delayed by write operations.

Simulating the readers-writers problem allows us to observe how different strategies for managing access to shared resources perform in real-world scenarios. By implementing and analyzing various algorithms and techniques for handling concurrent read and write operations, we can gain insights into the trade-offs involved and determine the most efficient and fair approach for different applications.

In essence, through this simulation, we can understand and evaluate the mechanisms for managing reader and writer access to shared resources in a real-time environment, helping us design more robust and efficient concurrent systems.

Readers Writers Problem Code

 

 #include   
 #include   
 #include   
 void * reader(void *) ;  
 void *writer (void *) ;  
 sem_t wsem,mutex ;  
 int readcount=0 ;  
 main()  
 {  
  int a=1,b=1;  
     system("clear");  
  sem_init(&wsem,0,1) ;  
  sem_init(&mutex,0,1) ;  
  pthread_t r,w,r1,w1 ;  
  pthread_create(&r,NULL,reader,(void *)a);  
     a++;  
  pthread_create(&w1,NULL,writer,(void *)b);  
     b++;  
  pthread_create(&r1,NULL,reader,(void *)a);  
  pthread_create(&w,NULL,writer,(void *)b);  
  pthread_join(r,NULL);  
  pthread_join(w1,NULL);  
  pthread_join(r1,NULL);  
  pthread_join(w,NULL) ;  
  printf("main terminated\n");  
 }  
 void * reader(void * arg)  
 {  
  int c=(int)arg ;  
  printf("\nreader %d is created",c);  
     sleep(1);  
  sem_wait(&mutex) ;  
     readcount++;  
     if(readcount==1)  
         sem_wait(&wsem) ;  
  sem_post(&mutex) ;  
 /*Critcal Section */  
  printf("\n\nreader %d is reading\n ",c);  
  sleep(1) ;  
  printf("\nreader%d finished reading\n",c);  
 /* critical section completd */  
  sem_wait(&mutex) ;  
     readcount-- ;  
     if(readcount==0)  
         sem_post(&wsem) ;  
  sem_post(&mutex) ;  
 }  
 void * writer(void * arg)  
 {  
  int c=(int)arg ;  
  printf("\nwriter %d is created",c);  
     sleep(1);  
  sem_wait(&wsem) ;  
  printf("\nwriter %d is writing\n",c) ;  
  sleep(1);  
  printf("\nwriter%d finished writing\n",c);  
  sem_post(&wsem) ;  
 }

 Download Readers writers problem using semaphore

Other Projects to Try:

  1. Readers-writers problem using Semaphore
  2. Queue Operations using C Language
  3. Matrix Operations in C Language
  4. Breadth First and Depth First Search C Language
  5. To Perform File Handling in Java

Readers-writers problem using Semaphore

by Leave a Comment

Readers-writers problem using Semaphore

Objective 

In this post, we will see Readers-writers problem code using C Language and we will try to understand how to solve this problem.

 

Readers writers problem using SemaphoreReaders-writers problem in c is the Synchronization problem which can be solved by using this algorithm. This code is written to run on Linux or Unix machines. So for running this code, you must have UNIX system with c compiler installed on it then only you can run these programs. The main reason that we require the Unix system is that we can only test reader-writer problem on Unix system.

Readers-writers problem is Mutual Exclusion and Synchronization problem which can solve by semaphores and monitors. Here is the Source Code for writer priority using C under reader and writer problem. Reader-writer code can be implemented in C on Linux.

We have declared two variables named as reading count and write count which will count the read and write to control the synchronization problem. Only the read or write permission will be given based on these variables. So we can say that it is a way in which we should handle the reader and writer. 

Mutual Exclusion and Synchronization are like the traffic rules of computer programs, ensuring that multiple threads or processes play nicely together when using shared resources. Imagine a semaphore as a traffic light: it tells threads when to stop and when to go, preventing them from crashing into each other while accessing shared data. Monitors, on the other hand, are like gated communities for data, where access is carefully controlled through a single entrance. Inside, everyone follows the rules, taking turns and waiting patiently when needed. Both semaphores and monitors offer smart ways to keep our programs running smoothly, preventing chaos and ensuring that everyone gets their fair share of resources.

Reader Writer problem using Reader Priority code can be found here.

Readers writers problem Code


#include   
#include   
#include 

void * reader(void *) ;  
void *writer (void *) ;  
sem_t x,y,z,wsem,rsem ;  
int readcount=0 ;  
int writecount=0 ;  

main()  
{  
  int a=1,b=1;  
  system("clear");  
  sem_init(&wsem,0,1) ;  
  sem_init(&x,0,1) ;  
  sem_init(&rsem,0,1) ;  
  sem_init(&y,0,1) ;  
  sem_init(&z,0,1) ;  

  pthread_t r,w,r1,w1,r2,r3,w2,w3 ;  
  pthread_create(&r,NULL,reader,(void *)a);  
     a++;  
  pthread_create(&r1,NULL,reader,(void *)a);  
     a++;  
  pthread_create(&w,NULL,writer,(void *)b);  
     b++;  
   pthread_create(&w1,NULL,writer,(void *)b);  
     b++;  
  pthread_create(&r2,NULL,reader,(void *)a);  
     a++;  
  pthread_create(&w2,NULL,writer,(void *)b);  
     b++;  
  pthread_create(&r3,NULL,reader,(void *)a);  
     a++;  
  pthread_create(&w3,NULL,writer,(void *)b);  
  pthread_join(r,NULL);  
  pthread_join(r1,NULL);  
  pthread_join(w,NULL);  
  pthread_join(w1,NULL);  
  pthread_join(r2,NULL);  
  pthread_join(w2,NULL) ;  
  pthread_join(r3,NULL);  
  pthread_join(w3,NULL);  
  printf("main terminated\n");  
 }  

void * reader(void * arg)  
{  
   int c=(int)arg ;  
   printf("\nreader %d is created",c);  
   sleep(1);  
   sem_wait(&rsem);  
   sem_wait(&x) ;  
   readcount++;  
   if(readcount==1)  
         sem_wait(&wsem) ;  
   sem_post(&x) ;  
   sem_post(&rsem);  
   sleep(1)  

 /*Critcal Section */  

  printf("\n\nreader %d is reading\n ",c);  
  sleep(1) ;  
  printf("\nreader%d finished reading\n",c); 

 /* critical section completd */  
  sem_wait(&x) ;  
  readcount-- ;  
  if(readcount==0)  
     sem_post(&wsem) ;  
  sem_post(&x) ;  
 } 

void * writer(void * arg)  
{  
  int c=(int)arg ;  
  printf("\nwriter %d is created",c);  
  sleep(1);  
  sem_wait(&y) ;  
  writecount++ ;  
  if(writecount==0)  
      sem_wait(&rsem) ;  
  sem_post(&y) ;  
  sem_wait(&wsem) ;  
  printf("\nwriter %d is writing\n",c) ;  
  sleep(1);  
  printf("\nwriter%d finished writing\n",c);  
  sem_post(&wsem) ;  
  sem_wait(&y) ;  
  writecount-- ;  
  if(writecount==0)  
      sem_post(&rsem) ;  
  sem_post(&y) ;  
 }

In conclusion, this article provides an in-depth exploration of the Readers-Writers problem in C Language, offering valuable insights into concurrent resource management. Through detailed analysis and practical code examples, readers gain a solid understanding of synchronization techniques and deadlock prevention strategies. Readers-Writers problem in C, concurrent resource access, and synchronization techniques, this content aims to enhance visibility and accessibility for programmers seeking solutions to concurrency challenges. With this comprehensive guide, readers can master the complexities of concurrent programming in C, empowering them to develop robust and efficient systems.

Download Source Code

Please use the below link for downloading source code.

Download Source Code

 

Other Projects to Try:

  1. Readers Writers Problem using Semaphores
  2. Regular Expression to DFA Code in C Language
  3. Breadth First and Depth First Search C Language
  4. String Operations in C Program
  5. Hoffmans algorithm in C Language