Optimisation d'un code simple.

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:

---

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.

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:

---

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

---

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:

---

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

---

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:

---

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:

---

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.

En continuant l'idée de bobbyboy :

Code:

---

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.

Autre possibilité (à raffiner) :

Code:

---

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.

Merci à tous pour vos réponses.

Je vais faire les tests et je vous tiens au courant.