0

I wrote a program to write 0's and 1's` into shared buffer and read the data from shared buffer in C language

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/times.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/wait.h>

#define FILE_SIZE 11
#define NO_PROC   10

int DelayCount = 0;

int readerID = 0;
int writerID = 0;

char* shared_buffer;

const int LOOP_TIME = 3;

/* The reader */

 void reader() {

    int i,j;
    char results[FILE_SIZE];

    printf("Reader %d (pid = %d) arrives\n", readerID, getpid());

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

        printf("   Reader %d starts round %d\n", readerID,i);
        /* read data from shared data */

         for (j=0; j<FILE_SIZE; j++) {

             results[j] = shared_buffer[j];
             sleep(2);
         }

    /* display result */
    results[j] = 0;
    printf("Reader %d (round %d) gets results : %s\n", readerID, i, results);
   }
}




  /* The writer */
  void writer() {

   int i,j;
   char data[FILE_SIZE];


   for (j=0; j<FILE_SIZE-1; j++) {
      data[j]= writerID + '0';
   }
   data[j]= 0;

   printf("Writer %d (pid = %d) arrives, writing %s to buffer\n",
          writerID, getpid(), data);


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

 printf("   Write %d starts round %d\n", writerID,i);

/* write to shared buffer */
for (j=0; j<FILE_SIZE-1; j++) {
  shared_buffer[j]= data[j];
  sleep(1);  
    }

    printf("Writer %d (round %d) finishes\n", writerID, i);
  }
 }


 /* creating readers and writers */

 void create_reader() {
   if (0 == fork()) {
      reader();
      exit(0);
   }

    readerID++;
 }

void create_writer() {
    if (0 == fork()) {
       writer();
       exit(0);
   }

  writerID++;
}



/* main */
void main() {

 int return_value;
 char InitData[]="0000000000\n";
 int i;
 int fd;


 /* creates a memory region shared by all child processes */

 fd = open("race.dat", O_RDWR | O_CREAT | O_TRUNC, 0600);
if ( fd < 0 ) {
   perror("race.dat ");
   exit(1);
 }

write(fd, InitData, FILE_SIZE);

unlink("race.dat"); 


shared_buffer = mmap(0, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if ( shared_buffer == (caddr_t) -1) {
 perror("mmap");
 exit(2);
 }
 

 /* Create readers and writes */

create_reader();
sleep(1);
create_writer();
sleep(1);
create_writer();


 /* Wait until all children terminate */
 for (i=0; i<(readerID+writerID); i++) {
  wait(NULL);
   }
}

But currently while reading the buffer the output is mix match of 0's and 1's like below

Reader 0 (pid = 8352) arrives
  Reader 0 starts round 0
Writer 0 (pid = 8355) arrives, writing 0000000000 to buffer
  Write 0 starts round 0
Writer 1 (pid = 8356) arrives, writing 1111111111 to buffer
  Write 1 starts round 0
Writer 0 (round 0) finishes
  Write 0 starts round 1
Writer 1 (round 0) finishes
  Write 1 starts round 1
Writer 0 (round 1) finishes
  Write 0 starts round 2
Reader 0 (round 0) gets results : 0001111111

 Reader 0 starts round 1
Writer 1 (round 1) finishes
 Write 1 starts round 2
Writer 0 (round 2) finishes
 Writer 1 (round 2) finishes
Reader 0 (round 1) gets results : 0111111111

 Reader 0 starts round 2
Reader 0 (round 2) gets results : 1111111111

I looked at this article and trying to use semaphores to make buffer synchronized and lock while one process is writing and reading, i want the others to wait until all 0's are written and read

ark
  • 1
  • 1

0 Answers0