Discussion :

[mehdi_me85]

Bonjour,

Afin d'améliorer les performances de mon code, je suis entrain de passer du simple thread au multi-threading mais j'ai quelques soucis. Je constate que les listes et les iterators ne sont pas des objet safe et donc il provoquent des plantages lors de l'exécution.

Est ce que vous savez s'il existe des listes et des iterateur safe, que je peux utiliser au lieu des listes et iterator classiques?

Merci

[JolyLoic]

Oui, c'est normal, et c'est même voulu. A soi même de gérer en externe la synchronisation sur ces objets. La gérer en interne imposerait des restrictions d'usages trop gênantes dans le cas général.

Maintenant, si tu veux des collections aux fonctionnalités plus réduites, mais avec certaine sémantique multithead, tu peux regarder du côté de thread building blocks (biblitohèque open source développée par Intel).

[mehdi_me85]

Merci JolyLoic pour ta réponse,

Je viens de parcourir la doc, mais je n'ai pas trouvé de réponses concernant mon problème. La librairie il propose des méthodes pour parcourir une liste en parallèle :

Code :

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

1
2
3
4
5
6
7
 
For example, consider the following serial code:
void SerialApplyFooToList( const std::list<Item>& list ) {
for( std::list<Item>::const_iterator i=list.begin() i!=list.end();
++i )
Foo(*i);
}

If Foo takes at least a few thousand instructions to run, you can get parallel speedup
by converting the loop to use parallel_do. To do so, define an object with a const
operator(). This is similar to a C++ function object from the C++ standard header
<functional>, except that operator() must be const.

Code :

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

1
2
3
4
5
6
7
 
class ApplyFoo {
public:
void operator()( Item& item ) const {
Foo(item);
}
};

The parallel form of SerialApplyFooToList is as follows:

Code :

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

1
2
3
4
 
void ParallelApplyFooToList( const std::list<Item>& list ) {
parallel_do( list.begin(), list.end(), ApplyFoo() );
}

Mais moi, j'ai besoin d'une classe qui ressemble à une liste mais avec des méthodes safe. De façon que je puisse traites deux listes par exemple sans aucun souci de concurrences.

Merci

[JolyLoic]

Il y a 3 conteneurs thread safe dans cette bibliothèque : concurrent_vector, concurrent_queue, concurrent_hash_map.

Maintenant, je ne suis pas certain de bien comprendre ce que tu veux : Tu parles de 2 listes. Il ne devrait pas y avoir de problèmes à travailler sur deux listes différentes dans deux threads différents (sauf si tu as trafficoté l'allocateur).

De même, si tu itères sur une même liste depuis deux threads, mais sans la modifier, et avec des itérateurs différents dans chaque thread (car eux, tu es obligé de les modifier), il ne devrait pas non plus y avoir de soucis.

[mehdi_me85]

Je vais essayer de reproduire le plantage que j'ai eu, et dés que j'aurais un résultat explicite, je vais le publier. Car si j'ai bien compris, je ne dois pas avoir de problème car je travaille sur des listes différentes.

Merci.

[Goten]

Ouaip, un problème d'accès concurrent c'est quand deux threads essayent d'accéder à la même donnée en même temps. Si c'est deux données distinctes il doit pas y'avoir de soucis. (ou alors il vient d'ailleurs.)

[mehdi_me85]

Salut,

Vous avez raison, j'ai bien vérifié et j'ai trouvé que les deux listes accèdent à la même donnée durant l'exécution et donc un Mutex a réglé le problème.

Merci.