procs, fork() i mutexes

Question

Chcę utworzyć n procesów działających równolegle i mieć je zablokować mutex, inkrementacja licznika, a następnie odblokować i wyjść.

Oto mój kod:

#include <stdio.h> 
#include <stdlib.h> 
#include <sys/wait.h> 
#include <sys/types.h> 
#include <sys/mman.h> 
#include <unistd.h> 
#include <pthread.h> 

pthread_mutex_t mutex; 

int main(int argc, char **argv) { 

    if (argc != 2) 
    return 0; 
    int n = atoi(argv[1]); 
    int i = 0; 
    int status = 0; 

    pthread_mutex_init(&mutex, NULL); 

    pid_t pid = 1; 
    static int *x; 
    x = mmap(NULL, sizeof *x, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); 
    *x = 0; 

    printf("Creating %d children\n", n); 

    for(i = 0; i < n; i++) { 
    if (pid != 0) 
     pid = fork(); 
    } 

    if (pid == 0) { 
    pthread_mutex_lock(&mutex); 
    *x = *x + 1; 
    printf("[CHLD] PID: %d PPID: %d X: %d\n", getpid(), getppid(), *x); 
    pthread_mutex_unlock(&mutex); 
    exit(0); 
    } 

    wait(&status); 

    printf("[PRNT] PID: %d X: %d\n", getpid(), *x); 
    munmap(x, sizeof *x); 

    return 0; 
} 

./procs 10000 jednak nie wraca z x = 10000 Myślę, że to dlatego, że mutex nie jest dzielone między procesami, ale co to jest poprawny sposób udostępniać muteks?

Answer 1

Oto port mojego przykładu w komentarzu za pomocą pthread_mutex. Pierwszy raz to zrobiłem, ale wygląda na to, że działa:

#include <stdio.h> 
#include <assert.h> 
#include <unistd.h> 
#include <stdbool.h> 
#include <fcntl.h> 
#include <sys/mman.h> 
#include <pthread.h> 

typedef struct 
{ 
    bool done; 
    pthread_mutex_t mutex; 
} shared_data; 

static shared_data* data = NULL; 

void initialise_shared() 
{ 
    // place our shared data in shared memory 
    int prot = PROT_READ | PROT_WRITE; 
    int flags = MAP_SHARED | MAP_ANONYMOUS; 
    data = mmap(NULL, sizeof(shared_data), prot, flags, -1, 0); 
    assert(data); 

    data->done = false; 

    // initialise mutex so it works properly in shared memory 
    pthread_mutexattr_t attr; 
    pthread_mutexattr_init(&attr); 
    pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); 
    pthread_mutex_init(&data->mutex, &attr); 
} 

void run_child() 
{ 
    while (true) 
    { 
     puts("child waiting. .. "); 
     usleep(500000); 

     pthread_mutex_lock(&data->mutex); 
     if (data->done) { 
      pthread_mutex_unlock(&data->mutex); 
      puts("got done!"); 
      break; 
     } 
     pthread_mutex_unlock(&data->mutex); 
    } 

    puts("child exiting .."); 
} 

void run_parent(pid_t pid) 
{ 
    puts("parent sleeping .."); 
    sleep(2); 

    puts("setting done .."); 
    pthread_mutex_lock(&data->mutex); 
    data->done = true; 
    pthread_mutex_unlock(&data->mutex); 

    waitpid(pid, NULL, NULL); 

    puts("parent exiting .."); 
} 

int main(int argc, char** argv) 
{ 
    initialise_shared(); 

    pid_t pid = fork(); 
    if (!pid) { 
     run_child(); 
    } 
    else { 
     run_parent(pid); 
    } 

    munmap(data, sizeof(data)); 
    return 0; 
}