Accessing a shared memory buffer in another process

Question

I am trying to solve the producer consumer problem using mutexes and a shared buffer, but am having trouble accessing values in my shared buffer struct, specifically the char array. When I invoke the producer.c file in one terminal and print the values (the input is a txt file of the alphabet) using

printf("%c", newBuff->bytes[newBuff->rear]); 

the chars do appear as normal, however when I do the same thing in consumer.c, but with

printf("%c", newBuff->bytes[newBuff->front]);

the values appear blank. The newBuff->front value is zero, so it should print the letter a. When I access other values in my struct in consumer.c like front, count, or rear they are correct. Share memory creation as well as attachment also works properly so I believe the issue is either I am not storing the char values properly in the array or I am trying to access them incorrectly. In the code below I placed the printf in the loop for producer.c and then outside the loop for consumer.c so I know for a fact a value is present before the consumer starts extracting data.

Consumer.c

typedef struct buffer{
    pthread_mutex_t lock;
    pthread_cond_t shout;
    int front;
    int rear;
    int count;
    int endOfFile;
    char bytes[1024];
} buffer;


int main(int argc, char const *argv[]) {
    int i=0;
    FILE *file = fopen(argv[1], "w");
    if (argc != 2){
        printf("You must enter in a file name\n");
    }
    int shmid, swapCount=0;
    char swapBytes[] = "";
    char path[] = "~";
    key_t key = ftok(path, 7);
    buffer* newBuff;
    if ((shmid = shmget(key, SIZE, 0666 | IPC_CREAT | IPC_EXCL)) != -1) {
        newBuff = (buffer*) shmat(shmid, 0, 0);
        printf("successful creation\n");
        newBuff->front = 0;
        newBuff->count = 0;
        newBuff->endOfFile = 0;
        pthread_mutexattr_t attr;
        pthread_condattr_t condAttr;

        pthread_mutexattr_init(&attr);
        pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
        pthread_mutex_init(&newBuff->lock, &attr);

        pthread_condattr_init(&condAttr);
        pthread_condattr_setpshared(&condAttr, PTHREAD_PROCESS_SHARED);
        pthread_cond_init(&newBuff->shout, &condAttr);
    } //shared memory creation

    else if ((shmid = shmget(key, 0, 0)) != -1){
        printf("%d\n", shmid);
        printf("successful attachment\n" );
        newBuff = (buffer*) shmat(shmid, 0, 0);
        printf("%c\n", newBuff->count);
    }
    else{
        printf("oops\n");
        exit(0);
    }
    pthread_mutex_lock(&newBuff->lock);
    printf("%c\n", newBuff->bytes[newBuff->front]);
    while (newBuff->endOfFile != 1)
    {
        while (newBuff->count == 0){
            pthread_cond_signal(&newBuff->shout);
            pthread_cond_wait(&newBuff->shout, &newBuff->lock);
        }
        newBuff->front = ((newBuff->front + 1)%SIZE);
        newBuff->count--;
    }
    pthread_mutex_unlock(&newBuff->lock);
    shmdt(&newBuff);

    //pthread_mutexattr_destroy(&attr);
    //pthread_condattr_destroy(&condAttr);*/

    return 0;
}

Producer.c

typedef struct buffer{
    pthread_mutex_t lock;
    pthread_cond_t shout;
    int front;
    int rear;
    int count;
    int endOfFile;
    char bytes[1024];
} buffer;


int main(int argc, char const *argv[]) {
    FILE *file = fopen(argv[1], "r");
    if (argc != 2){
        printf("You must enter in a file dumbass\n");
    }
    int shmid;
    char path[] = "~";
    key_t key = ftok(path, 7);
    buffer* newBuff;
    printf("dfasdfasdf\n");
    if ((shmid = shmget(key, SIZE, 0666 | IPC_CREAT | IPC_EXCL)) != -1) {
        newBuff = (buffer*) shmat(shmid, 0, 0);
        printf("successful creation\n");


        newBuff->front = 0;
        newBuff->count = 0;
        newBuff->endOfFile=0;
        pthread_mutexattr_t attr;
        pthread_condattr_t condAttr;

        pthread_mutexattr_init(&attr);
        pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
        pthread_mutex_init(&newBuff->lock, &attr);

        pthread_condattr_init(&condAttr);
        pthread_condattr_setpshared(&condAttr, PTHREAD_PROCESS_SHARED);
        pthread_cond_init(&newBuff->shout, &condAttr);
    } //shared memory creation

    else if ((shmid = shmget(key, 0, 0)) != -1){
        printf("successful attachment\n" );
        newBuff = (buffer*) shmat(shmid, 0, 0);
    }
    else{
        printf("oops\n");
        exit(0);
    }
    printf("%d\n", shmid);
    pthread_mutex_lock(&newBuff->lock);
    while (fscanf(file, "%c", &newBuff->bytes[newBuff->rear]) != EOF) //read in file
    {
        printf("%c\n", newBuff->bytes[newBuff->rear]);
        while (newBuff->count >= SIZE){ //buffer is full
            //("%c\n", newBuff->bytes[newBuff->rear]);
            pthread_cond_signal(&newBuff->shout);
            pthread_cond_wait(&newBuff->shout, &newBuff->lock);
        }
        //printf("%c\n", newBuff->bytes[newBuff->rear]);
        newBuff->rear = ((newBuff->front + 1)%SIZE);
        newBuff->count++;
    }
    newBuff->endOfFile = 1;
    pthread_cond_signal(&newBuff->shout);
    pthread_mutex_unlock(&newBuff->lock);

    shmdt(&newBuff);

    //pthread_mutexattr_destroy(&attr);
    //pthread_condattr_destroy(&condAttr);

    return 0;
}

Answer 1

There are several difficulties with your code, some already addressed in comments:

• ftok() requires the path passed to it to designate an existing file, but the path you are passing does not.

• You request less shared memory than you actually need: only the size of the buffer content, not of a whole struct buffer. Because the amount of shared memory actually allocated will be rounded up to a multiple of the page size, this may end up being ok, but you should ensure that it will be ok by requesting the amount you actually need.

• System V shared memory segments have kernel persistence, so once created, they will continue to exist until they are explicitly removed or the system is rebooted. You never remove yours. You also initialize its contents only when you first create it. Unless you manually delete it between runs, therefore, you'll use old data -- with the end-of-file indicator set, for instance -- on the second and subsequent runs. I suggest having the consumer schedule it for removal.

• The consumer prints only one byte of data from the buffer, and it does so before verifying that there is anything to read.

• After adding a byte to the buffer, the producer does not update the available byte count until after signaling the consumer. At best, this is wasteful, because the consumer will not see the change in count until the next time (if any) it wakes.

• The producer updates the rear index of the buffer incorrectly, based on the current front value instead of on the current rear value. The data will therefore not be written into the correct places in the buffer array.

• Once the producer sets the endOfFile flag, the consumer ignores all but one of any remaining unread bytes.

• If the producer leaves the count zero when it finishes, the consumer will deadlock.

I find that modified versions of your programs addressing all of these issues successfully and accurately communicate data through shared memory.

Update:

Also,

• The way in which consumer and / or producer initializes the mutex and condition variable is not itself safe. It is possible for whichever process attempts the shmget() second (or third, or ...) to access those objects before the first finishes initializing them. More generally, once a shared memory segment is attached, there is no inherent memory barrier involved in writing to it. To address these issues, the natural companion to SysV shared memory is SysV semaphores.