Discussion :

[robinsondesbois]

Bonjour,

Je suis en train de fabriquer un simulateur multi-agent multithreader.
Je lance donc 5000 threads, un pour chaque agent. Il se trouve que le lancement des threads est très lent (350 ms).
Je cherche donc à stocker mes agents dans un vector puis de les lancer plus tard.

voici un code minimal :

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
#include <iostream>
#include <thread>
#include <vector>
#include <chrono>
 
void agent()
{
	int cmp = 0;
	for (int i=0; i< 100; ++i)
		++cmp;
}
 
 
int main(int argc, char* argv[]) 
{
	auto start_time=std::chrono::high_resolution_clock::now(), end_time=std::chrono::high_resolution_clock::now();
 
 
	std::vector<std::thread> vt;
	start_time = std::chrono::high_resolution_clock::now();
 
	for (int i=0; i<5000; ++i)
		vt.push_back(std::thread(agent));
 
	end_time = std::chrono::high_resolution_clock::now();
	std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count() << ":";
 
 
	for (std::vector<std::thread>::iterator it = vt.begin(); it != vt.end(); ++it)
		(*it).join();
 
	return EXIT_SUCCESS;
}

Voici ce que j'aimerais obtenir :
- création des 5000 threads dans un vector (sans les lancer)
- lancer les 5000 threads.
- les relancer quand les 5000 ont finis
- les relancer quand les 5000 ont finis
- les relancer quand les 5000 ont finis
- les relancer quand les 5000 ont finis
- les relancer quand les 5000 ont finis

Je n'arrive pas à trouver une fonction pour relancer les threads.

Merci d'avance pour votre aide
Robin

[JolyLoic]

C'est souvent une mauvaise idée : Les OS ont des limites quant au nombre de threads simultanés existants, et la création d'un thread est une opération lourde qui ne se justifie que si l'on effectue un nombre important d'opérations dedans. Certaines bibliothèques (TBB, PPL) fournissent la notion de task, adaptées à de petits traitements, pouvant être crées en grand nombre, et qui se partagent un faible nombre de threads en les réutilisant (de l'ordre de un thread par cœur).

[robinsondesbois]

Merci beaucoup pour cette réponse rapide

Voici le nouveau code :

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
#include <iostream>
#include <thread>
#include <vector>
#include <chrono>
#include <tbb/tbb.h>
 
using namespace tbb;
 
 
void agent(int i)
{
	int cmp = 0;
	for (int i=0; i< 1000; ++i)
		++cmp;
}
 
int main(int argc, char* argv[]) 
{
	std::chrono::system_clock::time_point start_time, end_time;
 
	while(1)
	{
		start_time = std::chrono::high_resolution_clock::now();
		parallel_for(0, 100000, 
			[&](int i) 
			{
				agent(i);
			} 
		);
		end_time = std::chrono::high_resolution_clock::now();
		std::cout <<"all block"<< std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count() << std::endl;
	}
 
	return EXIT_SUCCESS;
}

Je peut maintenant lancer 100 000 agents en temps réel en mode debug
Merci beaucoup !