Discussion :

[Bleys]

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 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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

[corrector]

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".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

Par avance, merci de votre lecture et de votre aide

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

[Bleys]

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 ) voici un mini exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ...

Bon courage

[corrector]

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.

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.

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 :

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

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)

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 ) voici un mini exemple :

Et quelques lignes que l'on comprend valent toujours mieux qu'une explication qu'on ne comprend pas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Bleys]

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

Oui ça je suis d'accord ...

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 ...

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 ...

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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é ...

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

[corrector]

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?

[corrector]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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