Je continue de tester mon petit moteur de collisions en ciblant certaines fonctions très sollicitées.

J'ai essayé de changer de compilateur pour voir.

D'habitude j'utilise Clang sous mac OS Catalina. Là j'ai décidé d'installé gcc (version 11) avec homebrew.

Résultat pour cette petite fonction, exécutée sur une centaine de millions de valeurs :

inline std::uint8_t node_depth(std::uint8_t const tree_depth, std::uint32_t node)
{
    for (std::uint32_t i = 0; i < tree_depth-1; ++i)
    {
        std::uint32_t a = (1u << (tree_depth - i -1))-1;
        if(node>a+i)
            node-=a;
    }
    return node;
}

L'exécutable de GCC est 8 fois plus lent que celui Clang. (code compilé en -O3 dans les deux cas)

Un tel écart est-il normal ? J'ai certainement fait une bêtise quelque part...

-
Edité par Umbre37 30 avril 2022 à 14:20:59

Il faudrait comparer l'asm généré, mais cela peut venir d’instructions vectorisées utilisés par défaut sur clang, mais pas sur gcc. Pour un test rapide, il me semble que -march=native -mtune=native active tout, mais le binaire est moins portable.

Merci de ta réponse, hélas je suis incapable de lire l'assembleur, c'est du chinois pour moi.

-march=native -mtune=native

ce sont des options de compilation à tester sur GCC ?

EDIT :

J'ai essayé ces options sur les deux compilos. Rien ne change chez GCC mais ça améliore encore les perfs pour Clang ! (pas de beaucoup, 20 % peut-être)

Je pensais qu'en -O3 toutes les optimisations étaient déjà activées...

EDIT2 :

Je n'arrive pas à générer l'assembleur.

J'ai essayé avec -S, -save-temps, en enlevant ou en laissant les autres options, rien n'y fait. Il me sort toujours des fichiers .s presque vides :

	.text
	.ident	"GCC: (Homebrew GCC 11.3.0) 11.3.0"
	.subsections_via_symbols

 et c'est tout.

-
Edité par Umbre37 30 avril 2022 à 15:26:06

Je me demande si l'utilisation de sous-traction sur des unsigned ne viendrai pas mettre la pagaille -- Car on a la garantie de cycler.

@lgmhs

Je ne sais pas si j'ai bien compris. Tu veux dire si jamais il arrivait  a - b avec b>a ?

Les données entrées sont telles que cela n'arrive jamais.

Les données le garantissent, mais le compilo ne le sait pas forcément. Je ne sais pas si cela peut avoir un impact.

Après, je trouve la modélisation étrange car on ne teste et supprime pas un bit mais 2^n-1+i

Je ne sais pas non plus si le compilo arrive à voir que les valeurs successives de a peuvent s'obtenir en retirant un 2^k à chaque fois

EDIT: Pour voir les assembleurs: https://godbolt.org/z/97xP9eeoz et enlève "inline"

En ligne tu peux jouer avec quick-bench, mais je préfère nanobench (à faire tourner sur notre machine du coup)

-
Edité par lmghs 30 avril 2022 à 15:50:26

@pour la modélisation, c'est parce que l'arbre est comme ça.

       0
   1         8
 2   5    9     12
3 4 6 7 10 11 13  14

Merci pour le inline et pour le lien, très puissant cet outil.

-
Edité par Umbre37 30 avril 2022 à 16:24:17