在C中使用信号量和共享内存

Question

The program should create 200000 integers and write 2000 to a shared memory. A forked process should read 2000 from shared memory and the parent should write the next 2000 to shared memory.

if i use the code below without sleep, the parent first creates all 200000 integers and then the child reads the same integers from shared memory.

With sleep everything looks good, but we have to use semaphore.

shm.c (parent):

    #include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <sys/sem.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <sys/resource.h>
    #include <sys/wait.h>

    #define N_DATA 200000
    #define N_SHARED 2000
    #define LOCK       -1
    #define UNLOCK      1

    static struct sembuf semaphore;

    char shmidArg[32];
    char semidArg[32];
    int *shmData;
    int i, j;
    int status;
    char *strsignal(int sig);
    pid_t pid;

    static int shmid;
    static int semid;

    char *strsignal(int sig);

    /** Semaphore Operation */
    static int semaphore_operation (int op) {
       semaphore.sem_num = 1;
       semaphore.sem_op = op;
       semaphore.sem_flg = IPC_NOWAIT;
       if( semop (semid, &semaphore, 1) == -1) {
          perror(" semop ");
          exit (EXIT_FAILURE);
       }
       return 1;
    }

    int main(int argc, char **argv) {
      /* Ein Shared-Memory-Segment einrichten */
      shmid = shmget(IPC_PRIVATE, N_SHARED*sizeof(int), IPC_CREAT | SHM_R | SHM_W);
      if (shmid == -1) {
       perror("shmid");
       exit(1);
      }

      printf("Shared-Memory-ID: %d\n",shmid);

      /* Pointer zu Shared-Memory-Segment erhalten */
      shmData = (int *)shmat(shmid,0, 0);
      if (shmData == (int *)(-1)) {
          perror("shmat");
          exit(1);
      }

      /* Semaphore anlegen */
      semid = semget(IPC_PRIVATE, 1, IPC_CREAT | SHM_R | SHM_W);
      if (semid < 0) {
       perror("semid");
       exit(1);
      }

      printf ("Semaphor-ID : %d\n", semid);

      /* Semaphor mit 1 initialisieren */
    if (semctl (semid, 0, SETVAL, (int) 1) == -1) {
       perror("semctl");
    }

    snprintf(shmidArg,32, "%d", shmid);
    snprintf(semidArg,32, "%d", semid);

      /** erstellen des Kindprozesses */
      pid = fork();

      // Kindprozess
      if (pid == 0) {
        execlp("./shm_child",shmidArg,semidArg,NULL);
      } else if (pid < 0) {
            perror("Kindprozess konnte nicht erzeugt werden!");
            return 1;
        }
      // Elternprozess
      else {
        /** ininitalisieren des Zufallsgenerator durch aktuellen Zeitstempel */
        srand48(time(NULL));
        for(i=0;i<N_DATA;i=i+N_SHARED) {
          semaphore_operation(LOCK);
          for (j=0; j<N_SHARED; j++) {
            shmData[j] = lrand48();
            //MSZ
            //printf("SHM-->%d-->%d\n",i+1,shmData[i]);
          }
    //      if(i == 0 || i == 2000) {
            printf("Parent-->%d-->0-->%d\n",i,shmData[0]);
            printf("Parent-->%d-->1999->%d\n",i,shmData[1999]);
    //      }
          semaphore_operation(UNLOCK);
          //sleep(1);
        }
      }

      //MSZ
      //sleep(2);
      printf("PID: %d\n", pid);

      if (waitpid(pid, &status, 0) == -1) {
            perror("wait konnte nicht erzeugt werden!");
            return 1;
        }

        if (WIFEXITED(status)) {
            printf("Exitcode: %d\n", WEXITSTATUS(status));
        semctl (semid, 0, IPC_RMID, 0);
        shmctl (shmid, IPC_RMID, NULL);
        //If process terminaded by a signal
        } else if (WIFSIGNALED(status)) {
            printf("Signal: %d %s\n", WTERMSIG(status), strsignal(WTERMSIG(status)));
        semctl (semid, 0, IPC_RMID, 0);
        shmctl (shmid, IPC_RMID, NULL);
        }

    }

shm_child.c (Child):

        #include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <sys/sem.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/stat.h>

    #define N_DATA 6000
    #define N_SHARED 2000
    #define LOCK       -1
    #define UNLOCK      1

    int i,j;
    int *shmData;
    static int shmid;
    static int semid;
    static struct sembuf semaphore;


    /** Semaphore Operation */
    static int semaphore_operation (int op) {
       semaphore.sem_num = 0;
       semaphore.sem_op = op;
       semaphore.sem_flg = SEM_UNDO;
       if( semop (semid, &semaphore, 1) == -1) {
          perror(" semop ");
          exit (EXIT_FAILURE);
       }
       return 1;
    }

    int main(int argc, char **argv) {
      shmid = atoi(argv[0]);
      semid = atoi(argv[1]);

      printf("\nshm_child shared memoryid:%d\n",shmid);
      printf("shm_child Semaphoren-ID:%d\n",semid);

      /* Pointer auf Shared-Memory erstellen */
      shmData = (int *)shmat(shmid,0,0);
      if (shmData == (int *)(-1)) {
          perror("shmat");
          exit(1);
      }


    for(i=0;i<N_DATA;i=i+N_SHARED) {
      semaphore_operation(LOCK);
      for(j=0;j<N_SHARED;j++) {
        //printf("%d-->%d --> %d\n",i,j+1,shmData[j]);
      }
    //  if(i == 0 || i == 2000) {
        printf("child-->%d-->0-->%d\n",i,shmData[0]);
        printf("child-->%d-->1999->%d\n",i,shmData[1999]);
    //  }
      semaphore_operation(UNLOCK);
      sleep(1);
    }

      return 0;
    }

Please help us Thank you guys

Edit: Thank you very much for your answers. I can't mark the right answer because i dont know what its right. But i dont want try anything more. 15 hours are enough

Answer 1

The writer process shall give reader a permission to read, and wait for the reading completion. After that the reader shall give writer a permission to proceed, and wait for writing completion.

This goal cannot be achieved with a single semaphore. You need two, along the lines of:

    // parent aka writer
    writer_barrier = semaphore(UNLOCKED);
    reader_barrier = semaphore(LOCKED);
    start_reader();
    while(...) {
        lock(writer_barrier);
        write_data();
        unlock(reader_barrier);
    }

    // child aka reader
    while(....)
        lock(reader_barrier);
        read_data();
        unlock(writer_barrier);
    }