Programmation Système : sémaphore

Version imprimable

Bonsoir à tous,
Avant tout je pense qu'il peut être nécessaire de préciser que l'environnement de développement est un système Linux. Ceci fait, venons-en aux faits.

Je me suis dernièrement lancé dans la programmation système mais dans le cours qui m'a servi de support je suis tombé sur un schéma qui m'a au final embrouillé les esprits. Les schémas étant difficiles à représenter, je vous prie un peu d'indulgence quant au mien :lol: :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 +--------------------------+ | _______ | | sem0 |_______| | | sem1 |_______| | | sem2 |_______| | | sem3 |_______| | | sem4 |_______| | | sem5 |_______| | | sem6 |_______| | | | +--------------------------+
le gros carrée représentant ce qui a été appelé sémaphore général et semX X€[0..6] = sémaphore élémentaires.

Il y a ensuite quelques données supplémentaires :
la création d'un sémaphore s'effectue grâce à l'appel système semget( key_t clef, int nbSemElem, int options);
D'après ce qui est écrit (toujours dans ce cours) et en relation avec mon schéma, cet appel renvoie un identifiant de sémaphore correspondant à ce que j'ai appelé sémaphore général (Vrai ?)

Bien dans ce cas là supposons la situation suivante : j'ai besoin de deux sémaphores pour protéger deux accès à deux mémoires partagées (mpNum1 et mpNum2).
Ma question est-alors la suivante :
A quoi correspond réellement chaque entité représentée là-haut ? (sémaphore général / sémaphore élémentaire ?)

Ma seconde question dépend de la première au final (ou peut-être même allez vous y répondre dans la première). Dans la situation exposée ci-dessus et dans l'hypothèse où ce que l'on appelle sémaphore est sur ce schéma le sémaphore général, à quoi servent les sémaphores élémentaires ?

Si ma supposition est fausse, je suis alors tout ouïe à toute explication ...

Par avance, merci de votre lecture et de votre aide :D

11/03/2008, 10h43
Bleys

Re bonjour,

en regardant de plus près le fonctionnement de semop j'ai compris que en fait ceux sont les sémaphores élémentaires que l'on manipule réellement.

Mais alors j'ai une nouvelle question :
quel intérêt d'avoir plusieurs sémaphores généraux au sein d'une même application ?

Merci pour toute aide

Citation:

Envoyé par Bleys

Avant tout je pense qu'il peut être nécessaire de préciser que l'environnement de développement est un système Linux.

C'est surtout que tu utilises une "System V"rie, les "System V IPC".
Citation:
Envoyé par Bleys
Code:

1 2 3 4 5 6 7 8 9 10 11 12 +--------------------------+ | _______ | | sem0 |_______| | | sem1 |_______| | | sem2 |_______| | | sem3 |_______| | | sem4 |_______| | | sem5 |_______| | | sem6 |_______| | | | +--------------------------+
le gros carrée représentant ce qui a été appelé sémaphore général et semX X€[0..6] = sémaphore élémentaires.
Bon, c'est moi qui suis encore plus embrouillé; c'est quoi un sémaphore général? En V.O., comment on dit? (Mêmes questions pour "sémaphore élémentaire".)

Ton schéma augmente encore ma confusion. Quel est l'interface du sémaphore général? Accède t-on directement aux semx?

Citation:

Envoyé par Bleys

Par avance, merci de votre lecture et de votre aide :D

Déjà, il faudrait que tu m'aides à comprendre ces notions.

Citation:

Envoyé par corrector

C'est surtout que tu utilises une "System V"rie, les "System V IPC".

Bon, c'est moi qui suis encore plus embrouillé; c'est quoi un sémaphore général? En V.O., comment on dit? (Mêmes questions pour "sémaphore élémentaire".)

Ton schéma augmente encore ma confusion. Quel est l'interface du sémaphore général? Accède t-on directement aux semx?

En VO je ne sais pas je ne connais pas le terme mais à mon avis (compte tenu des noms des appels sytèmes surtout) ce qui est appelé semaphore en VO correspond au sémaphore général.

Je t'explique comment ça fonctionne :
En fait, l'appel semget (on est donc sous un environnement linux) te renvoie un identifiant sur un sémaphore général qui, selon le schéma que j'ai représenté, contient plusieurs sémaphores élémentaires.

Pour rappel la déclaration de semget est la suivante :
semget(key_t,int,int);
où le premier int correspond au nombre de sémaphores élémentaires que contient le sémaphore général...

En très gros et en vulgarisant le principe :
semaphore général = tableau à N cases
semaphore élémentaire = 1 case de ce tableau.

Par la suite ce qu'on manipule en réalité du coup ce sont les sémaphores élémentaires. Comme parfois quelques lignes de code commentées valent mieux qu'un long commentaire (sisi je vous l'assure :D ) voici un mini exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 #include <sys/types.h> // Pour key_t #include <sys/sem.h> // Pour la manipulation de semaphores #include <sys/ipc.h> // Pour ftok() /******************* Définition des constantes **/ // Chaine de reference pour la generation d'une clé : notre exécutable const char REFERENCE [] = './demo'; const int DROITS = 0600; const int NB_SEM_ELEM = 2; const int SEM_ELEM_0 = 0; const int SEM_ELEM_1 = 1; /****************** Mise en place de nos variables **/ // Id de référence pour la génération d'une clé int id_key(0); // Création de notre sémaphore général contenant NB_SEM_ELEM ( = 2) // sémaphores élémentaires int semGene (semget(ftok(REFERENCE,(char)id_key++),NB_SEM_ELEM,IPC_CREAT|DROITS)); /****************** Définition des structures de manipulation des sémaphores **/ // Structure de prise d'un jeton sur le sémaphore élémentaire // <SEM_ELEM_0> = premier sémaphore du sémaphore général <semGene> struct sembuf reserverSemElem0 = {SEM_ELEM_0,-1,0} // Idem sur le deuxième sémaphore élémentaire struct sembuf reserverSemElem1 = {SEM_ELEM_1,-1,0} struct sembuf libererSemElem0 = {SEM_ELEM_0,1,0} // reposer jeton struct sembuf libererSemElem0 = {SEM_ELEM_1,1,0} // reposer jeton /****************** Manipulation des sémaphores **/ // Récupération d'un jeton sur le sémaphore élémentaire 0 // du sémaphore général <semGene> semop(semGene,&reserverSemElem0,1); // Libération de la ressource semop(semGene,&libererSemElem0,1); ...
Il est vrai que sans but précis ce code n'a aucun sens, mais peut-être éclaircira-t-il quelques points ... quoiqu'il en soit j'espère qu'il ne t'embrouillera pas plus ... :aie:

Bon courage :yaisse2:

Citation:

Envoyé par Bleys

En VO je ne sais pas je ne connais pas le terme mais à mon avis (compte tenu des noms des appels sytèmes surtout) ce qui est appelé semaphore en VO correspond au sémaphore général.

Non, je crois que (en) semaphore = (fr) sémaphore. :)

Citation:

Envoyé par Bleys

Je t'explique comment ça fonctionne :
En fait, l'appel semget (on est donc sous un environnement linux)

linux, ou tout cousin de la famille System V.

Citation:

Envoyé par Bleys

te renvoie un identifiant sur un sémaphore général qui, selon le schéma que j'ai représenté, contient plusieurs sémaphores élémentaires.

Un "identificateur de sémaphores", tout simplement :

Citation:

Envoyé par man semget

The semget() function returns the semaphore identifier associated with key.

Citation:

Envoyé par Bleys

Pour rappel la déclaration de semget est la suivante :
semget(key_t,int,int);
où le premier int correspond au nombre de sémaphores élémentaires que contient le sémaphore général...

En très gros et en vulgarisant le principe :
semaphore général = tableau à N cases
semaphore élémentaire = 1 case de ce tableau.

En très précis et sans vulgarisation :

"sémaphore général" = ensemble de sémaphores représenté par une structure semid_ds, désigné par un numéro (identificateur)
"sémaphore élémentaire" = un sémaphore (dans un ensemble)

Citation:

Envoyé par Bleys

Par la suite ce qu'on manipule en réalité du coup ce sont les sémaphores élémentaires. Comme parfois quelques lignes de code commentées valent mieux qu'un long commentaire (sisi je vous l'assure :D ) voici un mini exemple :

Et quelques lignes que l'on comprend valent toujours mieux qu'une explication qu'on ne comprend pas. ;)
Citation:
Envoyé par Bleys
Code:

1 2 3 4 5 6 // Id de référence pour la génération d'une clé int id_key(0); // Création de notre sémaphore général contenant NB_SEM_ELEM ( = 2) // sémaphores élémentaires int semGene (semget(ftok(REFERENCE,(char)id_key++),NB_SEM_ELEM,IPC_CREAT|DROITS));
D'après ce que j'ai compris, tu n'as pas besoin de caster la valeur de id_key ici.
Citation:
Envoyé par Bleys
Code:

1 2 3 4 /****************** Définition des structures de manipulation des sémaphores **/ // Structure de prise d'un jeton sur le sémaphore élémentaire // <SEM_ELEM_0> = premier sémaphore du sémaphore général <semGene> struct sembuf reserverSemElem0 = {SEM_ELEM_0,-1,0}
Tu supposes un ordre sur les membres de sembuf... je ne crois pas que ça soit portable, ni même formellement garanti sous linux. En plus je trouve ça moins lisible, moins évident.

Bon, je crois que l'ordre c'est : sem_num, sem_op, sem_flg, et que :

sem_op = 1 signifie post.
sem_op = -1 signifie wait

PS : En général, pour parler d'informatique, c'est mieux d'utiliser soit le vocabulaire anglais "officiel" (utilisé dans les normes, les documentations officielles, les livres de référence), soit une traduction littérale du vocabulaire anglais, soit le vocabulaire français des documentations officielles françaises (et dans tous les cas, je préfère indiquer la VO si ce n'est absolument évident).

En tout cas il faut éviter d'aller contre le sens français des mots : sémaphore existe et a un sens précis, il me semble donc peu souhaitable de définir un "sémaphore général" comme n'étant pas un "sémaphore", mais une structure de donnée abstraite contenant un tableau de sémaphores.

Citation:

Envoyé par corrector

Non, je crois que (en) semaphore = (fr) sémaphore. :)

Oui ça je suis d'accord ...

Citation:

Envoyé par corrector

En très précis et sans vulgarisation :

"sémaphore général" = ensemble de sémaphores représenté par une structure semid_ds, désigné par un numéro (identificateur)
"sémaphore élémentaire" = un sémaphore (dans un ensemble)

Toujours d'accord avec l'idée que j'en avais,mais en plus formel ...

Citation:

Envoyé par corrector

D'après ce que j'ai compris, tu n'as pas besoin de caster la valeur de id_key ici.

Effectivement je l'ai déjà fait sans caster id_key mais suivant les conditions de compilation et/ou les compilo ... c'est juste histoire d'être sûr qu'il ne nous dérange pas avec un Warning ...

Citation:

Envoyé par corrector

Tu supposes un ordre sur les membres de sembuf... je ne crois pas que ça soit portable, ni même formellement garanti sous linux. En plus je trouve ça moins lisible, moins évident.

Je ne comprends pas ce que tu veux dire par là : je ne suppose pas d'ordre, je suis d'accord que l'exemple n'est pas super ici mais supposons une application multitâche dans laquelle j'ai besoin de deux sémaphores pour protéger des ressources critiques (mémoire partagé ou autre) il faut bien que je fixe quel sémaphore "élémentaire" correspond à quel sémaphore (de protection) ... exemple :
Code:

1 2 3 const int MUTEX_DUREE = 0; const int MUTEX_COULEUR = 1;
et donc pour accéder à ces sémaphores j'ai les structures
Code:

1 2 3 4 5 struct sembuf reserverDuree = { MUTEX_DUREE, -1, 0}; struct sembuf reserverCouleur = { MUTEX_COULEUR, -1, 0}; struct sembuf libererDuree = { MUTEX_DUREE, 1, 0}; struct sembuf libererCouleur = { MUTEX_COULEUR, 1, 0};
sinon comment différencier sur quel sémaphore j'agis par semop ?
Ou alors c'est qu'il y a quelque chose que je n'ai pas encore complètement pigé ... :lol:

Citation:

Envoyé par corrector

Bon, je crois que l'ordre c'est : sem_num, sem_op, sem_flg, et que :

sem_op = 1 signifie post.
sem_op = -1 signifie wait

Je ne comprends pas ce que tu veux dire par là ... un peu de lumière ?

Sinon certes mon problème initial est résolu, mais la discussion m'intéresse, si cela ne te dérange pas de continuer sur cette lancée, je me ferais un plaisir de lire ta réponse :mouarf:

15/03/2008, 19h35
corrector

POSIX vs. System V IPC

Je sais c'est un peu HS, mais je me permets de te demander : as-tu considéré la possibilité d'utiliser les fonctions de synchronisation des "POSIX threads" à la place des IPC?
16/03/2008, 11h10
Bleys

Je suis désolé mais je ne connais pas du tout ?

Ce que je connais de la programmation système se limite à ce qu'on m'a appris dans ma formation scolaire ... et autant que je sache ce point n'a pas été abordé, ou que je ne vois pas encore de quoi tu parles ...
Quelques informations dessus ?

Sinon par rapport au dernier messsage que j'ai laissé, quelque chose n'est pas bon ?

merci bien ;)
16/03/2008, 13h32
corrector

Citation:

Envoyé par Bleys

Je suis désolé mais je ne connais pas du tout ?

Je parle de pthread_mutex_t, de sem_t... des primitives de synchronisations POSIX.

Citation:

Envoyé par Bleys

Ce que je connais de la programmation système se limite à ce qu'on m'a appris dans ma formation scolaire ... et autant que je sache ce point n'a pas été abordé, ou que je ne vois pas encore de quoi tu parles ...

On t'a défini un sémaphore au moins?

On t'a dit qu'un sémaphore supporte deux opérations de base : P et V, aussi appelées Wait et Post, aka Wait et Signal, aka Decrement et Increment?

Est-ce qu'on a commencé par la base (un sémaphore partagé par des threads), ou est-ce qu'on t'a balancé directement les ensembles de sémaphores désignés par une clef correspondant à un fichier, partageables par plusieurs processus, avec contrôle d'accès, opérations multiples atomiques, et fonctions d'"annulation", aka sémaphores IPC System V?

(C'est quoi ce cours? :evilred:)

Citation:

Envoyé par Bleys

Quelques informations dessus ?

Ce sont des fonctions qui ne coutent pas un appel système juste pour prendre un mutex qui est libre. C'est appréciable.

Pour utiliser les IPC il faut vraiment ne pas avoir le choix, AMHA.

Mais je ne connais pas du tout ton cahier des charges, je ne sais même pas si tu fais du multithread, du multiprocess, avec de la mémoire partagée, ou des messages... bref je n'ai aucune idée de ce que veux faire.
16/03/2008, 19h49
Bleys

Citation:

Envoyé par corrector

Je parle de pthread_mutex_t, de sem_t... des primitives de synchronisations POSIX.

... Désolé je ne connais pas ...

Citation:

Envoyé par corrector

On t'a défini un sémaphore au moins?

On t'a dit qu'un sémaphore supporte deux opérations de base : P et V, aussi appelées Wait et Post, aka Wait et Signal, aka Decrement et Increment?

Jusque là toujours pas de problème ...

Citation:

Envoyé par corrector

Est-ce qu'on a commencé par la base (un sémaphore partagé par des threads), ou est-ce qu'on t'a balancé directement les ensembles de sémaphores désignés par une clef correspondant à un fichier, partageables par plusieurs processus, avec contrôle d'accès, opérations multiples atomiques, et fonctions d'"annulation", aka sémaphores IPC System V?

On nous en a appris le principe de fonctionnement (opération P et V) et pourquoi on utilise un sémaphore, qui se résume au final principalement à permettre une synchronisation lors d'un développement multitâche, ou de la protection de ressource critique dans le cas de mutex (sémaphore à 1 jeton), le principe de partage etc ...

Citation:

Envoyé par corrector

Mais je ne connais pas du tout ton cahier des charges, je ne sais même pas si tu fais du multithread, du multiprocess, avec de la mémoire partagée, ou des messages... bref je n'ai aucune idée de ce que veux faire.

En fait à la base ma question n'était centré que sur le sémaphore, mais j'avais finalement répondu à la question moi-même puis petit à petit on a dérivé sur le fonctionnement à proprement parler des sémaphores mais sans but précis derrière ... Je viens de faire un développement multitâche, mais ce topic ne s'en rapporte pas forcément, c'était juste pour répondre à une question en relation avec les sémaphores ...

Bref au final je crois qu'on va en rester là ...

Je me renseignerais sur les deux trois dernières informations que tu viens de me fournir, mais continuer sur ce sujet serait totalement hors-sujet justement ...:yaisse2:

Quoiqu'il en soit, merci beaucoup d'avoir pris de ton temps, me reste plus qu'à me pencher sur deux trois petites choses ...

Bonne soirée ...

Citation:

Envoyé par Bleys

Code:

struct sembuf reserverDuree = { MUTEX_DUREE, -1, 0};

Je ne comprends pas ce que tu veux dire par là ... un peu de lumière ?

Sinon certes mon problème initial est résolu, mais la discussion m'intéresse, si cela ne te dérange pas de continuer sur cette lancée, je me ferais un plaisir de lire ta réponse :mouarf:

Je voulais tout simplement dire que l'ordre des membres de sembuf ne me semble pas garanti, même sous Linux.

C'est la syntaxe que je pointais, et qui n'est peut-être pas portable.

Et effet, info libc dit juste :
Code:

1 2 3 4 5 Operations are described by a structure sembuf: struct sembuf ushort sem_num; /* semaphore index in array */ short sem_op; /* semaphore operation */ short sem_flg; /* operation flags */
et j'interprète cela comme

sembuf comprend les membres suivants : sem_num etc.
pas :
sembuf est défini comme suit :
Code:

1 2 3 4 5 struct sembuf { ushort sem_num; /* semaphore index in array */ short sem_op; /* semaphore operation */ short sem_flg; /* operation flags */ };

16/03/2008, 22h34
Bleys
Re-Bonsoir,
Ok je vois ce que tu veux dire, il vaudrait mieux que je définisse ma "variable" comme suit en fait :
Code:

1 2 3 4 5 struct sembuf reserverDuree; reserverDuree.sem_num = MUTEX_DUREE; reserverDuree.sem_op = -1; reserver.sem_flg = 0; ...
Si c'est de ça que tu parles, je pense que maintenant, et notamment vis à vis de POSIX, cette structure ne devrait pas changer, et donc le premier code rester valable ... mais bon tu n'as pas tord ...

@ tout à l'heure :mouarf:
18/03/2008, 04h36
corrector
Citation:

Envoyé par Bleys

Re-Bonsoir,

Re-re-bonsoir!
Citation:
Envoyé par Bleys

Ok je vois ce que tu veux dire, il vaudrait mieux que je définisse ma "variable" comme suit en fait :

Code:

1 2 3 4 5 struct sembuf reserverDuree; reserverDuree.sem_num = MUTEX_DUREE; reserverDuree.sem_op = -1; reserver.sem_flg = 0; ...
Et en plus je trouve ça plus lisible.

Citation:

Envoyé par Bleys

Si c'est de ça que tu parles, je pense que maintenant, et notamment vis à vis de POSIX, cette structure ne devrait pas changer, et donc le premier code rester valable ... mais bon tu n'as pas tord ...

@ tout à l'heure :mouarf:

Il ne me semble pas que POSIX dise quoi que ce soit sur sembuf, qui ne fait pas parti de POSIX justement.

Et en général, l'ordre dans lequel sont présentés les membres d'une structure dans une norme ou une documentation ne garantit pas forcément que ces membres soient déclarés dans cet ordre, juste qu'ils existent avec le type indiqué. (Confirmation? Contre-exemples?)

Si la doc dit "sembuf est définit ainsi : struct sembuf { ... }" alors c'est bon.

Pour moi ce n'est pas clair.
18/03/2008, 04h46
corrector

Citation:

Envoyé par Bleys

... Désolé je ne connais pas ...

pthread_mutex_t : le type mutex des POSIX threads
sem_t : le type sémaphore des POSIX threads

Citation:

Envoyé par Bleys

On nous en a appris le principe de fonctionnement (opération P et V) et pourquoi on utilise un sémaphore, qui se résume au final principalement à permettre une synchronisation lors d'un développement multitâche, ou de la protection de ressource critique dans le cas de mutex (sémaphore à 1 jeton), le principe de partage etc ...

Comment vous a t-on appris à lancer plusieurs "tâches"?

Citation:

Envoyé par Bleys

Je me renseignerais sur les deux trois dernières informations que tu viens de me fournir, mais continuer sur ce sujet serait totalement hors-sujet justement ...:yaisse2:

Par rapport au C++, toute cette discussion est totalement HS de toutes façons : IPC est une interface C d'une certaine famille Unix.
18/03/2008, 05h08
corrector

P, V, wait, post et signal
Citation:

Envoyé par Bleys

On nous en a appris le principe de fonctionnement (opération P et V)

P = wait
V = post = signal

C'est peut-être cela que ton cours ne disait pas.

Par exemple, avec pthread :
Code:

1 2 int sem_wait(sem_t *sem); int sem_post(sem_t *sem);
Autre exemple, sous Windows, les fonctions dont le nom contient Wait ou Signal (WaitForSingleObject, SignalObjectAndWait...).