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?

[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

[corrector]

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.

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? )

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.

[Bleys]

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

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

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

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

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


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

[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 */
  };

[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 :

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

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

[corrector]

Re-Bonsoir,

Re-re-bonsoir!

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

Code :

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

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.

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

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.

[corrector]

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

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

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

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

Par rapport au C++, toute cette discussion est totalement HS de toutes façons : IPC est une interface C d'une certaine famille Unix.

[corrector]

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 :

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

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