Discussion :

[Lintel-oo]

Bonjour � tous,

je viens de me heurter � un probl�me dont les seules solutions que je vois sont absolument horribles au point de vue conception, c'est pour �a que je fais appel � votre aide .

Comme indiqu� dans le titre, je cherche � ex�cuter des fonctions depuis un thread, en les lan�ant depuis le thread principal. J'explique la n�cessit� de faire cela : je code un petit wrapper pour coder en Opengl en utilisant le fen�trage et les �v�nements SDL, du coup vu que je veux qu'on puisse faire du multi fen�trage et du multi vue dans chaque fen�tre, j'ai besoin de cr�er mes fen�tres dans l'unique thread graphique qui tourne. Sauf que je dois pouvoir cr�er des fen�tres depuis le thread principal. Du coup je dois appeler quelque chose du genre graphicalThread.addWindow(...); et graphicalThread ajoute la fen�tre dans sa boucle run. Cela implique de sauvegarder les arguments lors de l'appel � la fonction addWindow de graphicalThread.
C'est donc extr�mement laid, car je n'ai pas une seule fonction, mais une vingtaine, donc autant de "tuple" d'arguments � enregistrer.

Voyez-vous une solution propre ?

Edit : Evidemment, il faut que sit�t apr�s avoir post� le message j'aie l'id�e d'une solution qui me paraisse bien meilleure (je ne sais pas pourquoi �crire tuple m'a fait penser � �a), mais dites moi quand m�me ce que vous en pensez : lorsqu'on appelle addWindow, on ajoute une std::function f correspondant � la fonction qu'on souhaite appeler en lui bindant ses arguments, comme �a on n'a plus qu'� appeler f() dans l'update.

[Iradrille]

Hello,

Une simple std::deque<std::function<void()>> que tu remplis depuis n'importe quel thread, et que tu vide dans le thread principal doit faire l'affaire ?

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
#include <thread>
#include <deque>
#include <mutex>
 
void addWindow(int, float) { }
void addWindow(double) { }
 
// second thread
void work(std::mutex& mut, std::deque<std::function<void()>>& tasks) {
	while(1) {
		// [...]
		{
			std::lock_guard<std::mutex> lock(mut);
 
			// quelques soit le nombre / type des arguments, c'est caché dans une lambda
			tasks.emplace_back([]() { addWindow(1, 0.4f); });
 
			// ou via std::bind, (cast pour choisir la bonne surcharge)
			tasks.emplace_back(std::bind(static_cast<void(*)(double)>(addWindow), 2.0));
		}
	}
}
 
int main() {
	// main thread
	std::mutex mut;
	std::deque<std::function<void()>> tasks;
 
	std::thread t([&mut, &tasks]() { work(mut, tasks); });
	while(1) {
		// [...]
		{
			// on récupère les traitements à effectuer par le thread principal
			std::lock_guard<std::mutex> lock(mut);
			while(!tasks.empty()) {
				tasks.front()();
				tasks.pop_front();
			}
		}
	}
	t.join();
	return 0;
}

En fonction de la dur�e des traitement, il est peut �tre pr�f�rable de ne pas garder le lock sur la deque pendant qu'ils sont effectu�s.

[Lintel-oo]

Ouep, c'est sur quoi je m'�tais orient� (m�me si j'avais pr�f�r� utiliser une liste). Je pense que je peux passer le sujet en r�solu vu qu'il ne doit pas exister de solution plus propre.