Discussion :

[sebduth]

J'ai un code fortran qui lit un fichier de données, fait des calculs dessus, puis crée un nouveau fichier de sortie contenant les résultats.

Le traitement est long et j'aimerai le réduire.
La phase la plus longue est de loin la partie que j'ai appelée Appel de la subroutine. Les temps de lecture et d'écriture sur les fichiers sont négligeables à côté.

Je voudrais donc essayer d'opitmiser mon code, mais je ne sais pas trop quelles sont les règles à respecter.
Est ce qu'il faut privilégier l'utilisation des fonctions ou plutot les limiter? (il me semble que le cout de passage des arguments d'une fonction à une autre n'est pas négligeable).
Dans ma partie Appel, je fait par exemple appel à une fonction pour toutes les valeurs du fichier d'entrée. Est ce qu'il vaudrait mieux que je fasse moins d'appels et que ma fonction traite plus de valeurs?

Toutes les suggestion seront les bienvenues!

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
 
open (8, file=filename, status='old')
 
! Lecture des donnees
read(8,*) nbsrc
do i=1,inbsrc
  read(8,*) idum,idum,idum,Nparts(i)
enddo
 
C=0
do s=1,inbsrc
  allocate(X(Nparts(s)))
  allocate(Y(Nparts(s)))
  allocate(Z(Nparts(s)))
  allocate(Zdum(Nparts(s)))
  allocate(Mass(Nparts(s)))
  quot=Nparts(s)*(2*PI*Hx*Hy*Hz)**(0.5*esp)
 
  do k=1, Nparts(s)    
    read(8,*) X(k), Y(k), Z(k), Zdum(k), Mass(k)  ! lecture des donnees des particules
  end do
 
  ! Appel de la subroutine
  do k = 1, R 
    do j = 1,Q
      do i = 1,M   
        call estimdens(X,Y,Z,Nparts(s),Gx(i,j,k),Gy(i,j,k),Gz(i,j,k), &
	    F(i,j,k),Hx,Hy,Hz,Fp(i,j,k))          
	F(i,j,k) = F(i,j,k)/quot       
        Fp(i,j,k) = Fp(i,j,k)/quot
      end do
    end do
  end do
 
  ! Calcul
  do l=1,Nparts(s)
    C(:,:,:,s)=C(:,:,:,s)+Mass(l)*(F(:,:,:)+Fp(:,:,:))/(Hx*Hy*Hz)
  enddo
! desallocations
  if(allocated(X)) deallocate(X)
  if(allocated(Y)) deallocate(Y)
  if(allocated(Z)) deallocate(Z)
  if(allocated(Zdum)) deallocate(Zdum)
  if(allocated(Mass)) deallocate(Mass)
 
enddo
close (8)
 
open(10,file='concentrations.general')
do k = 1,R
  do j=1,Q
    do i = 1,M      
      write(10,*) Gx(i,j,k), Gy(i,j,k), Gz(i,j,k), C(i,j,k,1)
    end do
  end do
end do
close(10)

[DaZumba]

Les entrees/sorties sur disque et les allocations memoire sont chers, en general, et ne sont pas deterministes (on ne peut pas savoir a l'avance le temps qu'ils vont prendre).
Les appels de fonctions coutent un peu parce que le programme doit copier les arguments, mais le passage par reference du Fortran fait que le cout n'est pas enorme. Se priver des fonctions n'est pas une bonne solution.

Ton petit code est optimise. Evidemment, le travail que doit faire la routine estimdens peut etre long. Tu peux optimiser cela en ameliorant l'algorithme pour avoir a faire moins d'operations. Mais il n'y a pas de miracle, s'il y a du travail a faire, cela va prendre du temps.
Tu pourrais faire les boucles sur i, j et k dans la routine estimdens (mais il faudra passer les dimensions R, Q et M). Cela a le desavantage de faire perdre le cote "generique" de estimdens.

Enfin, tu peux demander au compilateur d'optimiser l'executable produit. C'est generallement l'option -O<level>, ou level peut prendre des valeurs allant de 0 (pas d'optimisation) a 3 ou 4 (optimisation maximale).