Comment puis-je tester les performances d'une fonction C?

Checkout HighRestimer pour une minuterie haute performance.

Vous trouverez probablement stocker le temps avant / après n'est pas assez précis et entraînera probablement 0 à moins que vous n'ayez une fonction de fonctionnement plus longue.

Vérifiez RDTSC mais il est préférable de le faire ci-dessous.

0 - Dormeur de sommeil ou de rendement du système d'appel de sorte que lorsqu'il retourne, vous avez une nouvelle ligne de TimesLice

1 - RDTSC

2 - Appelez votre fonction

3 - RDTSC

Si votre fonction est longue, vous devez utiliser une sorte d'outil de profilage comme GProf (il est très facile à utiliser) et l'application VTune d'Intel (que je n'ai pas utilisée depuis longtemps). Après avoir vu la réponse de l'art, j'ai changé d'avis de GProf en Callgrind. Je n'ai utilisé que l'outil Memcheck de Valgrind dans le passé et c'était un outil magnifique. Je n'ai pas utilisé Callgrind avant, mais je suis sûr qu'il est meilleur que GProf ...

la source ouverte Callgrind profileur (pour Linux) est un moyen vraiment génial de mesurer performance. Couplé avec KcachetRind, vous obtenez de très grandes visualisations de votre temps.

Callgrind fait partie de Valgrind.

• Art

Comme l'approche la plus simple et portable, vous pouvez utiliser le temps de fonction standard (), qui renvoie le nombre actuel de secondes depuis l'époque.

#include <time.h>

time_t starttime, endtime;

starttime = time(NULL);
for (i = 0; i < 1000000; i++)
{
    testfunc();
}
endtime = time(NULL);

printf("Time in seconds is %d\n", (int)(endtime-starttime));

Fred, je remarque que vous avez dit dans un commentaire que vous êtes sur OS X. Le meilleur moyen d'obtenir des horaires très précis des fonctions à petite échelle sur OS X est avec le mach_absoute_time () code> une fonction. Vous pouvez l'utiliser comme suit:

#include <mach/mach_time.h>
#include <sys/sysctl.h>
#include <stdint.h>

double ticksToNanoseconds(double ticks) {
    static double nanosecondsPerTick = 0.0;
    // The first time the function is called
    // ask the system how to convert mach
    // time units to nanoseconds
    if (0.0 == nanosecondsPerTick) {
        mach_timebase_info_data_t timebase;
        // to be completely pedantic, check the return code of this call:
        mach_timebase_info(&timebase);
        nanosecondsPerTick = (double)timebase.numer / timebase.denom;
    }
    return ticks * nanosecondsPerTick;
}

double nanosecondsToCycles(double nanoseconds) {
    static double cyclesPerNanosecond = 0.0;
    // The first time the function is called
    // ask the system what the CPU frequency is
    if (0.0 == cyclesPerNanosecond) {
        uint64_t freq;
        size_t freqSize = sizeof(freq);
        // Again, check the return code for correctness =)
        sysctlbyname("hw.cpufrequency", &freq, &freqSize, NULL, 0L );
        cyclesPerNanosecond = (double)freq * 1e-9;
    }
    return nanoseconds * cyclesPerNanosecond;
}

Toutes ces autres réponses utilisent une variante de GetTimeOdday () pour le timing. Ceci est assez brut puisque vous devez généralement exécuter le noyau plusieurs fois pour obtenir des résultats reproductibles. La mise dans une boucle serrée change l'état des deux caches de code et de données afin que ces résultats ne soient donc pas révélés de la performance réelle.

Une bien meilleure alternative consiste à utiliser le compteur de cycle de la CPU. Sur X86, vous pouvez le faire avec l'instruction rdtsc . Cela vient de x264 < / a>: xxx

Pour plus d'informations sur le profilage à l'aide de divers compteurs de matériel, voir Papi . Simulateurs (comme Callgrind et des profilers basés sur des interruptions ( oprofile ) sont utiles.