Une nouvelle méthode d´optimisation des boucles nommée " D-Loop" vient d´apparaitre :

http://www.onversity.com/cgi-bin/progarti/art_aff.cgi?Eudo=bgteob&M=informat&O=touslesmots&P=a0404

Article très intéressant pour tous ceux qui se sentent concernés par ces techniques.

Et bien... Ca a l´air sacrément intéressant ( d´après le texte français, je vais commencer l´article proprement dit).

Merci pour l´article.

J´ai pas encore tout compris mais faut des boucles trés lourdes pour que ce soit rentable car l´ecriture est sacrement alourdie avec cette optim ( du peu que j´en ai vu).

Un bonne optim, c´est de deja utiliser des variable locales au sein de la boucle ( au lieu d´acceder a des membre de classes par exemple), c´est beaucoup plus " cache friendly".

Bin oui et non même si ca alourdit l´écriture de la boucle ca diminue grandement la complexité. Et les gains ont l´air quand même intéressant ( cf l´optim de la fonction strstr de la lib standard). Bon ensuite faut arriver à l´appliquer à ses propres boucles mais l´idée est plutôt pas mal je trouve.

J´ai trouvé un moyen de ne faire qu´un test ( et donc qu´un seul branchement ) :

int compte( const char* val, char ch )
{
static char ancien;
static char table[256];
table[ancien] = 0;
table[ch]= 1;
ancien = ch;

static int boucle;
int nb = 0;

for( boucle = 0 ; val[boucle]!=´\0´; boucle++, nb+=table[val[boucle]] ) ;

return nb;
}

Est ce mieux ?

oula ; )
tu as une raison particulière à utiliser des statiques ? ?? c´est rès dangereux tu sais

et les remises à zéro de tes variables ? ? le compilo le fera pas tout seul . ..

est ce que c´est mieux je sais pas faut la profiler pour voir

J´ai pondu ca vite fait pour voir.
Ca fonctionne, j´ai testé.
Les statiques c´est pour la préservation de mémoire.

table[ancien] = 0;
table[ch]= 1;
ancien = ch;

Se charge de remettre à zero.

Sinon je ne connaissait pas le danger des statiques et je ne sais pas comment la profiler...
Et l´usage du tableau évite un branchement conditionnel.
C´est pas beau, mais bon ca marche

et puis c´est pas des char mais unsigned char qu´il faut . ..

imagine ca :

compte("Création de jeux",´é´);

le ´é´ est > au caractère 127 . .. tu sors du tableau avec du char ( table[´é´]) c´est du signé...

non je parle de la PREMIERE raz . ..

ton tableau n´est pas forcément rempli de 0 au démarrage du programme

Oui ce détail existe, mais on peut y remédier avec des unsigned.
L´important ici est l´algorithme, qui fait moins usage de boucles que l´exemple.
Mais j´aimerais savoir ce que ca vaut...

" ton tableau n´est pas forcément rempli de 0 au démarrage du programme"

Ah bon ? Je croyais que toute variable statique était initialisée à zéro ?

arf oui exact

Comment faire pour déterminer son temps d´exécution ?

bin ya des outils pour ca, ya même un profileur intégré dans visual c++ ( ca vaut ce que ca vaut . .. il est pas extra mais ca dépanne toujours)

Par contre pour le danger des statiques je voulais parler du multi-thread. Là t´y coupes pas ca va faire mal

Boin dans ce cas autant utilisé de l´automatique avec un memset pour le tableau, ce seras un minimum moins rapide mais plus sécurisé

int compte( const char* val, char ch )
{
char table[256];
memset(table,0,sizeof(char)*256);
table[ch]= 1;

int boucle, nb = 0;

for( boucle = 0 ; val[boucle]!=´\0´; boucle++, nb+=table[val[boucle]] ) ;

return nb;
}

Nouvelle version
J´ai laissé les signed char, car c´est tiré de leur exemple...

hmm quel exemple ? je vois que des unsigned char dans l´article PDF

count/new_count : si le tableau de la version optimisée est bel et bien un unsigned char, les paramètres de la fonction sont eux des char, mais ceci dit il les castent : ( unsigned char).
Mais bon il suffit de le modifier...

Alors ca vaut quoi ? Paske ca m´intéresse un peu quand même

j´ai utilisé VTune pour les tests :
( j´espère que ca va pas planter pour la mise en forme du texte . ...) :

int compte(char const *,char)
Clockticks Samples . ................ 375
Clockticks - Processor0 . ........... 312
Clockticks - Processor1 . ........... 63
Clockticks - Total events . ......... 975000000
Clockticks - Total % . .............. 10,36770805
Clockticks - Processor0 events . .... 811200000
Clockticks - Processor0 % . ......... 13,19238901
Clockticks - Processor1 events . .... 163800000
Clockticks - Processor1 % . ......... 5,031948882

int count_char(char *,char)
Clockticks Samples . ................ 256
Clockticks - Processor0 . ........... 172
Clockticks - Processor1 . ........... 84
Clockticks - Total events . ......... 665600000
Clockticks - Total % . .............. 7,077688692
Clockticks - Processor0 events . .... 447200000
Clockticks - Processor0 % . ......... 7,272727273
Clockticks - Processor1 events . .... 218400000
Clockticks - Processor1 % . ......... 6,709265176

int new_count_char(char *,char)
Clockticks Samples . ................ 250
Clockticks - Processor0 . ........... 220
Clockticks - Processor1 . ........... 30
Clockticks - Total events . ......... 650000000
Clockticks - Total % . .............. 6,911805364
Clockticks - Processor0 events . .... 572000000
Clockticks - Processor0 % . ......... 9,302325581
Clockticks - Processor1 events . .... 78000000
Clockticks - Processor1 % . ......... 2,396166134