Discussion :

[gumpman]

Shalom, je cherche a executer un certains nombre de threads en respectant un certain graphe de dépendance.
Par exemple:

P1
/ \
P2 P3

En gros P2 et P3 doivent s'executer apres la fin de P1.
Tout le défi est de ne pas utiliser les mécanismes de syncho (pas de mutex, ni de barrières).

Ce qui m’intéresse c'est comment orchestrer les threads, je n'arrive pas trop à voir comment faire.
Merci d'avance

[LittleWhite]

Bonjour,

J'imagine qu'un tel exercice est un devoir d'école... Enfin bref, vous pourriez très bien avoir une liste de tâche qui serait traitée dans une boucle. Tant qu'il y a des tâches dans votre liste, vous devez traiter. Chaque tâche sera traité en créant un thread et en exécutant le calcul de la tâche. Une tâche peut très bien, ajouter de nouvelle tâche dans la liste, qui seront traitée à la prochaine itération de la boucle.
Je pense en avoir assez dit
Il y a aussi certainement d'autres façons de faire. Possible aussi qu'une difficulté d'éviter les problèmes lors d'ajout de nouvelles tâches

[gumpman]

Alors oui c'est un devoir, j'avais déjà essayé plusieurs méthodes dont celle ci qui fonctionne mal.
Sans barrières, mutexes ou voir des sémaphores les boucles sont pas très efficaces.
Le mieux a faire est juste faire des grosses conditions sur les pthread_join après la terminaison du thread.
Merci pour ton idée tout de même.

[LittleWhite]

Pourtant, je suis persuadé que cela peut se faire. Je pars du principe que l'on a pas le droit aux atomiques non plus
Dans un modèle avec un seul thread travailleur (en plus d'un thread principal), on peut y arriver facilement : le thread principale effectue une boucle principale tant qu'il y a des tâches. Il spawn un thread au début, pour traiter les tâches et il join à la fin, pour attendre la fin des tâches. Le thread travaillant sur les tâches va remplir une autre liste (la liste des nouvelles tâches) au fur et à me sure de son travail.
Et c'est à peu près tout, ça devrait passer.

Il y a moyen de mettre ça en plusieurs threads de travail, avec un procédé de map reduce. En bref, plusieurs threads travaillent, chacun remplit ça propre liste de nouvelles tâches et une fois que tous les threads ont travaillé, on rassemble toutes les nouvelles tâches dans la liste de travail principale et on recommence .