Discussion :

[oodini]

Hello,

J'ai une fonction qui, par des appels successifs, doit remplir un grand buffer (peu importe de quoi) par morceaux. Je crée donc un petit buffer et appelle la fonction dans une boucle en lui filant l'adresse du petit buffer. La fonction écrase le contenu, et une fois sorti de la fonction, je mets à jour le grand buffer en lui filant le petit buffer et un décalage d'indice idoine.

J'aimerais dorénavant qu'elle soit appelée en multithread (à l'aide de Boost). je remplace la boucle par un compteur partagé qui s'incrémente. Ce n'est pas trop gênant de bloquer ce compteur par un mutex. La MAJ est rapide (je recopie el compteur dans une variable locale). En revanche, je ne veux pas bloquer tous les threads dès que l'un d 'entre eux veut remplir son petit buffer. Je pense donc avoir autant de petits buffer que je lance de threads, donc avoir un "pool" de petits buffers.

Disons que j'ai un grand buffer d'une taille équivalente à 100 petits buffer. Je lance 4 threads pour exécuter la fonction de remplissage de buffer. Il faudrait donc un vecteur de 4 petits buckets. Dès qu'un thread rentre dans la fonction de MAJ, il en chope un, le bloque, le remplit, met à jour le grand buffer, et libère le petit buffer.

Y a-t-il une méthode pour faire ce genre de truc ?

Merci.

[Joel F]

boost::pool ???

[bruno_pages]

Bonsoir,

je suppose que ce qui prend du temps c'est le remplissage d'un petit buffer c.a.d. le calcul associé, alors que la recopie d'un petit dans le grand est quasi instantanée (genre memcpy) ?

si la taille des informations qui seront placées dans le grand buffer (via un petit) est connue à l'avance (peut être même fixe) alors il est inutile de passer par un petit buffer et autant écrire directement dans le grand à partir de la bonne position => plus de problème de gestion des petits buffers

sinon, pourquoi ne pas allouer un petit buffer pour chaque thread une fois pour toute lors de leur lancement ?

sinon une gestion de protégée par un mutex de 'n' buffers libres avec une opération de prise et une de relachement est très simple à faire, la question porte sur cela ?

[oodini]

Je suppose que ce qui prend du temps c'est le remplissage d'un petit buffer c.a.d. le calcul associé, alors que la recopie d'un petit dans le grand est quasi instantanée (genre memcpy) ?

si la taille des informations qui seront placées dans le grand buffer (via un petit) est connue à l'avance (peut être même fixe) alors il est inutile de passer par un petit buffer et autant écrire directement dans le grand à partir de la bonne position => plus de problème de gestion des petits buffers

Certes, mais je dois simuler une API qui m'envoie en multithreads des petits buffers que je dois recopier.

sinon, pourquoi ne pas allouer un petit buffer pour chaque thread une fois pour toute lors de leur lancement ?

C'est effectivement ce à quoi j'avais pensé. Mais cela oblige le client à créer explicitement ces petits buffers, et à les détruire, et je me demandais s'il n'existait pas une méthode permettant au client de s'affranchir de ce souci.

sinon une gestion de protégée par un mutex de 'n' buffers libres avec une opération de prise et une de relâchement est très simple à faire, la question porte sur cela ?

Oui, mais voir ma réponse précédente.
Je pensais que c'était un problème récurrent en multithreads, et que donc une solution plus aboutie existait.

Il aurait fallu pouvoir filer à l'appel de boost::thread() une sorte de constructeur pour le thread...