J’avais un problème de benchmarks. Je voulais benchmarker un truc dans ce goût là :

for(j = 0; j<16; j++)   {     c[j] = a[j] + b[j];   }

et son équivalent,

*(__m128i *) d = _mm_add_epi8( *(__m128i *) a,*(__m128i *) b);

C’est évidemment non trivial parce qu’on est très largement au-dessous de la granularité mesurable. Bourrinons donc un coup, on colle une grosse boucle autour et on mesure 30 millions d’exécutions de ce truc.

Tout se passe bien avec GCC, on a les mesures avec des gettimeofday() placés aux endroits stratégiques, roulez jeunesse. Enfin, tout se passe bien… je tombe quand même là-dessus : http://gcc.gnu.org/bugzilla/show_bug.cgi?id=26128 mais bon, c’est presque la routine.

Ça se corse avec ICC. Là, ya pas à dire, le compilo, il est pas assez con. Il voit ma boucle, il se dit « mais mais mais… ça sert à rien ce truc ! » (il a raison, hein, intrinsèquement) et donc il la vire sans autre forme de procès. Les temps d’exécution à 0.000000, c’est encourageant, mais ça fai t pas avancer la recherche.

Donc je cherche, je trifouille, je torture les options du compilo pour qu’il me sorte ma boucle, rien n’y fait. Je tente un appel de fonction, ça fout un overhead monstrueux. Je bricole ma boucle pour utiliser la variable d’induction dedans, idem, overhead monstrueux.

C’est Seb (qu’il en soit loué) qui m’a donné la solution : un petit volatile (d’où le titre du billet, pour ceux qui suivent) devant la déclaration de mon compteur est clairement une solution qui n’est pas forcément très élégante mais qui a l’avantage de faire ce que je veux avec un overhead assez réduit. Youpi 🙂