Structure en variable globale : question de performance
Bonsoir,
Je viens de faire plusieurs tests sur mon algorithme récursif qui liste des clés de registre.
J'ai constaté les choses suivantes :
- Plus on passe d'arguments à une fonction, plus la vitesse d'exécution du programme augmente ( si je ne me trompe pas, dans le cas d'une fonction récursive, c'est la pile d'appel qui est très sollicitée ). Du coup, je mets mes éléments constants dans une structure, et je passe uniquement le pointeur à ma fonction récursive + les arguments qui changent à chaque appel. Seuls les arguments dont la valeur ne change pas à chaque appel sont stockés dans la structure ).
- En utilisant une structure en tant que variable globale et en passant un pointeur vers cette structure à toutes les fonctions qui ont besoin d'initialiser ou de modifier une entrée de la structure, le temps d'exécution semble plus court. Cela paraît logique, puisqu'on "économise" des variables et on ne renvoie rien, puisqu'on peut écrire directement dans la structure.
Je sais que le gros problème dans cette façon de coder, c'est la réutilisation possible des fonctions :
Par exemple, j'ai la fonction suivante :
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
| char *GetHandleAndPathOfTheKey(struct s_registre *ptr_registre, char path[])
{
size_t len1;
size_t len2;
char *pos = NULL;
pos = strchr(path, '\\');
if (pos != NULL)
{
len1 = pos-path;
pos++;
len2 = strlen(pos);
if ( (ptr_registre->handle = malloc(len1+1)) != NULL
&& (ptr_registre->path = malloc(len2+1)) != NULL)
{
strncpy(ptr_registre->handle, path, len1);
ptr_registre->handle[len1] = '\0';
strcpy(ptr_registre->path, pos);
}
}
else
{
len1 = strlen(path)+1;
if ((ptr_registre->handle = malloc(len1)) != NULL)
{
strncpy(ptr_registre->handle, path, len1);
ptr_registre->handle[len1] = '\0';
ptr_registre->path = NULL;
}
}
return (pos);
} |
Cette fonction est difficilement réutilisable sans grosse modification, puisqu'elle ne peut marcher qu'avec la structure adéquate. En revanche, je peux ainsi modifier plus d'une valeur avec un appel de fonction.
J'espère n'avoir pas été trop brouillon dans mes propos.
J'aimerais avoir vos avis sur les points que j'ai évoqués car je cherche à optimiser mon code en terme de temps d'exécution, et j'essaye différentes façons. Or pour le moment, la structure comme variable globale, avec des fonctions qui lisent/écrivent directement dedans est ce que j'ai trouvé de plus rapide. Et pourtant, j'ai cru comprendre que cette façon de coder n'était pas très "appréciée", que ce n'était pas très propre...
Merci de vos lumières :ccool:
