Discussion :

[camboui]

Bonjour,

J'ai une fonction qui traite les éléments d'une collection en itérant dessus par extraction de ses éléments un par un.
Voici un exemple de code simplifié:

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
struct MyData
{
};
 
class MyRunner
{
	std::vector<MyData> f_md_vect;
public:
	void init()
	{
		// fill f_md_vect with data
	}
	void run();
};
 
void MyRunner::run()
{
	for(auto & md : f_md_vect)
	{
		//... traitement d'un élément de la collection ici
	}
}
 
void mainST()
{
	MyRunner mr;
	mr.init();
	mr.run();
}

J'aimerais améliorer les performances de ce code sachant que le traitement de chacun des éléments de la collection est indépendant. Sur base du code qui précède il me suffirait d'appeler la méthode void MyRunner::run() dans autant de threads que voulu.
Le problème est alors de s'assurer que chaque élément de la collection ne soit traité qu'une seule fois, donc de verrouiller d'une manière ou d'une autre l'itération qui a lieu dans le code for(auto & md : f_md_vect). En d'autres termes, il faudrait extraire l'itérateur de la boucle for et en faire une variable partagée entre les threads.
Voici une solution:

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
39
40
41
42
43
44
45
46
47
48
49
50
51
struct MyData
{
};
 
class MyRunnerMT
{
	std::vector<MyData> f_md_vect;
	std::vector<MyData>::iterator f_md_vect_it{}; // null iterator ... (?)
	std::shared_mutex shmtx;
 
	MyData *next()
	{
		std::lock_guard<std::shared_mutex> lock{shmtx};
		if (f_md_vect_it == f_md_vect.cend())
			f_md_vect_it = std::vector<MyData>::iterator{}; // null iterator ... (?)
		if (f_md_vect_it == std::vector<MyData>::iterator{})
			return nullptr;
		return &*f_md_vect_it++;
	}
public:
	void init()
	{
		// fill f_md_vect with data
		if (f_md_vect.size())
			f_md_vect_it = f_md_vect.begin();
	}
	void run();
};
 
void MyRunnerMT::run()
{
	for (MyData *mdptr; (mdptr = next()) != nullptr;)
	{
		MyData & md = *mdptr;
		//... traitement d'un élément de la collection ici
	}
}
 
void mainMT()
{
	MyRunnerMT mr;
	mr.init();
	std::future<void> f1 = std::async(&MyRunnerMT::run, &mr);
	std::future<void> f2 = std::async(&MyRunnerMT::run, &mr);
	std::future<void> f3 = std::async(&MyRunnerMT::run, &mr);
	std::future<void> f4 = std::async(&MyRunnerMT::run, &mr);
	f1.wait();
	f2.wait();
	f3.wait();
	f4.wait();
}

Cette solution fonctionne et je l'ai implémentée.
Mais je me demandais s'il n'y avait pas plus simple et plus lisible.
Citons ce qui me déplaît:
-exposer aussi clairement un pointeur (retour de méthode next());
-initialiser un itérateur avec la valeur "nulle" et en faire la valeur de fin d'itération;
-le déréférencement de l'itérateur pour en extraire le pointer sous-jacent (&*);
-utiliser un mutex alors que l'itérateur pourrait être atomic (mais je ne vois pas comment faire).

Merci pour vos idées

[koala01]

Salut,

Ne serais tu pas dans le cadre idéal pour utiliser std::for_each, dans sa version "multi threaded" ?

Cela pourrait ressembler à quelque chose comme

Code :

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

1
2
3
4
5
6
 
void MyRunner::run(){
std::for_each(std::execution::par, f_md_vect.begin(), f_md_vect.end(),[&](MyData /* const */ & d){
    /* manipulation de chaque élément*/;
});
}

(C++17 inside !!! )

[Bousk]

Ou lancer plusieurs threads en leur donnant chacun un morceau de la collection à traiter. Sous forme de pointeur où commencer et d'un nombre d'objet à traiter.

[Invité]

Salut
Je n'ai peut-être pas bien compris mais pourquoi ne pas tout simplement utiliser OpenMP pour traiter ta collection en parallèle ?

Code :

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

1
2
3
4
5
6
void MyRunner::run(){
    #pragma omp parallel for
    for (unsigned i=0; i<md_vect.size(); i++) {
        /* manipulation de chaque élément*/;
    }
}

[jo_link_noir]

C'est ce que fait std::for_each avec std::execution::par (au moins pour libstdc++).

[Invité]

Merci pour l'info, je ne connaissais pas cette fonctionnalité.
Honnêtement, je ne sais pas si je l'utiliserai un jour car openmp est dispo sur pratiquement tous les compilo de moins de 10 ans et permet, si besoin, de gérer finement la parallélisation.