Comment puis-je synchroniser les accès à la mémoire partagée dans LynxOS/POSIX?

Je suis en œuvre deux processus sur un LynxOS SE POSIX (conforme) système de communication par mémoire partagée.

Un processus de va agir comme un "producteur" et de l'autre un "consommateur". Dans un environnement multi-thread système de mon approche serait d'utiliser un mutex et condvar (variable d'état) de la paire, avec le consommateur en attente sur le condvar (avec pthread_cond_wait) et le producteur de signalisation (avec pthread_cond_signal) lorsque la mémoire partagée est mise à jour.

Comment puis-je atteindre cet objectif dans un multi-processus, plutôt que de multi-thread, de l'architecture?

Est-il un LynxOS/POSIX façon de créer un condvar/mutex paire qui peut être utilisé entre les processus?

Ou d'un autre mécanisme de synchronisation plus appropriée dans ce scénario?

Merci @nsa, j'avais remarqué qu'il y avait un pthread_condattr_setpshared mais j'ai raté le pthread_attr_setscope. Si vous modifiez votre commentaire à la réponse, je vais upvote.
Semble que j'avais un peu mal informé, pthread_condattr_setpshared est en effet ce que vous pouvez utiliser, pthread_attr_setscope traite de la planification des threads.

OriginalL'auteur GrahamS | 2010-04-06

  1. 5

    Le moyen standard pour créer un processus partagé mutex/cond. variable est de les initialiser avec un attribut de l'endroit où vous définissez pthread_mutexattr_setpshared/pthread_condattr_setpshared. Vérifier si LynxOS prend en charge.

    Vous aurez naturellement besoin de mutex/cond. les variables dans la mémoire partagée, en quelque sorte, alors tous les processus de l'utiliser.

    Merci @ns. J'ai élargi votre réponse un peu.

    OriginalL'auteur nos

  2. 21

    De crédit va à @nsa, mais j'aimerais développer un peu sa réponse.

    En fin de compte (à l'exclusion de la gestion d'erreur pour plus de clarté) j'ai fait comme suit:

    1. Définir la mémoire partagée de la structure

    Il contient de l'inter-processus de synchronisation des objets et les données à partager.

    typedef struct
{
    //Synchronisation objects
    pthread_mutex_t ipc_mutex;
    pthread_cond_t  ipc_condvar;
    //Shared data
    int number;
    char data[1024];
} shared_data_t;

    2. Créer de la mémoire partagée et la taille de l'ensemble (processus Maître)

    Sur la Maîtrise du processus de créer une nouvelle mémoire partagée objet: 

    fd = shm_open(SHAREDMEM_FILENAME, O_CREAT|O_EXCL|O_RDWR, S_IRUSR|S_IWUSR);
ftruncate(fd, sizeof(shared_data_t));

    2. OU Ouvrir la mémoire partagée (Esclave processus)

    Sur l'Esclave, juste l'attacher à un objet existant:

    fd = shm_open(SHAREDMEM_FILENAME, O_RDWR, S_IRUSR|S_IWUSR);

    3. Mmap dans l'espace de processus

    shared_data_t* sdata = (shared_data_t*)mmap(0, sizeof(shared_data_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
close(fd);

    4. Initialiser les variables de synchronisation (processus Maître uniquement)

    pthread_mutexattr_t mutex_attr;
pthread_mutexattr_init(&mutex_attr);
pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init(&sdata->ipc_mutex, &mutex_attr);

pthread_condattr_t cond_attr;
pthread_condattr_init(&cond_attr);
pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED);
pthread_cond_init(&sdata->ipc_condvar, &cond_attr);

    .

    Mutex et cond peut maintenant être utilisé comme normal pour contrôler l'accès aux données partagées.

    Les seuls véritables pièges à ce que le Maître a engendré de la mémoire partagée et les initialisé la synchronisation des variables avant l'Esclave processus est lancé. Et assurez-vous de ranger avec munmap() et shm_unlink() que nécessaire.

    Remarque: XSI Alternative

    POSIX:XSI extension a d'autres fonctions pour le partage de la mémoire (shmget(), shmat() etc) qui peut être plus utile si ils sont disponibles, mais ils ne sont pas sur la version de LynxOS-SE que j'utilise.

    REMARQUE: Nous avons rencontré des problèmes avec cette approche sur LynxOS. Si une autre mémoire est mmap ed en avant de ce alors il va échouer. Voir stackoverflow.com/questions/2782883/...
    Dans le #2 du code de l'esclave processus, j'ai aussi eu à faire appel ftruncate(fd, sizeof(shared_data_t)) après l'appel de shm_open. C'est juste les paramètres de shm_open qui diffèrent entre maître et de l'esclave pour le #2. Sans le ftruncate dans la traite des esclaves, j'ai été faire EFAULT et d'autres erreurs lorsque vous essayez d'utiliser un flexible de membre de tableau à la fin de ma structure.

    OriginalL'auteur GrahamS

  3. 6

    C'est fait avec sans nom sémaphores POSIX, c'est à dire les sémaphores sont eux-mêmes placés dans la mémoire partagée.

    Est-il un avantage à utiliser sans nom sémaphores POSIX, au lieu de nom les sémaphores POSIX?
    Sans nom sémaphores sont très rapides entre les processus non-soutenu cas en évitant un appel système.

    OriginalL'auteur Nikolai Fetissov

  4. 5

    Vous pouvez réaliser cela avec la mémoire partagée/sémaphore de la CIB.

    Voici un article avec un joli exemple:

    http://www-personal.washtenaw.cc.mi.us/~chasselb/linux275/ClassNotes/ipc/shared_mem.htm

    +1 vraiment sympa l'article

    OriginalL'auteur mcabral