Calcul intensif avec interface

Bonjour à tous,

J'aimerais réaliser une appli qui fait du calcul intensif, avec une interface graphique (affichage de certains paramètres pour le monitoring)
Le tout est écrit en fortran2003, appelant les routines de GTK, GDK, GLIB.
Mes contraintes : calcul et affichage doivent être indépendants, dans le même code, pour portage ultérieur sur Linux, et l'interface doit être la moins intrusive possible.

Les premiers tests sont concluants (l'affichage ne gêne pas le calcul et le rafraîchissement se fait régulièrement) mais j'aimerais vos avis sur le modus operandi :

- l'appui sur un bouton "calcul" déclenche l'appel à une fonction, avec un g_signal_connect_data
- cette fonction appelle à la fois la routine calcul avec g_thread_create_full en G_THREAD_PRIORITY_NORMAL et l'affichage avec g_thread_create_full en G_THREAD_PRIORITY_LOW.
- la routine calcul écrit à intervalles régulier des paramètres dans un fichier
- la routine d'affichage lit à intervalles réguliers ce fichier et affiche les paramètres pour le monitoring

le rafraîchissement est contrôlé par une boucle sur gtk_main_iteration avec gtk_events_pending() et temporisée par g_usleep.

Cela vous semble-t-il, a priori, correct ?

(Je n'ai pas joint le code car il est écrit en fortran, et je sais que ça fait fuir les gens :lol:)

Merci !

Si t'as pas besoin du fichier intermédiaire, j'essaierai de m'en passer (via un GAsyncQueue par exemple). Et plutôt que de lire "a intervalle regulier" et de temporiser avec des g_usleep, tu peux peut être faire en sorte que le thread bloque d'une facon ou d'une autre tant qu'il n'a pas de nouvelles données ?
Sinon, vu que tu parles de threads, je présume que tu connais http://library.gnome.org/devel/gdk/s...k-Threads.html par coeur ?

Salut,

Merci pour ta réponse, quelle réactivité !

• Concernant le fichier d'échange, sur developpez, forum fortran je crois, un habitué de l'interfaçage a dit que les destinataires de codes de calcul aimaient bien fouiller ce genre de fichiers, qui servent alors de mouchards

• concernant GAsyncQueue ; cette fonction m'avait effectivement paru pratique pour communiquer des éléments d'un thread à l'autre, mais cela implique d'inclure des fonctions GTK dans la routine de calcul, qui doit rester "pur fortran" :marteau:

• concernant le rafraîchissement de l'interface lié à la modification de données, j'imagine que c'est en lien avec GAsyncQueue ; sinon est-il possible de "réveiller" l'affichage lorsqu'un fichier est modifié ? (je pense à mon fichier mouchard)

• enfin sur les gdk_threads, je t'avoue que je ne comprends pas tout (sorti de fortran, j'ai beaucoup de difficultés :aie:) mais il me semble que ce n'est important que si les threads de calcul et d'affichage partagent des données communes, ce qui n'est pas mon cas

J'ai dit de grosses bêtises ou ça tient la route ? Je pose cette question car j'ai vu que les threads sont à utiliser avec beaucoup de prudence ...

Encore merci !

Salut.

Pour "réveiller" l'affichage tu pourrais utiliser les GIOChannel. Comme tu utilises un fichier ca ne posera aucun problème.

Au vu de tes contraintes, le choix d'un fichier intermédiaire me paraît effectivement beaucoup plus judicieux que les GAsyncQueue, je mentionnais ce type de données au cas où tu ne l'aurais pas connu.
Pour le lien qui parle de gtk et des threads, il faut retenir que tous les appels à des fonctions gtk_XXX (et probablement gdk_XXX) doivent être faites depuis le même thread que celui où tourne gtk_main. Si tu es dans ce cas là, tout va bien, sinon c'est là que les choses deviennent compliquées... Si tu dois faire qques appels à des fonctions de gtk depuis un autre thread, g_idle_add est souvent un bon moyen de faire en sorte que l'appel passe de l'autre thread au thread principal (ie celui de la boucle principale de gtk+).

Si ton thread de calcul fait uniquement des calculs et écrit dans un fichier et qu'il est totalement indépendant de gtk+, tu ne devrais effectivement pas avoir de problème.

Bonjour et merci pour vos réponses !

Dès que je peux, j'étudie les GIOChannel, merci pour le tuyau.

Sinon est-il possible de mettre un thread en veille ? Typiquement, j'aimerais des boutons "pause" et "continue" sur l'interface, sans que cela n'ajoute du code GTK dans la routine de calcul ...

Bonjour,

votre message m'intéresse beaucoup car j'aimerais me lancer dans une interface GTK+ / Fortran en utilisant les ISO_C_BINDING et le compilateur gfortran, pour faire du graphisme dans une ou plusieurs fenêtres.

Avez-vous progressé dans cette voie ? Votre code est-il accessible quelque part ?

Merci
Vincent MAGNIN
P.s. Je suis actuellement en discussion sur ce sujet sur le newsgroup comp.lang.fortran :
http://groups.google.com/group/comp....8ffbfbc259ffd1

Citation:

---

Envoyé par teuf13

Si tu dois faire qques appels à des fonctions de gtk depuis un autre thread, g_idle_add est souvent un bon moyen de faire en sorte que l'appel passe de l'autre thread au thread principal (ie celui de la boucle principale de gtk+).

---

Je confirme que c'est une meilleure solution que la méthode "boucle sur gtk_main_iteration avec gtk_events_pending() et temporisée par g_usleep".

Une autre solution est d'avoir deux processus séparés:
celui en fortran qui écrit dans le fichier, et celui en C/GTK qui ne fait qu'appeler cet exécutable, lire le fichier via un mmap et dessiner ce qu'il a lu. De cette manière les deux programme sont 100% étanches, et si l'envie te vient d'avoir un frontend graphique différent, tu n'as rien à toucher dans le programme fortran effectuant les calculs.