Sustitución de LD con oro - ninguna experiencia?

StackOverflow https://stackoverflow.com/questions/3476093

Pregunta

¿Alguien ha intentado utilizar gold en lugar de ld?

gold href="http://www.airs.com/blog/archives/38" rel="noreferrer"> promesas a ser mucho más rápido que ld, por lo que puede ayudar a acelerar la prueba ciclos para grandes aplicaciones C ++, pero puede ser utilizado como gota en el reemplazo para ld?

Puede gcc / g++ gold directamente llamada.?

¿Hay errores o problemas saber?

A pesar de gold es parte de las binutils de GNU desde hace tiempo, he encontrado casi nada de "historias de éxito" o incluso "Cómos" en la web.

( Actualización: enlaces a oro y entrada de blog que explican agregó )

¿Fue útil?

Solución

En estos momentos se está recopilando los proyectos más grandes en Ubuntu 10.04. Aquí se puede instalar e integrar fácilmente con el paquete binutils-gold (si se quita ese paquete, se obtiene su edad ld). Gcc utilizará automáticamente el oro a continuación.

Algunas experiencias:

  • oro no buscar en /usr/local/lib
  • oro no asume libs como pthread o RT, tuvo que añadir a mano
  • es más rápido y requiere menos memoria (este último es importante en grandes proyectos de C ++ con una gran cantidad de impulso etc.)

Lo que no funciona: no puede compilar material del núcleo y por lo tanto no hay módulos del núcleo. Ubuntu hace automáticamente a través de DKMS si actualiza los controladores propietarios como fglrx. Esta falla con ld-gold (usted tiene que quitar el oro, DKMS reinicio, ld-gold reinstalación.

Otros consejos

Como me tomó un poco de tiempo para encontrar la manera de utilizar selectivamente el oro (es decir, no en todo el sistema mediante un enlace simbólico), voy a publicar la solución aquí. Se basa en http://code.google.com/p/chromium/wiki/ LinuxFasterBuilds # Linking_using_gold .

  1. Crear un directorio donde se puede poner un guión pegamento oro. Estoy usando ~/bin/gold/.

  2. Ponga el siguiente script pegamento allí y el nombre que ~/bin/gold/ld: 

    #!/bin/bash
gold "$@"

    Obviamente, hacen que sea ejecutable, chmod a+x ~/bin/gold/ld.

  3. Cambiar sus llamadas a gcc a gcc -B$HOME/bin/gold que hace mirada gcc en el directorio dado a los programas de ayuda como ld y por lo tanto utiliza la secuencia de comandos de cola en lugar de la ld sistema por defecto.

  

Puede gcc / g ++ directamente el oro llamada.?

Sólo para complementar las respuestas: no hay opción -fuse-ld=gold de un gcc (ver gcc doc ). Sin embargo, que yo sepa, es posible configurar gcc durante la construcción de un modo que la opción no tendrá ningún efecto.

Como desarrollador de Samba, he estado usando el engarce de oro casi exclusivamente en Ubuntu, Debian, Fedora y desde hace varios años. Mi valoración:

  • es oro muchas veces (sentido: 5-10 veces). Más rápido que el enlazador clásica
  • Inicialmente, había unos cuantos problemas, pero el haber ido más o menos desde Ubuntu 12.04.
  • El engarce de oro incluso encontró algunos problemas de dependencia en nuestro código, ya que parece ser más acertada que la clásica con respecto a algunos detalles. Véase, por ejemplo este Samba cometer .

I no han utilizado oro selectivamente, pero han estado usando enlaces simbólicos o el mecanismo alternativas si la distribución proporciona.

Se podría vincular a ld gold (en un directorio local binaria si ha instalado ld para evitar sobrescribir): 

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

o 

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

Minimal referencia sintética

Resultado: el oro estaba a punto de 2x 3 veces más rápido para todos los valores que he probado

.

Generar-objetos 

#!/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 aguas arriba .

Dada una entrada de tipo: 

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

Esto genera una principal que tiene: 

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

donde cada función se define en un archivo separado f_n.c, y añade veces n_int_file_is n_ints_per_file enteros extern: 

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

Esto conduce a: 

n_int_file_is x n_ints_per_file x n_funcs

reubicaciones en el enlace.

A continuación, comparé: 

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

para diversos tripletes de entrada, lo que dio: 

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

Algunos de los límites que he estado tratando de mitigar:

  • mallocs en 100k archivos de C, ambos métodos consiguen ocasionalmente no
  • GCC no puede compilar una función con adiciones 1m

Probado en Ubuntu 18.10, GCC 8.2.0, Lenovo ThinkPad portátil P51, Intel Core i7-7820HQ CPU (4 núcleos / 8 hilos), 2x Samsung M471A2K43BB1-CRC RAM (2x 16GiB), Samsung MZVLB512HAJQ-000L7 SSD (3000 MB / s).

También he observado un 2x en la versión de depuración de gem5: https: // gem5.googlesource.com/public/gem5/+/fafe4e80b76e93e3d0d05797904c19928587f5b5

Algunos proyectos parecen ser incompatibles con el oro, debido a algunas diferencias incompatibles entre LD y oro. Ejemplo: OpenFOAM, ver http://www.openfoam.org/mantisbt/view. php? id = 685 .

DragonFlyBSD conmuta al oro como su enlazador predeterminado. Por lo tanto, parece estar listo para una variedad de herramientas.
Más detalles: http://phoronix.com/scan.php?page=news_item&px=DragonFlyBSD -Gold-Enlazador

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top