Discussion :

[Dliw0]

Bonjour,

J'ai écris un programme C générant un labyrinthe de manière aléatoire avant d'en trouver la sortie à l'aide de l'algorithme A*, le tout étant illustré graphiquement grâce à la bibliothèque SDL.

Dans un premier temps je ne me suis pas embêter à gérer les interactions utilisateurs donc il est impossible de fermer le programme classiquement en cliquant sur la croix tant que l'algorithme A* n'est pas terminé, ce qui peut être long sur de gros labyrinthes. Une fois le chemin trouvé le programme se met en pause avec le classique SDL_WaitEvent en attendant la fermeture.

J'ai voulu y remédier (l'utilisateur doit pouvoir quitter à tout moment le programme) et pour faire cela j'ai utilisé un thread qui prend en charge l'application de l'algorithme A*, le processus principal étant simplement la boucle d'attente des événements. J'ai bien évidement géré la synchronisation afin qu'on ne continue pas à vouloir afficher des choses sur l'écran alors que le programme doit se fermer etc.

Tout marche bien mais comme j'ai un peu fais ça au feeling je me demandais si c'était la bonne manière de faire, ou pas ?
Si il existe d'autres méthodes, quels sont leurs avantages et inconvénients comparé à la mienne ?

Merci d'avance pour vos réponses.

[Neckara]

Bonjour,

Dès qu'on veut faire de longs traitements tout en ayant une interface réactive, on a pas beaucoup de choix.

Faire deux threads, l'un pour l'interface et l'autre pour le calcul me semble être la meilleure solution.

Il existerait une autre solution : appeler régulièrement dans ton calcul une fonction pour gérer l'interface graphique (regarder les E/S et rafraîchir l'écran).
Dans certains cas cette méthode peut être intéressante, par exemple si on a une boucle on peut appeler cette méthode tous les X tours de boucles. Pour afficher le résultat d'une commande "find" (recherche de fichiers), c'est une solution qui pourrait être envisagée.

[gangsoleil]

Bonjour,

Tu peux aussi t'interesser a la gestion des signaux, qui semblent etre une bonne solution dans ton cas.

Attention, signaux et threads ne font pas bon menage.

[Dliw0]

Merci pour vos réponses.

Tant mieux Neckara, c'est en effet comme ça que j'ai procédé.
Par contre je ne vois pas bien en quoi l'utilisation de signaux peut résoudre ce problème sans tout de même créer des threads ? Juste pour la synchronisation ? Je suis plus à l'aise avec des sémaphores ou flags placés dans le programme, si c'était dans ce but.

Edit : tiens au passage je me demandais : j'ai un processus à 4 cœurs. Lorsque je crée un thread, celui-ci peut-il être exécuté sur un autre cœur (physique) que le processus créateur ? Si oui, dans ce cas on doit aussi y gagner en performance non ?

[gangsoleil]

j'ai un processus à 4 cœurs. Lorsque je crée un thread, celui-ci peut-il être exécuté sur un autre cœur (physique) que le processus créateur ? Si oui, dans ce cas on doit aussi y gagner en performance non ?

Oui, il peut etre execute ailleurs. Non, tu ne gagnes pas forcement. Mais tu peux.

Ton processeur a 4 coeurs, et differents niveau de memoire (de la plus lente a la plus rapide, mais de la plus grosse a la plus petite) : disque, RAM, cache L3, cache L2 et cache L1.
Lorsque, pour un calcul, un processus a besoin d'une donnee, il va la chercher dans ces differents niveaux de memoire, pour au final la charger dans son cache.

Les threads partagent la memoire du processus. Donc si tu as 4 caches L1, un par coeur, le niveau de partage le plus fin est ce qui se trouve dans le cache L2. Donc :
T1 met la donnee D1 dans son cache C1. T2 a besoin de la donnee D1 : il va la chercher, et la copie dans son cache C2, ce qui rend obsolete la donnee dans C1. Donc si T1 a besoin a nouveau de la donnee D1, il y a un defaut de cache, et un rechargement dans C1. Et T2 doit egalement recharger la donnee si besoin.

Si le coeur 1 et le coeur 2 partagent de la memoire cache (ce qui est le cas des processeurs Nehalem d'Intel par exemple), par exemple de la memoire cache de niveau 2, alors le gain peut etre assez grand, selon le type de calcul.

Donc ca depend du type de calcul, de l'ordonnancement des processus, et de l'architecture du processeur.