Discussion :

[Merillym]

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 :

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
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

[Pouet_forever]

Passer un pointeur sur cette structure est beaucoup mieux que de passer la structure elle-même. Si la structure est passé entièrement elle est copiée entièrement aussi ! Et donc ta pile va augmenter beaucoup plus vite que si tu passais un pointeur sur la structure en question.

Par rapport au temps d'exécution je ne vois aucun rapport entre la variable globale et le pointeur. Certes avec la variable globale tu économises quelques octets de piles mais est-ce vraiment nécessaire ? Tout ce que tu gagnes c'est la taille d'un pointeur * le nombre d'appels de ta fonction. Si tu fais, imaginons, 100 appels et que ton pointeur fait 4 octets tu auras ... 400 octets utilisés. Comme apparemment tu es sous Windows je suppose que 400 octets ne te feront pas défaut ...

Si tu passes plein d'arguments à ta fonction ce sera plus long, parce qu'il faut copier à chaque fois les variables à chaque appel de fonction, mais je pense que si tu n'utilises que des pointeurs et pas des variables elles-mêmes tu ne verras pas la différence. A moins que ce soit vraiment très précis et que tu veuilles calculer au ms, ce qui m'étonnerais

[Merillym]

Oui je ne suis pas au millième de seconde prêt, mais il ne faut pas que le programme mette plus de quelques secondes à s'exécuter, car on augmente les risques de "freeze".

Si tu fais, imaginons, 100 appels et que ton pointeur fait 4 octets tu auras ... 400 octets utilisés. Comme apparemment tu es sous Windows je suppose que 400 octets ne te feront pas défaut ...

En fait, si je souhaite lister une très grosse clé, je peux avoir jusqu'à... plusieurs centaines de milliers d'appels...

J'ai fait un test avec la clé HKLM\Software\Microsoft\Windows\CurrentVersion : sur mon pc elle contient 108000 clés, ce qui fait donc 108000 appels récursifs.

Et si je veux effectuer une recherche dans la base de registre avec mon programme, il faut parfois lister l'intégralité d'une ruche, pour n'afficher que les quelques clés qui correspondent à ce que l'on cherche. J'y arrive sur mon PC ( pentium D, 3GHZ ) en 18 secondes. C'est convenable, mais si je pouvais encore gagner quelques secondes, je serais satisfait.

D'où mes questions d'ordre plus général afin de mieux comprendre certains points de programmation.

Merci

[Pouet_forever]

108000 * 4 = 432 Ko
Tu n'atteinds même pas 1 Mo je pense que tu peux enlever ta variable globale

Après je ne peux pas t'aider sur ton code je ne connais pas bien Windows Mais tu peux sûrement simplifier en dé-récursifiant ta fonction

[Médinoc]

Mais tu peux sûrement simplifier en dé-récursifiant ta fonction

À ma connaissance, le parcours d'arborescences comme le système de fichier ou le Registre Windows sont plus simples en récursif (d'ailleurs, dans le second cas, je ne suis même pas sûr que ce soit possible en "itératif pur").