Remplacement ld d'or - une expérience?

Question

Quelqu'un at-il essayé d'utiliser gold au lieu de ld?

promesses

gold href="http://www.airs.com/blog/archives/38" rel="noreferrer"> être beaucoup plus rapide que ld, il peut aider à accélérer essai cycles pour les grandes applications C ++, mais il peut être utilisé comme solution de remplacement pour ld?

Peut gcc / g++ directement appel gold.

Y a-t-il des bugs ou des problèmes des savoir?

Bien que gold fait partie des binutils GNU depuis un certain temps, je l'ai trouvé presque pas « success stories » ou même « Howtos » dans le Web.

( Mise à jour: Ajout de liens vers l'or et entrée de blog expliquant qu'il )

Answer 1

À l'heure actuelle, il compile des projets sur Ubuntu plus gros 10.04. Ici, vous pouvez installer et intégrer facilement avec le paquet binutils-gold (si vous supprimez ce paquet, vous obtenez votre ancien ld). Gcc utilisera automatiquement l'or alors.

Quelques expériences:

• l'or ne recherche pas dans /usr/local/lib
• l'or ne suppose pas libs comme pthread ou rt, a dû les ajouter à la main
• il est plus rapide et nécessite moins de mémoire (le plus tard est importante sur le grand C ++ projets avec beaucoup d'élan, etc.)

Qu'est-ce qui ne fonctionne pas: Il ne peut pas compiler des choses du noyau et donc pas de modules du noyau. Ubuntu fait automatiquement via DKMS si elle met à jour des pilotes propriétaires comme fglrx. Cela échoue avec ld-gold (vous devez enlever l'or, DKMS Redémarrer, Réinstaller ld-gold.

Answer 2

Comme il m'a fallu un peu de temps pour savoir comment utiliser de manière sélective l'or (à savoir pas l'ensemble du système en utilisant un lien symbolique), je posterai la solution ici. Il est basé sur http://code.google.com/p/chromium/wiki/ LinuxFasterBuilds # Linking_using_gold .

1. Créez un répertoire où vous pouvez mettre un script de colle d'or. J'utilise ~/bin/gold/.

2. Mettez là et nommez le script de la colle suivante il ~/bin/gold/ld:

   #!/bin/bash
   gold "$@"
   

   De toute évidence, rendre exécutable, chmod a+x ~/bin/gold/ld.

3. Modifier vos appels à gcc à gcc -B$HOME/bin/gold qui fait regarder gcc dans le répertoire donné pour les programmes d'aide comme ld et utilise ainsi le script de la colle au lieu du ld système par défaut.

Answer 3

  

Peut or gcc / g ++ directement appel.

Juste pour compléter les réponses: il y a une option de gcc de -fuse-ld=gold (voir gcc doc ). Bien que, autant que je sache, il est possible de configurer gcc lors de la construction d'une manière que l'option n'aura aucun effet.

Answer 4

En tant que développeur Samba, je suis en utilisant l'éditeur de liens d'or presque exclusivement sur Ubuntu, Debian, Fedora et depuis plusieurs années. Mon évaluation:

• l'or est à plusieurs reprises (ressenti: 5-10 fois). Plus vite que l'éditeur de liens classique
• Dans un premier temps, il y avait quelques problèmes, mais ont disparu depuis à peu près Ubuntu 12.04.
• L'éditeur de liens d'or a même trouvé quelques problèmes de dépendance dans notre code, car il semble plus juste que celle classique par rapport à certains détails. Voir, par exemple ce Samba commettre.

Je n'ai pas utilisé de manière sélective l'or, mais ont été en utilisant si la distribution ou le mécanisme symlinks alternatives fournit.

Answer 5

Vous pourriez créer un lien ld à gold (dans un répertoire local si vous avez ld installé pour éviter d'écraser):

ln -s `which gold` ~/bin/ld

ou

ln -s `which gold` /usr/local/bin/ld

Answer 6

référence synthétique minimal

Résultat: l'or était d'environ 2x à 3x plus rapide pour toutes les valeurs que j'ai essayées

.

generate-objets

#!/usr/bin/env bash
set -eu

# CLI args.

# Each of those files contains n_ints_per_file ints.
n_int_file_is="${1:-10}"
n_ints_per_file="${2:-10}"

# Each function adds all ints from all files.
# This leads to n_int_file_is x n_ints_per_file x n_funcs relocations.
n_funcs="${3:-10}"

# Do a debug build, since it is for debug builds that link time matters the most,
# as the user will be recompiling often.
cflags='-ggdb3 -O0 -std=c99 -Wall -Wextra -pedantic'

# Cleanup previous generated files objects.
./clean

# Generate i_*.c, ints.h and int_sum.h
rm -f ints.h
echo 'return' > int_sum.h
int_file_i=0
while [ "$int_file_i" -lt "$n_int_file_is" ]; do
  int_i=0
  int_file="${int_file_i}.c"
  rm -f "$int_file"
  while [ "$int_i" -lt "$n_ints_per_file" ]; do
    echo "${int_file_i} ${int_i}"
    int_sym="i_${int_file_i}_${int_i}"
    echo "unsigned int ${int_sym} = ${int_file_i};" >> "$int_file"
    echo "extern unsigned int ${int_sym};" >> ints.h
    echo "${int_sym} +" >> int_sum.h
    int_i=$((int_i + 1))
  done
  int_file_i=$((int_file_i + 1))
done
echo '1;' >> int_sum.h

# Generate funcs.h and main.c.
rm -f funcs.h
cat <<EOF >main.c
#include "funcs.h"

int main(void) {
return
EOF
i=0
while [ "$i" -lt "$n_funcs" ]; do
  func_sym="f_${i}"
  echo "${func_sym}() +" >> main.c
  echo "int ${func_sym}(void);" >> funcs.h
  cat <<EOF >"${func_sym}.c"
#include "ints.h"

int ${func_sym}(void) {
#include "int_sum.h"
}
EOF
  i=$((i + 1))
done
cat <<EOF >>main.c
1;
}
EOF

# Generate *.o
ls | grep -E '\.c$' | parallel --halt now,fail=1 -t --will-cite "gcc $cflags -c -o '{.}.o' '{}'"

GitHub amont .

Étant donné une entrée de type:

./generate-objects [n_int_file_is [n_ints_per_file [n_funcs]]]

Cela génère une principale qui fait:

return f_0() + f_1() + ... + f_(n_funcs)()

où chaque fonction est définie dans un fichier séparé f_n.c, et ajoute des temps de n_int_file_is n_ints_per_file ints externat:

int f_0() { return i_0_0 + i_0_1 + ... + i_(n_int_file_is)_(n_ints_per_file); }

Cela conduit à:

n_int_file_is x n_ints_per_file x n_funcs

déménagement sur le lien.

Je comparais:

gcc -ggdb3 -O0 -std=c99 -Wall -Wextra -pedantic               -o main *.o
gcc -ggdb3 -O0 -std=c99 -Wall -Wextra -pedantic -fuse-ld=gold -o main *.o

pour différents triplets d'entrée, ce qui a donné:

10000 10 10
nogold: wall=3.70s user=2.93s system=0.75s max_mem=556356kB
gold:   wall=1.43s user=1.15s system=0.28s max_mem=703060kB

1000 100 10
nogold: wall=1.23s user=1.07s system=0.16s max_mem=188152kB
gold:   wall=0.60s user=0.52s system=0.07s max_mem=279108kB

100 1000 10
nogold: wall=0.96s user=0.87s system=0.08s max_mem=149636kB
gold:   wall=0.53s user=0.47s system=0.05s max_mem=231596kB

10000 10 100
nogold: wall=11.63s user=10.31s system=1.25s max_mem=1411264kB
gold:   wall=6.31s user=5.77s system=0.53s max_mem=2146992kB

1000 100 100
nogold: wall=7.19s user=6.56s system=0.60s max_mem=1058432kB
gold:   wall=4.15s user=3.81s system=0.34s max_mem=1697796kB

100 1000 100
nogold: wall=6.15s user=5.58s system=0.57s max_mem=1031372kB
gold:   wall=4.06s user=3.76s system=0.29s max_mem=1652548kB

Quelques limites que j'ai essayé d'atténuer:

• à 100k fichiers C, les deux méthodes se mallocs échoué à l'occasion
• GCC ne peut pas compiler une fonction avec des additions 1M

Testé sur Ubuntu 18.10, GCC 8.2.0, Lenovo ThinkPad portable P51, Intel Core CPU i7-7820HQ (4 cœurs / 8 fils), 2x Samsung M471A2K43BB1-CRC RAM (2x 16GiB), Samsung MZVLB512HAJQ-000L7 SSD (3000 MB / s).

J'ai aussi observé un 2x dans la version de débogage de gem5: https: // gem5.googlesource.com/public/gem5/+/fafe4e80b76e93e3d0d05797904c19928587f5b5

Answer 7

Certains projets semblent être incompatibles avec l'or, en raison de quelques différences incompatibles entre ld et de l'or. Exemple: OpenFOAM, voir http://www.openfoam.org/mantisbt/view. php? id = 685 .

Answer 8

DragonFlyBSD commuté à l'or comme éditeur de liens par défaut. Il semble donc être prêt pour une variété d'outils.
Plus de détails: http://phoronix.com/scan.php?page=news_item&px=DragonFlyBSD -Gold-Linker