Threads avec boost : débutant

Bonjour à tous :)

Je rencontre une grosse difficulté quand au fonctionnement des threads. Tout d'abord il faut que je vous dise que je ne suis pas un programmeur et que le c++ c'est pas ma tasse de thé (je sais je suis mal :D).

Voici mon problème :
Jusqu'à aujourd'hui j'ai 2 applications distinctes (deux exe).

Une programmée avec opengl qui me permet d'avoir une interface graphique mais surtout elle me permet la création d'un motif 2D que je peux déplacer à volonté avec 6 variables (3 en translation, 3 en rotation).

Dans l'autre application, je calcule ces données en translation et en rotation.

Mon but serait donc de tout regrouper dans un même prog en utilisant les threads, ce qui donnerait un truc du genre :
thread 1 : appli opengl
thread 2 : appli calcul

J'ai compris grâce au tuto du site (merci à son auteur) comment créer deux threads. Cependant je n'arrive pas à déterminer comment communiquer entre ces deux threads.
Voilà en gros ce que je sais faire :

Code:

---

1 2 3 4 5 6 7 8 9 10

int main(const int argc, char** argv) { boost::thread thrd(&calculation); boost::thread thrd2(&appli_opengl); thrd.join() thrd2.join();   return 0; }

---

C'est à dire pas grand chose :oops:
Je sais qu'il faudra gérer ça avec des mutex pour que les deux threads n'accédent pas aux variables en même temps. Mais après... en fait si quelqu'un avait la bonté de me montrer un exemple simple (archi simple) de deux threads qui communiquent entre eux avec boost, je lui en serais vraiment reconnaissant.
Tout conseil(ou liens) ou encouragement :lol: est également bon à prendre donc n'hésitez pas !!

Mercciii.

Quel type de communication ?
Tu veux signaler un événement ? Envoyer un message ? Modifier de l'état partagé ?

Je veux juste envoyer des données :
- appli calcul envoi matrice translation et rotation
- appli opengl reçoit cette matrice

Je n'arrive pas à trouver comment déclarer des threads avec des paramètres...
Et autre question : devrais-je utiliser des mutex pour éviter que les deux threads accèdent aux mêmes variables en même temps?

Double post mais c'est pour la bonne cause, donc pour avoir des threads avec des paramètres, il suffit d'utiliser bind de cette manière, nan?

Code:

---

boost::thread thrd(boost::bind(&calculation,&T_dep));

---

avec T_dep comme paramètre.

En tout cas, ça a l'air de marcher. Il me reste plus qu'à utiliser des mutex pour contrôler l'accès aux données, des indices là dessus??

D'un côté tu parles d'exécutables indépendants, et de l'autre de fonction avec des paramètres (paramètres que tu ne nous indique pas). Ce n'est pas du tout la même chose. Peut-être pourrais-tu mieux expliquer ta situation ?

pour passer des paramètres à un thread tu peux utiliser un functor

Citation:

---

D'un côté tu parles d'exécutables indépendants, et de l'autre de fonction avec des paramètres (paramètres que tu ne nous indique pas). Ce n'est pas du tout la même chose. Peut-être pourrais-tu mieux expliquer ta situation ?

---

Au départ j'avais deux executables(opengl et calcul) indépendants mais pour pouvoir communiquer entre les deux sans passer par des sockets (par exemple), j'ai tout regroupé dans un seul programme (avec deux fonctions : opengl et calcul)

Est-ce plus clair?

@nikko34:A priori avec bind, ça fonctionne pour faire passer des paramètres, je regarderai functor pour me renseigner, merci

Citation:

---

Envoyé par tortue3600

Au départ j'avais deux executables(opengl et calcul) indépendants mais pour pouvoir communiquer entre les deux sans passer par des sockets (par exemple), j'ai tout regroupé dans un seul programme (avec deux fonctions : opengl et calcul)

Est-ce plus clair?

---

C'est déjà mieux...

Maintenant, si j'ai bien compris le problème, tu veux que ton code de calcul envoie régulièrement des informations à ton code d'affichage. Avec bind, tu peux définir les valeurs avec lesquelles ta fonction d'affichage va être initialisée, au moment où elle va être lancée uniquement. Ce n'est pas vraiment la même chose.

Maintenant, deux threads se partagent le même espace mémoire. Donc il suffit qu'un thread écrive à un endroit particulier (variable globale, ou mieux, emplacement dont l'adresse a été passée en paramètre à la fonction de démarrage du thread), et que l'autre lise au même endroit quand il en a besoin.

Pour éviter que la lecture se passe au mauvais moment (pile poil au milieu de l'écriture, quand la structure n'est plus cohérente), il te faut protéger l'accès à cette zone mémoire, par exemple par un mutex, mutex qui doit aussi être partagé entre les deux threads.

Donc, je définirait probablement la fonction de démarrage de tes threads ainsi :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

struct Parameters { double x; double y; double z; double h; double p; double r; };   void lanceThreadDeCalcul(Parameters *outputArea, boost::recursive_mutex &mutex);

---

Et le code d'écriture des infos par exemple ressemblerait à :

Code:

---

1 2 3 4 5 6 7 8 9

{ lock_guard<boost::recursive_mutex> lock(mutex); outputArea->x = 42; outputArea->y = 2; outputArea->z = 4; outputArea->h = 314; outputArea->p = 157; outputArea->r = 0; }

---

PS : bind permet de créer des foncteurs simplement. Donc, si tu as essayé bind, tu a utilisé un foncteur sans le savoir.

Désolé de ne pas avoir répondu avant.
J'ai continué à chercher de mon côté et j'avais finalement opté pour des variables globales, par contre pour les mutex j'avais un peu laissé de côté.

Ton exemple est parfait et simple à comprendre alors :merci:
Testé et approuvé :D