performance : structure de tableaux ou tableau de structures
Salut,
Je crois que tout est dans le titre, je me demande si je dois, pour des raisons de performances (utilisation du cache), plutôt utiliser une structure contenant des tableaux, ou des tableaux de structures.
Déjà, est-ce qu'il y a des arguments généraux (indépendants du problème considéré) qui iraient vers l'une ou l'autre des deux solutions, et pourquoi ?
Mon problème consiste a calculer des formules mathématiques sur des fonctions à 2 dimensions, genre f(x,y), g(x,y), h(x,y). Par exemple f(x,y) = h(x,y)*g(x,y).
Est-il plus malin de faire :
Code:
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
|
struct ma_grille
{
double f;
double g;
double h;
};
int i, j, ij;
int nx, ny;
nx = 100;
ny = 100;
struct ma_grille *mg = malloc((nx+1)*(ny+1)*sizeof(*mg));
// initialisation de f, g et h
//...
//
// calcul
for (i=0; i < nx+1; i++)
{
ij = i + j*(nx+1);
mg[ij].f = mg[ij].g * mg[ij].h;
}
free(mg); |
ou bien :
Code:
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
|
struct ma_grille
{
double *f;
double *g;
double *h;
};
int i, j, ij;
int nx, ny;
nx = 100;
ny = 100;
struct ma_grille mg;
mg.f = malloc((nx+1)*(ny+1)*sizeof(*mg.f));
mg.g = malloc((nx+1)*(ny+1)*sizeof(*mg.g));
mg.h = malloc((nx+1)*(ny+1)*sizeof(*mg.h));
// initialisation de f, g et h
//...
//
// calcul
for (i=0; i < nx+1; i++)
{
ij = i + j*(nx+1);
mg.f[ij] = mg.g[ij] * mg.h[ij];
}
free(mg.f);
free(mg.g);
free(mg.h); |
