Pourquoi une version récursive d'une fonction serait plus rapide qu'un itératif en C?

J'ai compilé et exécuté votre code localement. Déplacer le printf code> à l'extérieur du bloc chronométré permet aux deux versions exécutées dans ~ 5ms à chaque fois.

Une erreur centrale dans votre timing est que vous mesurez la bête complexe de printf code > Et son runtime narfs le code que vous essayez de mesurer. p>

mon Main () code> -function ressemble maintenant à ceci: p>

int main() {
    struct timespec s1, e1, s2, e2;

    double d = 0.0;

    clock_gettime(CLOCK_MONOTONIC, &s1);
    d = descgraditer(100,99,0.01,0.00001);
    clock_gettime(CLOCK_MONOTONIC, &e1);
    printf("Minimum : %f\n", d);

    clock_gettime(CLOCK_MONOTONIC, &s2);
    d = descgrad(100,99,0.01,0.00001);
    clock_gettime(CLOCK_MONOTONIC, &e2);
    printf("Minimum : %f\n",d);

    uint64_t dif1 = timespecDiff(&e1,&s1) / 1000;
    uint64_t dif2 = timespecDiff(&e2,&s2) / 1000;

    printf("time_iter:%llu ms, time_rec:%llu ms, ratio (dif1/dif2) :%g\n", dif1,dif2, ((double) ((double)dif1/(double)dif2)));

    printf("End. \n");
}

Pour commencer, vous incluiez une Printf à l'époque que vous essayiez de mesurer. C'est toujours un non-nul géant, car il peut, et très probablement, suspendre votre processus en effectuant la sortie de la console. En fait, tout appel système peut complètement lancer des mesures de temps comme celles-ci.

Et deuxièmement, comme quelqu'un d'autre l'a mentionné, à ce court-circonscription, des interruptions de planificateur peuvent avoir un impact énorme.

Ceci est Pas parfait, mais essayez ceci pour votre principal et vous verrez qu'il y a vraiment très peu de différence. Lorsque vous augmentez le nombre de boucles, le rapport s'approche 1.0. xxx

}

EDIT: Après avoir examiné la sortie démontée en utilisant objdump -ds j'ai remarqué quelques choses:

Avec l'optimisation -O3, le code ci-dessus optimise complètement l'appel de la fonction. Cependant, il produit toujours du code pour les deux fonctions et n'est pas non plus récursif.

Deuxièmement, avec -O0, de telle sorte que le code résultant est réellement récursif, la version récursive est littéralement un billion de billion < / fort> fois plus lentement. Je suppose que la pile d'appel force les variables pour se retrouver dans la mémoire où la version itérative s'étend de registres et / ou de cache.