méthode la plus rapide pour traiter une structure se trouvant en ram/pile
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:
1
2
3
4
5
| #pragma pack(push,4)
typedef struct{
long a,b,c,d,e,f,g ;
}sFOO ;
#pragma pop(pop) |
Code:
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:
1
2
3
4
5
6
7
8
9
| void foo2(sFOO *pfoo){
// stuff...
pfoo->a++ ;
pfoo->b += pfoo->c ;
//...
// retour
} |
Code:
1
2
3
4
5
6
7
8
| void foo3(sFOO *pfoo){
sFOO foo = *pfoo ;
// stuff...
foo.a++ ;
foo.b += foo.c ;
//...
} |
Code:
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... :aie:
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:
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 ;
} |
