Bonjour,

Je voudrai avoir quelques explications sur le principe des Sémaphores.

1. Je sais qu'il y a des sémaphores d'exclusion mutuelle et d'autres de synchronisation. Est-ce que les sémaphores de synchronisation font que deux processus enregistrent leur contexte lors des blocage et les restaurent quand ils sont retirés de la file? Quelle est la différence avec les sémaphores d'exclusion mutuelle??

2. Que veut dire un sémaphore binaire?

3. Enfin, supposons qu'on veuille synchroniser deux processus avec des sémaphores, on a besoin de combien de sémaphore exactement?

Merci pour votre aide!!

Un mutex (sémaphore d'exclusion mutuelle) est un sémaphore de synchronisation. La seule différence est qu'on parle généralement de mutex lorsque l'on utilise un section critique et de synchronisation lorsque l'on parle de processus qui "s'attendent" mutuellement.

Un sémaphore binaire et un sémaphore dont le compteur et limité à 1 et n'est rien d'autre qu'un mutex.

Pour synchroniser deux processus, il te faut deux sémaphores :

Processus1 Processus2
P1() V2()
V2() P1()

Très bien merci

HUm, concernant le comportement interne. En utilisant les deux sémaphores pour effectuer un ordonnancement du genre : processus1 - processus2 - processus1 - processus2 -.... comment ça se comporte?

Le blocage d'un processus entraine bien sa mise en attente dans la file des processus, et l'attribution de la ressource partagée (supposons que c'est un processeur) au prochain processus dans la file, n'est-ce pas?
Le truc c'est qu'en lisant dans la doc des fonctions linux, j'ai vu qu'il y avait une fonction sched_yield qui faisait la même chose que cela, mais qui prenait nettement moins de temps que les sémaphores, je ne comprends pas pourquoi?

Est-ce que c'est dû au fait que sched_yield est un appel système --> moins couteux que sémaphores posix (appel bibliothéque) ou bien au fait que sched_yield ne soit pas bloquante contrairement aux instructions liées aux sémaphores??

Merci!

Le premier processus P1 demande un sémaphore S1 initialisé à 0. Il se bloque donc.
Le deuxième processus P2 arrive au point de synchronisation et libère S1 puis demande un deuxième sémaphore S2 initialisé à 0. Lui aussi se bloque.
N'étant plus bloqué, P1 peut continuer son exécution et commence par libérer S2 qui débloque donc P2.
P1 et P2 sont donc synchronisés.

Lorsqu'un processus est bloqué par un sémaphore, il est retiré de la liste de processus prêts et est placé dans la file des processus bloqués. Il n'aura donc plus le processeur jusqu'à ce que le sémaphore soit libéré.
De ce que je sais, sched_yield ne fait juste qu'enlever le processeur au processus courant sans le bloquer (le processus est replacé à la fin de la file de processus prêt associée à sa priorité). Une sorte de préemption manuelle en somme.

Hum d'accord, donc en fait cette différence de temps est dû au fait que dans les sémaphores, un processus n'est pas mis dans la file des processus prêts mais bloqués, donc le remettre dans la file des processus prêts rallonge le temps?

Concernant la première explication, en testant, j'ai dû initialiser un des sémaphores à 1 et l'autre à 0 pour qu'il n'y ait pas de blocage, ce n'est pas la bonne procédure? En executant j'avais l'ordonnancement correct

Salut, je re ouvre ce sujet même s'il date un peu. Je dois utiliser les sémaphore afin d'avoir un affichage synchronisé de la lettre a et b de la façon suivante: a b a b a b a b .... J'ai suivi vos conseils mais je n'y arrive pas a afficher a b a b a b mais j'ai ab ab ab ab ... Je ne comprend pas pourquoi sa prend a et b en même temps et non chaque son tour :/

Es-tu sûr qu'il ne s'agit pas seulement d'un souci d'affichage ? peux-tu stp poster ton code ?