Re: Une table

J'aime bien le inline avec le contrôle de type par le compilo & Co - je trouve ça plus propre que la définition de macros. Je me suis demandé quel coût avait le inline vs la définition de macro.

Testé avec le source suivant (sous Linux 64 bits, gcc 4.6.3).

// Fichier testinlinec.c
#include <stdio.h>
#include <stdint.h>
#include <time.h>
#include <limits.h>
#define TESTSCOUNT 10000000
static uint8_t mapping[256];
// Définition avec du inline.
static inline uint8_t mafonction1(uint8_t v)
{ return v>UCHAR_MAX? 0 : mapping[v]; }
// Définition en macro.
#define mafonction2(X) (X > UCHAR_MAX ? 0 : mapping[X])
inline uint64_t rdtsc()
{
 uint32_t lo, hi;
 __asm__ __volatile__ (
 "xorl %%eax, %%eax\n"
 "cpuid\n"
 "rdtsc\n"
 : "=a" (lo), "=d" (hi)
 :
 : "%ebx", "%ecx" );
 return (uint64_t)hi << 32 | lo;
}
void main(void)
{
 int i;
 int x;
 uint64_t start, end;
 uint64_t tinline, tmacro;
 // Initialisation du mapping avec des valeurs décalées.
 for (i=0 ; i<256 ; i++)
 mapping[i] = (i+8)%UCHAR_MAX;
 // Test avec le inline.
 start = rdtsc();
 for (i=0 ; i<TESTSCOUNT ; i++)
 x = mafonction1(i % UCHAR_MAX)*2;
 end = rdtsc;
 tinline = end - start;
 printf("Inline: %lu\n", tinline);
 // Test avec la macro.
 start = rdtsc();
 for (i=0 ; i<TESTSCOUNT ; i++)
 x = mafonction2(i % UCHAR_MAX)*2;
 end = rdtsc;
 tmacro = end - start;
 printf("Macro: %lu\n", tmacro);
 printf("Inline-Macro: %lu\n", tinline - tmacro);
}

Le résultat dépend fortement de l'option de compilation choisie (je suppute que dans certains cas il n'inline pas). Sur ma machine (note: le temps est en nano-secondes):

-O0 Inline-Macro: 227906089 nsec
-01 Inline-Macro: 14369156 nsec
-02 Inline-Macro: 94070 nsec
-O3 Inline-Macro: 89284 nsec

(note: avec des variations d'une exécution sur l'autre… vu la résolution c'est normal, les -O2 et -O3 sont quasi équivalent pour ce test)

Note: code pour le timing issu de stackoverflow.

Votez les 30 juin et 7 juillet, en connaissance de cause. http://www.pointal.net/VotesDeputesRN