Discussion :

[epsilon68]

Bonjour,

J'aurais voulu avoir votre opinion sur "comment implementer un semaphore en utilisant un mutex et une condition" avec pthread ?

Je sais que pthread possede deja des semaphores, mais j'aimerais en re-implementer un (pour le sujet [MT] Benchmark de produits matriciels sur processeurs multi-cores )

en gros, pthread est mal foutu pour mac et n'implemente pas ce qu'il faut pour faire des semaphores (en fait que ceux inter-processus et sont forcement nommés)

donc l'idée serait de reimplementer un count semaphore...

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
class semaphore
{
  private:
	int count;
        mutex mut;
	condition cond;
 
    semaphore(const self &);
    const self &operator=(const self &);
 
  public:
    inline semaphore(     ) { count = 1;  }
    inline semaphore(int n) { count = n; }
    inline ~semaphore() {}
 
    inline void release() { 
		mut.acquire();
		count = count + 1;
		cond.signal();
		mut.release();
	}
 
    inline void release(int n) { for (int i=0; i<n; ++i) release(); }
 
    inline void acquire() {
		mut.acquire();
		assert(count >= 0);
		while(count == 0)  
            cond.wait(mut);
		count = count - 1;
		mut.release();
	}
 
    inline void acquire(int n) { for (int i=0; i<n; ++i) acquire(); }
 
    inline bool try_acquire()      { mutex::scoped_lock lock(mut); return count > 0; }
    inline int  try_acquire(int n) { mutex::scoped_lock lock(mut); return count > n ? n : count; }
};

êtes-vous d'accord ? (pthread est utilisé sous la couche d'abstraction)

je ne pense pas que le code soit bon pour

Code :

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

inline void acquire(int n) { for (int i=0; i<n; ++i) acquire(); }

http://www.developpez.net/forums/sho...&postcount=177

imaginons 2 threads qui se dispute 10 resources (semaphore) si chacun des threads en veut 8, he bien il y a blocage pur et simple parce que ils se seront alloués chacun 5 resources par exemple ....
il vaudrait mieux faire acquerir n resources ou rien...

Qu'en pensez-vous ?

Merci d'avance pour vos conseils,
a+

[bolhrak]

Les opérations sur sémaphores (acquire et release) doivent par définition être atomiques, ce qui n'est pas le cas avec les implémentations d'acquire (int n) et release (int n) que tu proposes, donc ça ne peut pas marcher.

Si tu veux te baser sur l'utilisation des acquire et release, je vois que deux solutions :

- la première, utiliser un mutex réentrant, et acquérir le mutex en début de ta fonction acquire(int n) avant d'appeler la fonction acquire simple.

- la seconde, définir une fonction acquire (int n=1) (resp release(int n=1)) qui se charge d'incréementer (resp décrémenter) le compteur du nombre de ressources adéquates.

Il me semble cependant me souvenir qu'il ne faut pas modifier le compteur d'une sémaphore autrement que par incrémentation ou décrémentation simple, mais je n'arrive plus à remettre la main sur l'article :/

[epsilon68]

derniere implementation en date:
http://www.developpez.net/forums/sho...&postcount=181

[nicroman]

A noter que le V() d'un semaphore n'a normalement pas besoin d'être ni atomique, ni mutually-exclusive.

[epsilon68]

c'est quoi le V() ?

[Charlemagne]

Nicroman t'en dira sûrement plus.
Je sais juste que les fonctions P et V sont à la base de la programmation multi-processus.
La fonction P demande un ticket, la fonction V donne un ticket.
Si je me souviens bien, c'est des initiales de mots hollandais! Mais petit moyen mnémotechnique: P=Puis-je passer? V=Vas-y!

En pratique je crois que ça ne sert pas à grand chose puisque les bibliothèques offrent un minimum d'encapsulation.

[nicroman]

P() et V() sont les deux noms classiques donnés aux deux fonctions d'un sémaphore....
Dijkstra étant néérlandais, il a utilisé les fonctions "Proberen" (tester) et "Verhogen" (incrémenter) pour la définition des sémaphore... et c'est resté. Dans tous les cours d'informatique tu verras P() et V().

Si tu veux un moyen mnémotechnique facile tu peux dire "Puis-je()" et "Vas-y()"

[epsilon68]

mais en fait j'utilisais cette notation en cours, mais ca fait longtemps et je ne me rappelais plus. Je m'en suis juste souvenu quand vous me l'avez expliqué

Merci pour l'explication