Bonjour,

Mon problème est le suivant : J'ai implémenté une file de messages via mémoire partagée. Il n'y a qu'un seul lecteur et qu'un seul écrivain.
La taille de la file est définie par une constante MAX_SIZE. Je veux que l'écrivain bloque si la file est pleine, et que le lecteur bloque si la file est vide.

Pour cela j'ai défini un sémaphore available_size initialisé à MAX_SIZE, et un sémaphore used_size initialisé à 0.

Lorsque l'écrivain veut écrire n objets, il fait un p(-n) sur le sémaphore available_size, de manière à bloquer si la file est pleine. Une fois l'écriture effectuée, il fait un v(n) sur used_size.

Lorsque le lecteur veut lire n objets, c'est tout simplement l'inverse.

Le problème, c'est que les sémaphores ont une valeur maximum relativement faible (16384 sur mon OS), et mon logiciel doit tourner avec une taille de file beaucoup plus grande que ça.

Je cherche donc un algorithme ou une méthode qui puisse faire l'équivalent de ce comportement.

J'avais pensé à faire la chose suivante :

Dans le cas de l'écrivain :
un sémaphore lock
une variable used_size initialisée à 0
une variable available_size initialisée à MAX_SIZE

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
entrée : n
ok = false
while not ok
   p(lock)
   if available_size > n
      available_size -= n
      ok = true
   endif
   v(lock)
endwhile
Mais avec cette méthode, on boucle inutilement et on passe son temps à bloquer et débloquer un sémaphore, ce qui, je suppose, n'est pas gratuit.

Auriez-vous une solution ?