Compréhension sémaphores et mutex

Bonjour

Si mon sujet n'est pas dans la bonne rubrique je comprendrais aisément qu'on le déplace
pour autant il parle de sémaphore et de mutex codé en C sur eclipse dans le cadre d'un cours

je précise que je débute dans la compréhension du système de gestion de processus sous unix et linux et en général

or il y a des choses après avoir implémenté en c les algos des sémaphores et mutex que je pense ou pensais avoir compris
voici le problème :

j'ai 3 programmes ou projet sous eclipse (je met les codes des fichiers .c en pièces jointes)
Pièce jointe 207218 =>synchro.c // ou phase d'initialisation des sémaphores et execution des Fils lecteurs et redacteur
Pièce jointe 207219 =>lecteur.c
Pièce jointe 207220 =>redacteur.c

Pour essayer de comprendre j'ai affiché l’adresse d’attachement retour de shmat contenu dans *mem mais ça ne m'aide pas beaucoup plus pour comprendre les résultats
(parfois avec difficulté printf ayant des comportements bizarres (que je ne comprend pas!) avec l'execution des programmes surtout si il y'a \t ou \n à l'intérieur du message donc je met le \n au dernier printf)

J'ai étudié les différentes primitives utilisées dans les programmes sur www.man-linux-magique.net/ avec difficultés mais ça m'aide pas vraiment en plus de m'embrouiller à ce stade même si c'est intéressant.
De plus je pense c'est plus un déroulement du code ou des notions que je ne comprend pas.

Quand j'execute plusieurs fois synchro.o j'ai parfois ce genre de résultat que je ne comprend pas :

pour moi après qu'un rédacteur est écrit dans la zone mémoire partagée le lecteur d'après devrait lire la dernière valeur écrite par un rédacteur.
ex:
redacteur:valeur mem 2 valeur memoire 2
lecteur:valeur mem 2 valeur memoire 2

lecteur:valeur mem 1 valeur memoire 0
redacteur:valeur mem 2 valeur memoire 1
redacteur:valeur mem 2 valeur memoire 2
lecteur:valeur mem 2 valeur memoire 0
lecteur:valeur mem 3 valeur memoire 0
redacteur:valeur mem 2 valeur memoire 3

lecteur:valeur mem 1 valeur memoire 0
lecteur:valeur mem 2 valeur memoire 0
redacteur:valeur mem 2 valeur memoire 1
lecteur:valeur mem 3 valeur memoire 0
redacteur:valeur mem 2 valeur memoire 2
redacteur:valeur mem 2 valeur memoire 3

lecteur:valeur mem 1 valeur memoire 0
lecteur:valeur mem 2 valeur memoire 0
redacteur:valeur mem 1 valeur memoire 2
lecteur:valeur mem 3 valeur memoire 0
redacteur:valeur mem 1 valeur memoire 2
redacteur:valeur mem 0 valeur memoire 3

J'ai vraiment besoin de comprendre ce qui se passe car je pensais avoir compris un peu les algos semaphores et mutex.
Et là je suis assez perdu au vu des résultats.
Comme les cours continus sur les threads, toutes les primitives et que ça risque de devenir de plus en plus bloquant(non je ne suis pas un processus :lol:) pour comprendre si je ne pige pas ces résultats.

En vous remerciant par avance de vos réponses et votre aide :)

Quand tu ne maitrises plus du tout ce que produit un programme, alors il te faut "détricoter" le fonctionnement et revenir étape par étape au code actuel.
Commence par retirer les fork dans le programme principal ainsi que la suppression de la SHM. Le programme principal va donc créer la SHM et les sémaphores. Tu pourrais même ajouter un argument au programme : "on" pour créer la SHM et les sémaphores et "off" pour supprimer la SHM et les sémaphores. Ce sera plus facile à manier pour tester.
Ensuite, tu lances uniquement le rédacteur et tu vérifies qu'il se bloque correctement en attendant qu'un lecteur se lance.
Puis tu arrêtes le rédacteur et tu lances le lecteur et tu vérifies qu'il lit une seul valeur et se bloque en attendant une nouvelle valeur du rédacteur.
Tu vides tout, supprime SHM et sémaphore puis tu recommences en créant tout, puis tu lances le lecteur qui doit rester bloqué. Puis tu lances le rédacteur qui doit débloquer le lecteur.
Lorsque tout fonctionne correctement, tu peux replacer les choses au fur et à mesure en faisant des tests à chaque fois.

J'avoue ne pas tout comprendre je suis vraiment néophyte je découvre encore les primitives

qu'entend tu par SHM ?
toutes les primitives qui appartiennent à la bibliotheque shm.h
je les retires : shmget, shmat,shmctl,shmdt, voir la structure shmid_ds ???

je comprend le principe de retirer les fork pour pouvoir exécuter rédacteur et leceur mais j'ai pas compris tout ton principe du test désolé

peux tu m'expliquer un peu plus merci

Le bloc de mémoire partagée (shared memory).

La SHM, c'est la mémoire partagée. Puisque tu utilises deux "gros" trucs dans ton code : le fork et la mémoire partagée. Je te propose de laisser tomber le fork pour le moment et te concentrer sur la mémoire partagée. Donc tu conserves dans ton code toutes les fonctions relatives à la SHM.
L'échange d'information entre le rédacteur le lecteur se fait via une mémoire partagée. C'est une zone en mémoire qui peut être lue et écrite autant par le rédacteur que le lecteur. Mais il n'y a aucun mécanisme de verrouillage contre la corruption des données. Par exemple, le rédacteur peut être en pleine écriture, octet par octet, et le lecteur arrive et lit la zone mémoire contenant de nouveaux octets et d'anciens octets. C'est ce qu'on appelle une lecture corrompue.
Pour empêcher ça, on utilise des sémaphores. Le système d'exploitation gère les sémaphores et est le chef d'orchestre des programmes qui incrémentent ou décrémentent les sémaphores.
Pour empêcher toute corruption, il y a une entente tacite entre le rédacteur et le lecteur. Cette entente, c'est toi qui la code, bien sûr, il n'y a rien de magique ;)

oui j'avais compris l’intérêt des sémaphores et son codage

j'avais mal lu : retirer les primitives de suppression (ou la fin ) relative à la mémoire partagée
évidemment sinon lecteur et redacteur ne pourront pas communiquer entre eux sur les données
par contre je vais retirer aussi les primitives excelc de synchro pour éviter un conflit quelconque avant de tester

je vais voir comme faire avant de revenir
mais j'ai eu un cours sur toutes les primitives (tête farcie) en plus de ne pas avoir ou peu de pratique de linux et de commandes linux c'est donc pour moi un cours dense

j'aimerais savoir comment réinitialiser plutôt manuellement les CLEFS des sémaphores et mémoire partagé:

commande linux ou fonction c primitive SHM ET SEM à la limite mais je préfère ne pas surcharger si il faut tester préfère une commande linux dans le terminal si possible.

C'est possible de faire ça sans devoir à redémarrer eclipse voir linux quand semget ou shmget renvoie -1 quand les clés existe déjà ?

Pour créer une SHM sans être obligé de donner une clé, il faut utiliser la valeur IPC_PRIVATE comme clé. Le système se chargera de créer une SHM avec une clé non utilisée.
idem pour les sémaphores.

j'ai plusieurs questions :

tu entends par :
SHM tout ce qui est relatif à la mémoire partagée
SEM tout ce qui est relatif aux sémaphores

sinon :
j'avoue je n'ai pas trop compris sur quelle primitive et dans quel argument :
"Tu pourrais même ajouter un argument au programme : "on" pour créer la SHM et les sémaphores et "off" pour supprimer la SHM et les sémaphores. Ce sera plus facile à manier pour tester."

en attendant et c'est formateur je teste toutes les options des primitives en les étudiant soit sur :

http://www.man-linux-magique.net/man2/shmctl.html
ou
http://manpagesfr.free.fr/man/man2/semop.2.html
ou
http://www.linux-france.org/article/...2/shmop-2.html

d'ailleurs pour vous quel est le meilleur site la meilleure réf (evidement j'aurais tendance à dire linux-france.org mais bon )
et y'en a surement d'autres en anglais qui sont plus complet mais en langue frenchie quelle est la meilleure référence doc linux pour vous ?

Cdt,

SHM est le nom communément utilisé pour nommer une mémoire partagée.
SEM est le préfixe des fonctions manipulant des sémaphores.

Pour l'argument à ajouter "on" ou "off", c'est une facilité pour les tests à effectuer. Je te parle du programme qui créé et supprime la SHM.
Puisque je te propose de supprimer pas mal de chose pour tes tests, il faudrait pouvoir manipuler facilement ta SHM. Si ton programme compilé s'appelle "synchro", alors :

• synchro "on" : programme de création de la SHM et des sémaphores
• synchro "off" : appel du programme pour supprimer la SHM et les sémaphores

C'est uniquement pour faciliter tes tests. Le code prend 1 minute à écrire et va te simplifier la vie :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

int main( int argc, char * argv[] ) { if( argc > 1 && strcmp( argv[ 1 ], "on" ) == 0 ) { créer la SHM et les sémaphore } else if( argc > 1 && strcmp( argv[ 1 ], "off" ) == 0 ) { supprimer la SHM et les sémaphores } ... ... }

---

Sinon, tester toutes les options des primitives, ça ne sert pas à grand chose. Concentre-toi sur la compréhension de la création/suppression d'une SHM, de même pour les sémaphores.
Fait un programme qui fonctionne en le construisant par étape, et comprend chaque étape.

Pour la documentation, tu as les pages de man en français pour toutes les fonctions concernant la gestion des SHM et sémaphores. C'est trouvable sur Google. Le PC sur lequel tu développes possède très certainement les man, et probablement en français. La commande est man fonction ou man 3 fonction, "fonction" est bien sûr à remplacer par la fonction sur laquelle tu cherches de la documentation.

Un point important à comprendre sur les SHM : la suppression d'une mémoire partagée est une indication au système que plus aucun nouveau programme ne peut l'utilisée. La suppression sera effective lorsque plus aucun programme ne sera "branché" à la SHM. Supposons un programme "branché" à une SHM. Puis une demande de suppression de la SHM est faite. Le programme "branché" dessus pourra l'utilisé tant qu'il y restera "branché". Mais un autre programme qui n'est pas encore "branché" dessus ne pourra pas s'y "brancher".

alors j'ai fait de plusieurs façon:
1)
la tienne mais quand je lance "off"
la valeur semid=0 et shmid=0
et

Code:

---

1 2 3 4 5 6

rc = shmctl(shmid, IPC_RMID, &shmid_struct); if (rc==-1) { printf("main: shmctl() failed\n"); return -1; }

---

retourne systématiquement "main: shmctl() failed\n"
car je pense que la partie "on" se termine avec l'accolade "}" ce qui termine le premier processus init donc le "off" ne garde pas en mémoire les valeurs shmid et semid
mais sinon coté "on" quand le prog rédacteur écrit 1 ensuite le prog lecteur lit bien 1 même avec des boucles donc apparement c'est bon pour les mem partagé les semaphores et les semaphores mutex !

2)
j'ai tenté avec le code d'origine et même problème de résultat parfois : redacteur écrit 2 et lecteur ensuite lit 0
par contre un collègue a émis l'hypothèse que ce soit la console eclipse ou la console terminal de linux elles sont partagées par les deux processus avec le code d'origine,
ce qui fait que les résultats semblent parfois incohérent par rapport au code

qu'en pensez vous ?

Cdt,...

Citation:

---

Envoyé par nouilletonne

j'ai tenté avec le code d'origine et même problème de résultat parfois : redacteur écrit 2 et lecteur ensuite lit 0
par contre un collègue a émis l'hypothèse que ce soit la console eclipse ou la console terminal de linux elles sont partagées par les deux processus avec le code d'origine,
ce qui fait que les résultats semblent parfois incohérent par rapport au code

qu'en pensez vous ?

Cdt,...

---

Je n'ai pas compris. La console (Eclipse ou Linux) affiche ce qu'on lui demande, rien de plus.

Pour le problème évoqué, donne ton code dans sa dernière version.

J'ai mis les codes en pièces jointes au début
L'idée :
Comme y'a deux fork() dans le prog principal qui tourne 3 fois les processus fils se partagent la console et quand on exécute plusieurs fois on a ce genre de résultats :

lecteur, valeur memoire 0
redacteur, valeur memoire 1
redacteur, valeur memoire 2
lecteur, valeur memoire 0
lecteur, valeur memoire 0
redacteur, valeur memoire 3

J'attend l'avis et la réponse par mail de mon prof sur cette question qui me bloque pour la suite des cours qui sont de plus en plus compliqués; on est sur la gestion de fichiers et les tubes,etc...
donc j'aimerais résoudre ce dilemme pour être sur de moi pour la suite
Je suis en foad au cnam par evident d'avoir les réponses en direct !

réponse de mon prof "il y a à la fois un entrelacement des affichages , qui ne sont pas donnés dans l'ordre réel et un entrelacement des processus."

exemples :
Résultat 1)
lecteur, valeur memoire 0
lecteur, valeur memoire 0
redacteur, valeur memoire 3
lecteur, valeur memoire 0
redacteur, valeur memoire 12
redacteur, valeur memoire 39

le lecteur se réveille trois fois avant le rédacteur

Résultat 2)
redacteur, valeur memoire 3
lecteur, valeur memoire 3
redacteur, valeur memoire 12
lecteur, valeur memoire 39
redacteur, valeur memoire 39
lecteur, valeur memoire 39

le rédacteur se réveille en premier, le lecteur ensuite (valeur 3)
le rédacteur s'exécute deux fois de suite (12, 39)
le lecteur se réveille après et affiche deux fois la même valeur.

Comme sur ce document :
http://hameur.perso.univ-pau.fr/Cours/Para/Conc.pdf
mais j'avoue que même si je comprend j'ai du mal à me représenter à l'esprit tous les contextes et les notions d'entrelacement, parallélisme, d'interaction, communication, synchronisation (temps,latence,débit, ressources logiciel, système, matériel cpu ,...)
même synchrone et asynchrone n'est pas pour moi facile à manier.

Cdt,

je up un peu avant de marquer résolu si il y a encore quelques explications sur les entrelacements car c'est là que je bloque encore

car la console eclipse ou le terminal sont partagés par les processus dans certains cas où des excl + fork sont éxécutés en meme temps. les entrées sorties de la console ou du terminal étant une ressource noyau unique: le shell je crois qui peut afficher des résultats "étranges " justement lié à un entrelacement affichage (ressource i/o systeme) et un entrelacement de processus.

ça je peux comprendre mais j'ai besoin de plus d'explications simples sur cette notion d'entrelacement.

merci à vous pour plus de commentaires sur cette notion qui impliquent plusieurs contextes pas forcément pour moi facile à manier : contexte matériel, contexte logiciel, contexte utilisateur et noyau, ... comment les aborder correctement par analyse chrono, séquentiel, ou autres pour comprendre les entrelacements et donc des résultats ?

Pour moi, le plus simple, c'est de partir du principe qu'il n'y a qu'une seule chose qui soit synchronisée pour la sortie standard: Les appels à write(). On part du principe que deux write() sur STDOUT_FILENO ne peuvent pas être "entrelacés" et que n'importe quelle autre fonction de sortie peut l'être, et que donc si tu veux faire un printf(), tu dois remplaçer par:

• vsnprintf() [c99] sur pointeur nul pour obtenir la taille (attention au caractère nul terminal)
• Allocation d'un buffer via malloc() (ou optionnellement, utilisation d'un buffer de taille fixe quand la taille requise est suffisamment petite)
• vsnprintf() sur ledit buffer
• write() du buffer sur STDOUT_FILENO
• libération du buffer via free() s'il a été alloué par malloc().

Tu te fais une fonction pour faire tout ça qui prend une va_list en paramètre, une fonction wrapper qui prend ... en paramètre, et lorsque tu l'appelles tu seras sûr d'avoir ta sortie "en une fois" et non-polluée par les autre processus sur la même console.

ok vais essayer de coder tout ça.(connaissait pas vnsprintf()) en plus je n'utilise pas write mais c'est juste poru écrire dans la console c'est cela ?

mais sinon pour la notion d'entrelacement : définition simple avec ou non selon les contextes. j'aimerais bien un ordre car l'explication du pdf http://hameur.perso.univ-pau.fr/Cours/Para/Conc.pdf est bien mais je n’arrive pas à voir les contextes principaux auquels il faut faire attention dans le cadre d'un rique d'entrelacement.

Bon!
je marque résolu
puisque finalement soit j'ouvre un sujet sur l'entrelacement et avant je vais le bosser parce que c'est une notion qui me bloque et auquel je n'ai pas de cours ! et que je pense est essentiel pour comprendre la raison de gestion de fichiers et tout le reste qui va avec : les processus et les sémaphores justement.

merci à tous de m'avoir fait avancer :)