Discussion :

[louyxv]

Bonjour,
Je sollicite votre aide, je suis debutant et je voudrais savoir comment on peut optimiser ce bout de code

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
 
for (k = 0; k < 20; k++)
    {
    for (i = 1; i <= size; i++)
      {
      for (j = 1; j <= size; j++)
        {
        x[fonction(i, j, size)] = 
        (a * ( x[fonction(i-1, j, size)] + x[fonction(i+1, j, size)]
         +
         x[fonction(i, j-1, size)] + x[fonction(i, j+1, size)])
         +  
         x0[fonction(i, j, size)]) / c;
        }
      }
    fonction(b, x, size);
    }

[foetus]

• Supprimer ta première boucle parce que k n'intervient pas dans les calculs (tu fais k fois la même chose )
• Tu sors tes cours de mathématiques pour simplifier ton addition pondérée des proches en croix (... je pense à des sommes partielles)

[louyxv]

Justement a chaque tour de la boucle K j'execute une instruction, sinon je n'ai pas comrpis ce que vous vouliez dire pour le second point.

[BufferBob]

salut,

les maths c'est pas mon fort par contre je me dis que les appels de fonction() doivent couter cher, alors que quand on a fonction(i+1, j+1), au tour de boucle j suivant on relance le même calcul avec fonction(i+1, j), et idem pour i
du coup avoir un tableau temp[i*j] permettrait d'effectuer des accès mémoire au lieu de calculs potentiellement lourds, ça vaut peut-être la peine de creuser...

[louyxv]

Voila donc j'ai reussi a virer les appels de fonctions et la boucle k, y a t-il un moyen d'optimiser encore plus?

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
 
for (i = 1; i <= grid_size*20 ; i++)
      {
      for (j = 1; j <= grid_size; j++)
        {
        x[ i % grid_size + 1 + (grid_size + 2) * j] 
        = 
        (a * ( x[ i % grid_size + (grid_size + 2) * j] + x[ i%grid_size + 2 + (grid_size + 2) * j]
         +
         x[ i % grid_size + 1  + (grid_size + 2) * (j-1)] + x[ i % grid_size + 1 + (grid_size + 2) * (j+1)])
         +  
         x0[ i % grid_size + 1 + (grid_size + 2) * j]) / c;
        }
		if( (i % 20 == 0))
		function(b, x, grid_size);
    }

[droggo]

Bonjour,

Tu calcules souvent i % grid_size et grid_size + 2.

[BufferBob]

Voila donc j'ai reussi a virer les appels de fonctions et la boucle k, y a t-il un moyen d'optimiser encore plus?

difficile à dire, ça parait évident pour toi qui connais le code, mais vu d'ici je comprends pas un brin ce qu'est censé faire ce bout de code incomplet et qui pourrait bien être faux qui plus est (devrait pas y avoir un tableau glissant quelque part ?), tu dis que tu fais sauter la boucle k avec un modulo, pourquoi pas...

et avant de vouloir optimiser plus, est-ce que tu as testé ? quel est le gain concrètement ?