programme multithread fortran

**fortran83** · 18/05/2011, 16h19

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** · 19/05/2011, 08h00

Bonjour,

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

Bonne continuation.

**fortran83** · 19/05/2011, 08h12

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** · 19/05/2011, 08h47

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** · 25/05/2011, 19h16

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** · 25/05/2011, 19h33

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....

programme multithread fortran

Fortran

Vue hybride

Discussions similaires

Partager

Partager