Discussion :

[orand]

Salut,

Je suis a la recherche de la méthode la plus efficace particulièrement en terme de portabilité.
Je m'intéresse au sorties asm mais j'ai remarqué que selon les plateformes visés je n'obtiens pas du tout le même code.
Comment puis-je définir la meilleure selon le nombre d'arguments et aussi selon les cas ou les données se trouvent sur la pile ou en ram ?

Code :

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

1
2
3
4
5
#pragma pack(push,4)
typedef struct{
long a,b,c,d,e,f,g ;
}sFOO ;
#pragma pop(pop)

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
void foo1(sFOO *pfoo){
long a,b,c,d,e,f,g ;
a = pfoo->a ;
b = pfoo->b ;
c = pfoo->c ;
d = pfoo->d ;
e = pfoo->e ;
f = pfoo->f ;
g = pfoo->g ;
 
// stuff...
a++ ;
b += c ;
//...
}

Code :

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

1
2
3
4
5
6
7
8
9
void foo2(sFOO *pfoo){
 
// stuff...
pfoo->a++ ;
pfoo->b += pfoo->c ;
//...
 
// retour
}

Code :

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

1
2
3
4
5
6
7
8
void foo3(sFOO *pfoo){
sFOO foo = *pfoo ;
 
// stuff...
foo.a++ ;
foo.b += foo.c ;
//...
}

Code :

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

1
2
3
4
5
6
7
8
9
void foo4(sFOO *pfoo){
sFOO foo ;
memcpy(&foo,pfoo,sizeof(sFOO)) ;
 
// stuff...
foo.a++ ;
foo.b += foo.c ;
//...
}

Si les données sont en ram j'utilise plutôt la 1, la 2 si c'est sur la pile. La plus choquante pour moi est la 3. Déformation professionnelle...

mais ce qui me pose un dilemme c'est le cas ou il faut mettre à jours les données. Une fonction comme celle-ci est affreuse en terme de lecture mais en terme d'optimisation je ne sais pas, puis comment bien l'estimer selon le nombre d'éléments mis à jours:

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
void foo1(sFOO *pfoo){
long a,b,c,d,e,f,g ;
a = pfoo->a ;
b = pfoo->b ;
c = pfoo->c ;
d = pfoo->d ;
e = pfoo->e ;
f = pfoo->f ;
g = pfoo->g ;
 
// de 0 à 1024 itérations
while(a<e){
a++ ;
b += c ;
//...
}
 
// retour
pfoo->a = a ;
pfoo->b = b ;
pfoo->c = c ;
pfoo->d = d ;
pfoo->e = e ;
pfoo->f = f ;
pfoo->g = g ;
}

[Médinoc]

Euh... La pile est en RAM, non?

Ce genre de question n'est vraiment valable que si tu as un microcontrôleur avec la zone mémoire de la pile plus "près" du cœur que le reste de la RAM...

Parce que là, dans tous les cas tu lis toute la structure, donc sur un x86 la page entière sera chargée en RAM de toute façon, et la structure entière sera lue dans le cache de toute façon également.