Discussion :

[fortran83]

Bonjour,

j'essaye de créer un programme fortran ultra simple (pour comprendre) pour lancer sur chacun des coeurs de mon processeur (j'ai un quad) différentes subroutines. Une fois qu'elles se sont exécutées, je veux en "réunir" les résultats.

Par exemple la subroutine n°1 calcule 2*x^2, la n°2 3*x^3, la n° 3 5*sin(x), la 4° dsqrt(x). Puis je veux faire la somme de ces résultats une fois que chaque tâche a fini et l'afficher.

J'ai compaq fortran et je n'arrive même pas à comprendre les exemples livrés avec le fortran (multthrd.f90 entre autres) !

Auriez vous déjà réalisé un exemple de programme "élémentaire" pour comprendre le multithread ? Y a t-il un cours en français disponible ?

merci de votre aide

[Ehouarn]

Bonjour,

Je te conseille d'aller voir du coté des supports de cours de l'IDRIS.

Bonne continuation.

[fortran83]

Bonjour,

merci de ton attention. Je vais aller voir.

J'ai en effet un mini projet au sujet du lancer de plusieurs subroutines via un même programme fortran. Elles doivent remplir un tableau commun après avoir effectuer chacune un calcul distinct, et tout ca dans une boucle !

J'essaye d'abord de comprendre.

à bientôt

[fortran83]

Bonjour,

je viens de télécharger les cours de l'IDRIS, c'est pas du tout pédagogique et ca démarre trop fort pour moi qui suis débutante.

N'y aurait il pas quelques choses du type : multithread en fortran pour les nulles ?

à bientot

[MABROUKI]

Bonjour fortran 83
voici 2 exemples assez simples de multi-thread en fortan compaq ,qui utilise l'api win32 avec laquelle tu dois te familiariser.
Je te suggere de faire un peu de vb.net plutot que l'api win32 pour te familiariser avec les :
- start thread,waitforsingleobject,waitformultipleobject,
EnterCriticalSection(section critique "zone de donnees commune" verouille),suspendthread etc....
Sache que c'est la logique du multithreading qui est plus difficile à apprehender par rapport à la logique sequentielle,que le compaq fortran lui-meme.
voici 2 petits exemples qui j'espere te faciliteront la comprehension du compaq fortran.

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
C     On voit que thrdRun1(k=60) se termine apres  thrdRun2(k=30)
C     
 
 
C         PROGRAM PRINCIPAL
 
       PROGRAM  ExampleBoucle
       USE DFMT
	 USE modBoucle
 
 
C     param Tableau contient les Handles de Thread quand on veut demarrer plusieurs thread
C     param nombre de threads à demarrer
 
	 INTEGER*4 :: tableThread(2),nombreThread
C     threadID1,threadID2 sont des param retours qui contiennent
C     l'idendificateur de thread si on veut s'y referer plus tard
C	pour d'autres taches (suspension par exemple)
       INTEGER*4 :: threadID1,threadID2
	 INTEGER*4 :: Iret
	 LOGICAL*4 :: Tous
 
 
 
C	INITIALISATION
 
       Tous=.TRUE.
       a1=0.0
	 a2=0.0
 
       nombreThread=2
 
C	INITIALISATION DU VERROU  verrouilleLock
 
	 CALL InitializeCriticalSection(loc(verrouilleLock))
 
C	CREATION DES THREADS .CAS SANS PARAMETRES(param =0)
 
       tableThread(1) = CreateThread( 0, 0,thrdRun1,0,
     1		   0, LOC(threadID1)  )
 
 
       tableThread(2) = CreateThread( 0, 0, thrdRun2,0,
     1		    0, LOC(threadID2)  )
 
 
 
C     ATTENTE QUE TOUS LES THREADS SOIENT TERMINES POUR CALCULER LES VALEURS DE RETOUR
C     parametre Tous=>  vrai =>attend les 2 threads faux => au moins un thread termine.
C     parametre INFINITE => attente infinie jusqu'a terminaison de tous les threads(sans delai)
 
 
 
	 Iret = WaitForMultipleObjects( nombreThread,tableThread,Tous,
     1  INFINITE )
 
	 a1=x1
	 a2=x2
 
	 PRINT* ,"a1  :",a1
	 PRINT* ,"a2  :",a2
 
 
	 PAUSE
 
	END PROGRAM  ExampleBoucle
 
C           plus le module
C     type(RTL_CRITICAL_SECTION) verrouilleLock
C     Declaration au niveau module
C     Doit etre initialise dans prog principal par:
C     call InitializeCriticalSection( loc(verrouilleLock) )
 
C     la variable verrouilleLock permet de bloquer l'access
C     à une resource commune -console-  
C     par le thread numero -k- jusqu' à terminer traitement 
C     & liberation
 
C     code dans thread -k- 
C 	call EnterCriticalSection( loc(verrouilleLock) )
C      ...message.....
C     call LeaveCriticalSection( loc((verrouilleLock) )
C
      MODULE modBoucle
      USE DFMT
      IMPLICIT NONE
      REAL*8    :: x1,x2
      REAL*8    :: a1,a2
 
	type(RTL_CRITICAL_SECTION) verrouilleLock
 
	CONTAINS
C------------------------------------------------------
C	SUB N°1  x1 = alog(exp(x1)) 
C------------------------------------------------------
	SUBROUTINE thrdRun1()
      USE DFMT
      INTEGER*4 :: i,k     
      CHARACTER(20) ::nomproc
      CHARACTER(20) ::message
 
C     Subroutine work goes here.
 
	message="thrdRun1 demarre:"
	CALL EnterCriticalSection(LOC(verrouilleLock))
         WRITE(*,1000) message
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
	nomproc="thrdRun1:"
	x1=2.0 
      DO k=1,60 
        DO i=1,1000000
           x1=DLOG(DEXP(x1)) 
        ENDDO 
      ENDDO   
 
	CALL EnterCriticalSection(LOC(verrouilleLock))
        message="thrdRun1 termine:"
	  WRITE(*,1000) message
	  WRITE(*,1100) nomproc, k,i,x1
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
      CALL exitthread(0) ! Exit code is 0.
 
1000  FORMAT(1X,A20,/)
1100  FORMAT(1X,A20,I4,2x,I10,F20.15,/)
      END SUBROUTINE
 
C------------------------------------------------------
C	SUB N°2  x2 = alog(exp(x2)) 
C------------------------------------------------------
	SUBROUTINE thrdRun2()
      USE DFMT
      INTEGER*4 :: i,k      
      CHARACTER(20) ::nomproc
      CHARACTER(20) ::message
C     Subroutine work goes here.
 
	message="thrdRun2 demarre:"
	CALL EnterCriticalSection(LOC(verrouilleLock))
      	 WRITE(*,1000) message
    	CALL LeaveCriticalSection(LOC(verrouilleLock))
 
	nomproc="thrdRun2:"
	x2=2.0 
      DO k=1,30 
        DO i=1,1000000
           x2=DLOG(DEXP(x2)) 
        ENDDO 
      ENDDO   
 
	CALL EnterCriticalSection(LOC(verrouilleLock))
	 message="thrdRun2 termine:"
	 WRITE(*,1000) message
	 WRITE(*,1100) nomproc, k,i,x2
	CALL LeaveCriticalSection(LOC(verrouilleLock))
 
 
      CALL exitthread(0) ! Exit code is 0.
 
1000  FORMAT(1X,A20,/)
 
1100  FORMAT(1X,A20,2x,I4,2x,I10,F20.15,/)
      END SUBROUTINE
 
	END MODULE modBoucle

2eme exemple

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
 
 
 
C         PROGRAM PRINCIPAL
 
       PROGRAM  Example
       USE DFMT
	 USE modThread
 
	 REAL*8    :: resultat
	 INTEGER*4 :: numBoucle
	 INTEGER*4 :: tableThread(4)
       INTEGER*4 :: nombreThread
 
	 INTEGER*4 :: Iret
	 LOGICAL*4 :: Tous
 
 
C	INITILISATION
 
       Tous=.TRUE.
       y1=0.0
	 y2=0.0
	 y3=0.0
	 y4=0.0
 
       nombreThread=4
 
	 x=10.0
 
C	INITIALISATION DU VERROU  verrouilleLock
 
	CALL InitializeCriticalSection(loc(verrouilleLock))
 
C	CREATION DES THREADS
       numBoucle=500
       tableThread(1) = CreateThread( 0, 0, thrdSub1,numBoucle, 
     1		    0, LOC(threadID1)  )
 
       numBoucle=1000000
       tableThread(2) = CreateThread( 0, 0, thrdSub2,numBoucle, 
     1		    0, LOC(threadID2)  )
 
       numBoucle=10000
	 tableThread(3) = CreateThread( 0, 0, thrdSub3, numBoucle, 
     1		    0, LOC(threadID3)  )
 
	 numBoucle=1000	 
	 tableThread(4) = CreateThread( 0, 0, thrdSub4, numBoucle, 
     1		    0, LOC(threadID4)  )
 
C     ATTENTE QUE TOUS LES THREADS SOIENT TERMINES POUR CALCULER LA SOMME
C     Parametre Tous=> 
C      ***boolean : vrai =>attend les 4 threads ***. 
C      ***faux => au moins un thread termine    ***.
C     Parametre INFINITE =>
C      ***attente indefinie jusqu'a terminaison de tous les threads(sans delai)
C      ***attente avec un delai exprimee en milliseconds(timeout) ***
 
 
	 Iret = WaitForMultipleObjects( nombreThread,tableThread,Tous,
     1  INFINITE )
 
	 resultat=y1+y2+y3+y4
 
	 print* ,"Resultat General :",resultat
	 pause
 
	END PROGRAM
 
 C           plus le module
 
C     type(RTL_CRITICAL_SECTION) verrouilleLock
C     Declaration au niveau module
C     Doit etre initialise dans prog principal par:
C     call InitializeCriticalSection( loc(verrouilleLock) )
 
C     la variable verrouilleLock permet de bloquer l'access
C     à une resource commune -ici console-  
C     par le thread numero -k- jusqu' à terminer traitement 
C     & liberation
 
C     code dans thread -k- 
C 	call EnterCriticalSection( loc(verrouilleLock) )
C      ...message.....
C     call LeaveCriticalSection( loc((verrouilleLock) )
C
      MODULE modThread
      USE DFMT
      IMPLICIT NONE
      REAL*8 :: x
      REAL*8 :: y1,y2,y3,y4
 
      TYPE(RTL_CRITICAL_SECTION) verrouilleLock
 
	CONTAINS
C------------------------------------------------------
C	SUB N°1  y1= 2.0*x**2.0
C------------------------------------------------------
	SUBROUTINE thrdSub1(n)
      USE DFMT
 
      INTEGER*4:: i,n
      CHARACTER(20) ::message
 
 
      !DEC$ ATTRIBUTES VALUE :: n
C     Subroutine work goes here.
 
      message="thrdSub1 demarree :"
      CALL EnterCriticalSection(LOC(verrouilleLock))
         WRITE(*,1000) message
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
	DO i=1,n
        y1= 2.0*x**2.0
      END DO 
 
 
	CALL EnterCriticalSection(LOC(verrouilleLock))
         message="thrdSub1 termine :"
	   WRITE(*,1100) message, i,y1
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
 
      CALL exitthread(0) ! Exit code is 0.
 
1000  FORMAT(1X,A20,/)
1100  FORMAT(1X,A20,2X,I4,F20.15,/)
      END SUBROUTINE
 
C------------------------------------------------------
C	SUB  N°2  y2 = 3.0*x**3.0
C------------------------------------------------------
	SUBROUTINE thrdSub2(n)
      USE DFMT
 
      INTEGER*4:: i,n
      CHARACTER(20) ::message
 
	!DEC$ ATTRIBUTES VALUE :: n
 
C     Subroutine work goes here.
 
	message="thrdSub2 demarree :"
      CALL EnterCriticalSection(LOC(verrouilleLock))
         WRITE(*,1000) message
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
      DO i=1,n
        y2 = 3.0*x**3.0
      END DO 
 
	CALL EnterCriticalSection(LOC(verrouilleLock))
         message="thrdSub2 termine :"
	   WRITE(*,1100) message, i,y2
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
 
      CALL exitthread(0) ! Exit code is 0.
 
1000  FORMAT(1X,A20,/)
1100  FORMAT(1X,A20,2X,I4,F20.15,/)
      END SUBROUTINE
 
 
C------------------------------------------------------
C	SUB N°3  y3 = 5*DSIN(x)
C------------------------------------------------------
	SUBROUTINE thrdSub3 (n)
      USE DFMT
 
      INTEGER*4:: i,n
      CHARACTER(20) ::message
 
	!DEC$ ATTRIBUTES VALUE :: n
C     Subroutine work goes here.
 
      message="thrdSub3 demarree :"
      CALL EnterCriticalSection(LOC(verrouilleLock))
         WRITE(*,1000) message
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
 
	DO i=1,n
       y3 = 5*DSIN(x)
      END DO 
 
	CALL EnterCriticalSection(LOC(verrouilleLock))
         message="thrdSub3 termine :"
	   WRITE(*,1100) message, i,y3
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
      CALL exitthread(0) ! Exit code is 0.
 
1000  FORMAT(1X,A20,/)
1100  FORMAT(1X,A20,2X,I4,F20.15,/)
      END SUBROUTINE
 
C------------------------------------------------------
C	SUB N°4  y4 = DSQRT(x). 
C------------------------------------------------------
 
	SUBROUTINE thrdSub4 (n)
      USE DFMT
 
      INTEGER*4:: i,n
      CHARACTER(20) ::message
 
 
      !DEC$ ATTRIBUTES VALUE :: n
C     Subroutine work goes here.
 
 
      message="thrdSub4 demarree :"
      CALL EnterCriticalSection(LOC(verrouilleLock))
         WRITE(*,1000) message
      CALL LeaveCriticalSection(LOC(verrouilleLock))
	DO i=1,n
       y4 = DSQRT(x) 
	END DO 
 
	CALL EnterCriticalSection(LOC(verrouilleLock))
         message="thrdSub4 termine :"
	   WRITE(*,1100) message, i,y4
      CALL LeaveCriticalSection(LOC(verrouilleLock))
 
      Call exitthread(0) ! Exit code is 0.
 
1000  FORMAT(1X,A20,/)
1100  FORMAT(1X,A20,2x,I4,F20.15,/)
      END SUBROUTINE
 
	END MODULE modThread

bon code.....

[MABROUKI]

bonjour fortran83
ah un petit detail importrant!
N'oublies pas dans Projet->Settings->Panneau Fortran ->Combox Librairaies ->Combox Use Run-Time Librairie :choisir multi-threaded.
bon code....

[Matthieu Brucher]

Perso, je te conseille d'utiliser OpenMP, voire la fonction FOR_ALL.

[fortran83]

Bonjour,

je te remercie. Je vais regarder cela. En tout cas, ton code me parait beaucoup plus accessible et pédagogique que ceux de l'IDRIS du CNRS

Je te tiens au courant

[fortran83]

Bonjour,

j'ai essayé les programmes. Ils se compilent bien mais refusent le link.

Pour la compilation il a cependant fallu que je mette le module avant l'instruction program ! Est ce normal car tu as du le faire marcher tel que tu me l'a envoyé ?

Par exemple le programme ExampleBoucle sort comme erreur :

Compiling Fortran...
C:\fortrans\sources\essai_multitaches\forum\modules_1_2.for
C:\fortrans\sources\essai_multitaches\forum\exemple_multithread_1.for
Linking...
libcmt.lib(wincrt0.obj) : error LNK2001: unresolved external symbol _WinMain@16
Debug/forum.exe : fatal error LNK1120: 1 unresolved externals
Error executing link.exe.

forum.exe - 2 error(s), 0 warning(s)

Qu'en penses tu, d'ou vient mon erreur ?

Merci beaucoup pour ton aide.

[MABROUKI]

bonjour fortran83
Essai de faire un projet type console .
Ton message d'erreur vient du fait que tu as apparement fait un projet Fortan Windows Application sans les references necessaires.
Par ailleurs un projet Fortan Windows Application est assez ardu,vu que tu debutes dans Fortran Compaq.Dans ce type de projet il n' y a pas de program principal rien que des subroutines.
Le program principal fortran est en fait une subroutine en c
appele winmain que tu dois ecrire et integrer dans ton appli.

Si tu veux une interface graphique il vaut mieux utiliser le Compilateur Silverfrost Fortan (free )qui s'interface simplement avec fortran et utilise le vb.net assez facile à programmer et proche du point de vue syntaxe du bon vieux fortran.
ici le lien de silverfrost pour la version personnelle gratuite:
http://www.google.fr/url?sa=t&source...PhUPPyhmRXcKkA

bon code...

[fortran83]

Bonjour,

après quelques jours d'abscences me revoilà.

On m'a recommandé de démarrer le multithreading en visual basic ... et oui !

Et là, avec le livre "débuter en programmation" de Yann Lautrédou et Frederyk Blot, j'ai réussi à faire tourner une appli multithread sur mon quad en une dizaine de lignes de code !

Il serait intéressant d'avoir le même type de programme ultra simple en fortran pour manipuler les API windows qui gèrent cela.

J'ai mis une procédure win main dans votre programme ci-dessus mais ca été la catastrophe : des fenêtres consoles sont apparues et rien de plus sinon de devoir rebooter le PC !

Bref est ce qu'il est possible d'avoir un programme qui tourne vraiment sans planter ?

En attendant j'essaye d'en faire un ... mais pour une étudiante qui ne connait pas les API et le fortran, c'est hard. J'ai trouvé un bouquin sur le compaq fortran de norman lawrence qui en parle. mais le programme de démo du multithread est assez hard, aussi. Dommage.

à bientôt

[Matthieu Brucher]

Pour moi, Fortran n'est pas adapté à la programmation avec les API Windows.

[fortran83]

Bonjour,

je commence à piger. J'écris une petite doc et un petit programme. Mais ca prend du temps.

J'ai vu sur le forum que la norme Fortran 2008 était axée sur le parallélisme. Quel compilateur disponible (gratuit ou payant) utilise cette norme, l'intel XE ?

Je me demande s'il ne faudrait pas mieux que je m'investisse sur ce fortran plutôt que sur le compaq V6.6 ? Qu'en pensez vous ?

Merci de votre attention

[MABROUKI]

bonjour fortran83
J'ai deja mentionne dans le post precedent le compilateur fortan Silverfrost gratuit et pour cause car le visual fortran 6.6 n'est pas fameux.

Voici quelque chose d'equivalent au code deja donne fortan 6.6 mais nettement plus simple:

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
 
C   SUBROUTINE CREATE_THREAD@(SUB,ICODE)
C   EXTERNAL SUB
C   INTEGER ICODE
C  demarre un thread d'impression .
C  on peut demarrer plusieurs thread "foo" simultanement 
C  Here is a simple example of code to start a thread:
PROG   MAIN 
EXTERNAL foo
CALL CREATE_THREAD@(foo,42)
PRINT*,'Finishing main program.'
END
 
SUBROUTINE foo(m)
INTEGER m
PRINT*,'In foo ',m
END

Voici un exemple qui s'interface directement avec le .net framework sous vs 2008 en ajoutant une reference à l'assembly System.Threading.Thread.dll
comme si tu etais en vb.net mais tu es dans fortan silverfrost:

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
 
C Here is an example that illustrates the use of CREATE_THREAD1@:
PROGRAM MAIN
EXTERNAL foo
ASSEMBLY_EXTERNAL(NAME="System.Threading.Thread.Join") T_JOIN
OBJECT("System.Threading.Thread") NEW_THREAD 
CALL CREATE_THREAD1@(foo,42,NEW_THREAD)
!Do some processing...
CALL T_JOIN(NEW_THREAD)
PRINT*,'Finishing main program.'
END PROGRAM MAIN
 
SUBROUTINE foo(m)
INTEGER m
PRINT*,'In foo ',m
END

Il va de soi que le subroutine FOO pourrait aussi bien etre une Sub VB.Net ou une function C# ,pouvant par ailleurs elle meme utiliser un Form d'affichage.
Il suffit de la referencer sous Fortran avec 2 clics.

Il y a egalement le compilo intel XE qui gere le parallelisme mais avec les memes difficultes pour l'interfacage Windows.
bon code.....

[fortran83]

Bonjour

merci de ton aide.

En fait j'ai déjà essayé silverfrost mais il n'a pas voulu s'installer correctement sur mon PC. J'ai même envoyé sur leur site la copie de l'erreur que j'ai eu de la part du setup mais je n'ai jamais eu de réponse. Je me demande d'ailleurs si ce code est encore maintenu ?

En effet ton code me semble super , un peu comme une API "winexec" ou la commande "runqq" du compaq fortran, instructions que j'explore.

Je vais essayer tout d'abord de lancer, avec runqq et winexec, 3 programmes distincts, ou l'idéal, 3 subroutines distinctes qui sortent chacune, en argument (output), des variables (x_1 et tableau_1(100) pour la première, x_2 et tableau_2(100) pour la seconde et x_3 et tableau_3(100) pour la troisième) puis je les ajoute dans le programme main (write(6,*) x_1 + x_2 + x_3) et je "merge" les 3 tableaux en un grand, lui déclaré dans le main. Chacune des subroutines a en entrée des variables distinctes et un tableau, lui commun aux trois subroutines. Je vais voir ce qu'elles deviennent !

Ensuite je passe aux API multithreads. C'est mon programme d'étude du multithreading, mais je vais ré-essayer d'installer silverfrost avant de continuer.

merci