Discussion :

[LB_99]

Bonjour,

Après avoir profilé mon code, je me suis rendu compte que 70% du temps Elapse est passé dans bout de code suivant qui est appelé des milliers de fois :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
  y(n)=0.0d0
  do i = n - 1, 1, - 1
     r = 0.0d0
     do j = istart(i), iend(i)
        r = r + a(j)*x(ja(j))
     end do
     y(i) = r
  end do

A chaque appel, les tableaux d'entiers ja, istart et iend sont identiques, ainsi que le tableau de double a. seul le tableau de double x varie.

Est-ce qu'il est possible d'optimiser encore ce code? (hormis les options à la compilation)
Merci.

[doguette]

Bonjour,
Je ne sais pas si ce te fera vraiment gagner du temps de calcul, mais tu peux au moins t'épargner une boucle:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
  y(n)=0.0d0
  do i = n - 1, 1, - 1
     y(i) = sum(a(istart(i):iend(i))*x(istart(i):iend(i))
  end do

[LB_99]

Merci mais le problème est que les indices du tableau x sont stockés dans le tableau ja, ce qui rend la somme impossible à priori car le code suivant n'est pas correct :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
  y(n)=0.0d0
  do i = n - 1, 1, - 1
     y(i) = sum(a(istart(i):iend(i))*x(ja(istart(i):iend(i)))
  end do

[bobbyboy]

Bonjour,
de ce que je vois, les calculs des y(i) sont tous découplés (ils ne dépendent pas les uns des autres.
Donc pourquoi fais-tu une boucle inverse ? En suivant l'ordre naturel de stockage, tu dois pouvoir gagner un peu, comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
y(n)=0.0d0
  do i = 1, n-1
     r = 0.0d0
     do j = istart(i), iend(i)
        r = r + a(j)*x(ja(j))
     end do
     y(i) = r
  end do

EDIT :

Par contre tu peux passer par un tableau tampon pour pouvoir utiliser sum()
qui est assez avantageux. En gros tu perd un peux de temps à remplir le tampon (c'est simplement une copie des x qui vont jouer dans la somme) et tu gagnes à utiliser sum() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
y(n)=0.0d0
  do i = 1, n-1
 
     ! remplissage du tampon
     do j = istart(i), iend(i)
         x_tmp(j) = x(ja(j))
     enddo
 
     y(i) = sum(  a(istart(i):iend(i)) * x_tmp(istart(i):iend(i))  )
 
  end do

Bon je ne suis pas completement certain des indices, mais c'est l'idée. Faut tester pour voir si ca gagne vraiment du temps de calcul.

[Sylvain Bergeron]

En continuant l'idée de bobbyboy :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
! remplissage du tampon
do j = minvalue(istart), maxvalue(iend)
    x_tmp(j) = x(ja(j))*a(j)
enddo
 
y(n)=0.0d0
do i = 1, n-1
    y(i) = sum(x_tmp(istart(i):iend(i)))
enddo

Cette version devrait être plus rapide si les sections couvertes par istart et iend représentent une grande portion de la plage totale.

[Sylvain Bergeron]

Autre possibilité (à raffiner) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
! remplissage du tampon
x_tmp(0) = 0.0
do j = 1, maxvalue(iend)
    x_tmp(j) = x(ja(j))*a(j) + x_tmp(j-1)
enddo
 
y(n)=0.0d0
do i = 1, n-1
    y(i) = x_tmp(iend(i)) - x_tmp(istart(i))
enddo

Cette piste est cependant sujette à des risques de perte de précision.