Gérer des ressources accaparées longtemps par un Thread
Bonjour,
J'ai une question d'ordre générale, c'est à dire pas nécessairement spécifique au C++. Je participe au développement d'une application multithreadée assez lourde.
Aujourd'hui, j'ai un module X qui écrit de façon régulière et continue dans deux gros buffers. Quand un est plein, il le signale aux autres modules, leur envoie un pointeur vers le buffer, et ils peuvent travailler dessus. Puis, ce module X remplit l'autre buffer.
Premier souci : quand le module X a fini de remplir le second buffer (et qu'il le signale aux autres) il arrive parfois que certains modules qui font du traitement sur le premier buffer n'ont pas encore terminé! :(
Et là, magie des mutex, le module X n'écrit heureusement pas dans le buffer où il est sensé écrire. D'ailleurs, tant qu'un module travaille encore sur le buffer, ce buffer reste bloqué en écriture, impossible d'écrire dessus.
Bon, au moins, on a pas d'accès concurrent, c'est déjà pas la cata... Mais c'est pas terrible non plus. Tout simplement parce qu'on "saute" plein de buffers.
Existe-t-il une solution toute faite, un design pattern, un je-ne sais quoi (éventuellement un truc C++ de gourou) qui permet ceci :
- Le module X peut toujours remplir ses deux buffers.
- Les autres modules peuvent toujours avoir accès à un buffer sur lesquels ils peuvent travailler. Evidemment, si le travail sur le buffer prend trois fois le temps pour que le module X remplisse un buffer, alors le module n'a accès qu'à un buffer sur trois (en gros)
- On a une consommation mémoire faible : Hors de question d'allouer systématiquement des buffers à la volée. On peut en allouer, mais, disons qu'on veut borner la consommation mémoire.
Voilà, je n'ai pas trouvé de design pattern qui réponde à ma question, mais j'ai l'impression que c'est un problème fréquent en multithread.
Merci d'avance!
