Clang vs GCC - lequel produit des binaires plus rapides ?

Question

J'utilise actuellement GCC, mais j'ai découvert Clang récemment et j'envisage de le changer. Il y a cependant un facteur décisif : la qualité (vitesse, empreinte mémoire, fiabilité) des binaires produits. gcc -O3 peut produire un binaire qui s'exécute 1% plus vite, ou que les binaires Clang prennent plus de mémoire ou échouent simplement à cause de bogues du compilateur, c'est un cas de rupture.

Clang peut se vanter d'avoir une meilleure vitesse de compilation et une empreinte mémoire plus faible que GCC, mais je suis vraiment intéressé par les benchmarks/comparaisons des logiciels compilés qui en résultent. Pourriez-vous m'indiquer des ressources préexistantes ou vos propres benchmarks ?

Answer 1

Une différence particulière que j'ai constatée avec GCC 5.2.1 et Clang 3.6.2 est la suivante que si vous avez une boucle critique comme

for (;;) {
    if (!visited) {
        ....
    }
    node++;
    if (!*node)
        break;
}

Alors GCC, lorsqu'il compile avec -O3 o -O2 de manière spéculative dérouler la boucle huit fois. Clang ne la déroulera pas du tout. Grâce à essais et erreurs j'ai trouvé que dans mon cas spécifique avec les données de mon programme, le bon nombre de déroulements est de cinq, donc GCC a dépassé et Clang en dessous. Cependant, le dépassement était plus préjudiciable aux performances, donc GCC s'est bien moins bien comporté ici.

J'ai aucune idée si la différence de déroulement est une tendance générale ou juste quelque chose qui était spécifique à mon scénario.

Il y a quelque temps, j'ai écrit un quelques collecteurs de déchets pour en apprendre plus sur l'optimisation des performances en C. Et les résultats que j'ai obtenus sont à mon avis suffisants pour favoriser légèrement Clang. Surtout que garbage est surtout une question de chasse aux pointeurs et de copie de mémoire.

Les résultats sont les suivants (chiffres en secondes) :

+---------------------+-----+-----+
|Type                 |GCC  |Clang|
+---------------------+-----+-----+
|Copying GC           |22.46|22.55|
|Copying GC, optimized|22.01|20.22|
|Mark & Sweep         | 8.72| 8.38|
|Ref Counting/Cycles  |15.14|14.49|
|Ref Counting/Plain   | 9.94| 9.32|
+---------------------+-----+-----+

Il s'agit de code C pur, et je n'ai aucune prétention quant à l'efficacité de l'un ou l'autre des compilateurs. compilateur lorsqu'il compile du code C++.

Sur Ubuntu 15.10 (Wily Werewolf), x86.64, et une AMD Phenom II X6 1090T.

Answer 2

En gros, la réponse est : cela dépend. Il existe de nombreux benchmarks axés sur différents types d'applications.

Le benchmark de mon application est : GCC > ICC > Clang.

Les entrées/sorties sont rares, mais les opérations sur les flotteurs et les structures de données sont nombreuses.

Les drapeaux de compilation sont -Wall -g -DNDEBUG -O3 .

https://github.com/zhangyafeikimi/ml-pack/blob/master/gbdt/profile/benchmark