CUDA incompatible con mi versión gcc

Tengo problemas para compilar algunos de los ejemplos enviados con CUDA SDK. He instalado el controlador de desarrolladores (versión 270.41.19) y el kit de herramientas CUDA, luego finalmente el SDK (ambas versiones 4.0.17).

Inicialmente no se compiló en absoluto dando:

error -- unsupported GNU version! gcc 4.5 and up are not supported!

Encontré la línea responsable en 81: /usr/local/cuda/include/host_config.hy la cambié a:

//#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4)
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6)

a partir de ese momento obtuve solo algunos de los ejemplos para compilar, se detiene con:

In file included from /usr/include/c++/4.6/x86_64-linux-gnu/bits/gthr.h:162:0,
             from /usr/include/c++/4.6/ext/atomicity.h:34,
             from /usr/include/c++/4.6/bits/ios_base.h:41,
             from /usr/include/c++/4.6/ios:43,
             from /usr/include/c++/4.6/ostream:40,
             from /usr/include/c++/4.6/iterator:64,
             from /usr/local/cuda/include/thrust/iterator/iterator_categories.h:38,
             from /usr/local/cuda/include/thrust/device_ptr.h:26,
             from /usr/local/cuda/include/thrust/device_malloc_allocator.h:27,
             from /usr/local/cuda/include/thrust/device_vector.h:26,
             from lineOfSight.cu:37:
/usr/include/c++/4.6/x86_64-linux-gnu/bits/gthr-default.h:251:1: error: pasting         "__gthrw_" and "/* Android's C library does not provide pthread_cancel, check for
`pthread_create' instead.  */" does not give a valid preprocessing token
make[1]: *** [obj/x86_64/release/lineOfSight.cu.o] Error 1

A medida que se compilan algunos de los ejemplos, creo que esto no es un problema de controlador, sino que debe tener algo que ver con una versión de gcc no compatible. La degradación no es una opción ya que gcc4.6 tiene un sistema completo como dependencia en este momento ...

Como ya se señaló, nvcc depende de gcc 4.4. Es posible configurar nvcc para usar la versión correcta de gcc sin pasar ningún parámetro del compilador agregando enlaces de software al directorio bin creado con la instalación de nvcc.

El directorio binario de cuda predeterminado (el predeterminado de instalación) es / usr / local / cuda / bin, agregar un enlace suave a la versión correcta de gcc desde este directorio es suficiente:

sudo ln -s /usr/bin/gcc-4.4 /usr/local/cuda/bin/gcc

gcc 4.5 y 4.6 no son compatibles con CUDA: el código no se compilará y el resto de la cadena de herramientas, incluido cuda-gdb, no funcionará correctamente. No puede usarlos y la restricción no es negociable.

Su única solución es instalar una versión de gcc 4.4 como segundo compilador (la mayoría de las distribuciones lo permitirán). Existe una opción para nvcc --compiler-bindirque se puede usar para apuntar a un compilador alternativo. Cree un directorio local y luego haga enlaces simbólicos a los ejecutables de la versión gcc admitidos. Pase ese directorio local a nvcc a través de la --compiler-bindiropción, y debería poder compilar el código CUDA sin afectar al resto de su sistema.

EDITAR :

Tenga en cuenta que esta pregunta y respuesta pertenecen a CUDA 4.

Desde que se escribió, NVIDIA ha seguido ampliando el soporte para versiones posteriores de gcc en la versión más reciente de la cadena de herramientas CUDA.

• A partir de la versión CUDA 4.1, ahora se admite gcc 4.5. gcc 4.6 y 4.7 no son compatibles.
  
• A partir de la versión CUDA 5.0, gcc 4.6 ahora es compatible. gcc 4.7 no es compatible.
  
• A partir de la versión CUDA 6.0, gcc 4.7 ahora es compatible.
• A partir de la versión CUDA 7.0, gcc 4.8 es totalmente compatible, con soporte 4.9 en Ubuntu 14.04 y Fedora 21.
• A partir de la versión CUDA 7.5, gcc 4.8 es totalmente compatible, con 4.9 en Ubuntu 14.04 y Fedora 21.
• A partir de la versión CUDA 8, gcc 5.3 es totalmente compatible con Ubuntu 16.06 y Fedora 23.
• A partir de la versión CUDA 9, gcc 6 es totalmente compatible con Ubuntu 16.04, Ubuntu 17.04 y Fedora 25.
• La versión CUDA 9.2 agrega soporte para gcc 7
• La versión CUDA 10.1 agrega soporte para gcc 8

Actualmente (a partir de CUDA 10.1) no hay soporte para gcc 9 en CUDA.

Tenga en cuenta que NVIDIA ha agregado recientemente una tabla muy útil aquí que contiene el compilador compatible y la matriz del sistema operativo para la versión actual de CUDA.

1. Compruebe la versión máxima de GCC admitida para su versión de CUDA:

    | CUDA version | max supported GCC version |
    |--------------|---------------------------|
    |      11      |             9             |
    |  10.1, 10.2  |             8             |
    |   9.2, 10.0  |             7             |
    |   9.0, 9.1   |             6             |
    |       8      |            5.3            |
    |       7      |            4.9            |
    |    5.5, 6    |            4.8            |
    |    4.2, 5    |            4.6            |
    |      4.1     |            4.5            |
    |      4.0     |            4.4            |

2. Establezca una var env para esa versión de GCC. Por ejemplo, para CUDA 10.2:

    MAX_GCC_VERSION=8

3. Asegúrese de tener instalada esa versión:

    sudo apt install gcc-$MAX_GCC_VERSION g++-$MAX_GCC_VERSION

4. Agregue enlaces simbólicos dentro de las carpetas CUDA:

    sudo ln -s /usr/bin/gcc-$MAX_GCC_VERSION /usr/local/cuda/bin/gcc 
    sudo ln -s /usr/bin/g++-$MAX_GCC_VERSION /usr/local/cuda/bin/g++

   (o sustitúyalo /usr/local/cudapor la ruta de instalación de CUDA, si no está allí)

Consulte esta esencia de GitHub para obtener más información sobre la tabla de compatibilidad CUDA-GCC .

La solución de Gearoid Murphy funciona mejor para mí ya que en mi distribución (Ubuntu 11.10), gcc-4.4 y gcc-4.6 están en el mismo directorio, por lo que --compiler-bindir no es de ayuda. La única advertencia es que también tuve que instalar g ++ - 4.4 y vincularlo también:

sudo ln -s /usr/bin/gcc-4.4 /usr/local/cuda/bin/gcc
sudo ln -s /usr/bin/g++-4.4 /usr/local/cuda/bin/g++

Para CUDA7.5 estas líneas funcionan:

sudo ln -s /usr/bin/gcc-4.9 /usr/local/cuda/bin/gcc 
sudo ln -s /usr/bin/g++-4.9 /usr/local/cuda/bin/g++

Vea cómo utilizar "alternativas de actualización" para solucionar este problema:

... Si instala gcc 4.6, también puede usar el comando update-alternativas para permitir cambiar fácilmente entre versiones. Esto se puede configurar con:

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.6 60 --slave /usr/bin/g++ g++ /usr/bin/g++-4.6 
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.7 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.7 
sudo update-alternatives --config gcc

Si no usé cmakepara mí ninguno de los trucos para editar los archivos y vincular funcionó, entonces compilé usando las banderas que especifican la versión gcc / g ++.
cmake -DCMAKE_C_COMPILER=gcc-6 -DCMAKE_CXX_COMPILER=g++-6 ..

Funcionó a la perfección.

En la mayoría de las distribuciones, tiene la posibilidad de instalar otra versión de gcc y g ++ junto al compilador más reciente como gcc-4.7. Además, la mayoría de los sistemas de compilación son conscientes de las variables de entorno CCy CXX, que le permiten especificar otros compiladores de C y C ++ respectivamente. Entonces sugiero algo como:

CC=gcc-4.4 CXX=g++-4.4 cmake path/to/your/CMakeLists.txt

Para Makefiles debería haber una forma similar. No recomiendo establecer enlaces simbólicos personalizados dentro de / usr / local a menos que sepa lo que está haciendo.

Esto funciona para fedora 23. Los repositorios de compat gcc serán ligeramente diferentes según su versión de fedora.

Si instala los siguientes repositorios:

sudo yum install compat-gcc-34-c++-3.4.6-37.fc23.x86_64 compat-gcc-34-3.4.6-37.fc23.x86_64 

Ahora haga los enlaces suaves como se mencionó anteriormente, asumiendo que su carpeta cuda bin está en /usr/local/cuda/

sudo ln -s /usr/bin/gcc-34 /usr/local/cuda/bin/gcc
sudo ln -s /usr/bin/g++-34 /usr/local/cuda/bin/g++

Ahora debería poder compilar nvccsin el error de versión gcc.

La solución de Gearoid Murphy funciona de maravilla. Para mí tenía dos directorios para cuda -

/usr/local/cuda 
/usr/local/cuda-5.0

Los enlaces suaves tenían que agregarse solo al directorio mencionado a continuación:

/usr/local/cuda 

Además, se requerían enlaces blandos g ++ y gcc como lo menciona SchighSchagh.

Otra forma de configurar nvcc para usar una versión específica de gcc (gcc-4.4, por ejemplo) es editar nvcc.profile y alterar PATH para incluir la ruta al gcc que desea usar primero.

Por ejemplo (gcc-4.4.6 instalado en / opt):

PATH += /opt/gcc-4.4.6/lib/gcc/x86_64-unknown-linux-gnu/4.4.6:/opt/gcc-4.4.6/bin:$(TOP)/open64/bin:$(TOP)/share/cuda/nvvm:$(_HERE_):

La ubicación de nvcc.profile varía, pero debería estar en el mismo directorio que el propio ejecutable nvcc .

Esto es un truco, ya que nvcc.profile no está diseñado para la configuración del usuario según el manual de nvcc, pero fue la solución que mejor funcionó para mí.

CUDA es después de algunas modificaciones de encabezado compatible con gcc4.7 y tal vez una versión superior: https://www.udacity.com/wiki/cs344/troubleshoot_gcc47

Para las personas como yo que se confunden mientras usan cmake, el FindCUDA.cmakescript anula algunas de las cosas de nvcc.profile. Puede especificar el nvcccompilador de host configurando CUDA_HOST_COMPILERsegún http://public.kitware.com/Bug/view.php?id=13674 .

Tuve que instalar las versiones anteriores de gcc, g ++.

    sudo apt-get install gcc-4.4
    sudo apt-get install g++-4.4

Verifique que gcc-4.4 esté en / usr / bin /, y lo mismo para g ++ Entonces podría usar la solución anterior:

    sudo ln -s /usr/bin/gcc-4.4 /opt/cuda/bin/gcc
    sudo ln -s /usr/bin/g++-4.4 /opt/cuda/bin/g++

En $CUDA_HOME/include/host_config.h, busque líneas como estas (pueden variar ligeramente entre diferentes versiones de CUDA):

//...
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 9)

#error -- unsupported GNU version! gcc versions later than 4.9 are not supported!

#endif [> __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 9) <]
//...

Quítelos o cámbielos que coincidan con su condición.

Tenga en cuenta que este método es potencialmente inseguro y puede romper su compilación. Por ejemplo, gcc 5 usa C ++ 11 por defecto, sin embargo, este no es el caso para nvcc a partir de CUDA 7.5. Una solución alternativa es agregar

--Xcompiler="--std=c++98" para CUDA <= 6.5

o

--std=c++11 para CUDA> = 7.0.

Si encuentra este error, lea el archivo de registro:

$ cat /var/log/cuda-installer.log 
[INFO]: Driver installation detected by command: apt list --installed | grep -e nvidia-driver-[0-9][0-9][0-9] -e nvidia-[0-9][0-9][0-9]
[INFO]: Cleaning up window
[INFO]: Complete
[INFO]: Checking compiler version...
[INFO]: gcc location: /usr/bin/gcc

[INFO]: gcc version: gcc version 9.2.1 20191008 (Ubuntu 9.2.1-9ubuntu2) 

[ERROR]: unsupported compiler version: 9.2.1. Use --override to override this check.

Simplemente siga la sugerencia en el archivo de registro:

sudo sh cuda_<version>_linux.run --override

Trabajo hecho :)

Acabo de instalar CUDA 10.2 con gcc 9.2 en Kubuntu 19.10 usando la --overrideopción.

Para compilar los ejemplos de CUDA 8.0 en Ubuntu 16.10, hice:

sudo apt-get install gcc-5 g++-5
cd /path/to/NVIDIA_CUDA-8.0_Samples
# Find the path to the library (this should be in NVIDIA's Makefiles)
LIBLOC=`find /usr/lib -name "libnvcuvid.so.*" | head -n1 | perl -pe 's[/usr/lib/(nvidia-\d+)/.*][$1]'`
# Substitute that path into the makefiles for the hard-coded, incorrect one
find . -name "*.mk" | xargs perl -pi -e "s/nvidia-\d+/$LIBLOC/g"
# Make using the supported compiler
HOST_COMPILER=g++-5 make

Esto tiene la ventaja de no modificar todo el sistema o hacer enlaces simbólicos solo a los binarios (lo que podría causar problemas de vinculación de bibliotecas).

Esto resolvió mi problema:

sudo rm /usr/local/cuda/bin/gcc
sudo rm /usr/local/cuda/bin/g++
sudo apt install gcc-4.4 g++-4.4
sudo ln -s /usr/bin/gcc-4.4 /usr/local/cuda/bin/gcc
sudo ln -s /usr/bin/g++-4.4 /usr/local/cuda/bin/g++

Para CUDA 6.5 (y aparentemente 7.0 y 7.5), he creado una versión del paquete gcc 4.8.5 RPM (bajo Fedora Core 30) que permite que esa versión de gcc se instale junto con el GCC actual de su sistema.

Puedes encontrar toda esa información aquí .

En mi caso, ya tenía CUDA instalado desde la versión de Ubuntu y cmake lo detectaría en lugar de la versión recién instalada usando NVidia SDK Manager.

Corrí dpkg -l | grep cuday pude ver ambas versiones.

Lo que tuve que hacer fue desinstalar el antiguo CUDA (versión 9.1 en mi caso) y dejar la nueva versión sola (versión 10.2). Usé el comando de purga así:

sudo apt-get purge libcudart9.1 nvidia-cuda-dev nvidia-cuda-doc \
                                nvidia-cuda-gdb nvidia-cuda-toolkit

Verifique que los nombres de los paquetes coincidan con la versión que desea eliminar de su instalación.

Tuve que volver a ejecutar cmakedesde un BUILDdirectorio en blanco para redirigir todas las #includebibliotecas y a la versión SDK (ya que las rutas antiguas se crearon en el entorno de compilación existente).

Esto sucede porque su versión actual de CUDA no es compatible con su versión actual de GCC. Debes hacer lo siguiente:

1. Encuentre la versión de GCC compatible (en mi caso 5 para CUDA 9)

   • CUDA 4.1: GCC 4.5
   • CUDA 5.0: GCC 4.6
   • CUDA 6.0: GCC 4.7
   • CUDA 7.0: GCC 4.8
   • CUDA 7.5: GCC 4.8
   • CUDA 8: CGC 5.3
   • CUDA 9: CGC 5.5
   • CUDA 9.2: CCG 7
   • CUDA 10.1: GCC 8

2. Instale la versión de GCC compatible

   sudo apt-get install gcc-5
   sudo apt-get install g++-5

3. Cambie los enlaces suaves para GCC en el /usr/bindirectorio

   cd /usr/bin
   sudo rm gcc
   sudo rm g++
   sudo ln -s /usr/bin/gcc-5 gcc
   sudo ln -s /usr/bin/g++-5 g++

4. Cambie los enlaces suaves para GCC en el /usr/local/cuda-9.0/bindirectorio

   cd /usr/local/cuda-9.0/bin
   sudo rm gcc
   sudo rm g++
   sudo ln -s /usr/bin/gcc-5 gcc
   sudo ln -s /usr/bin/g++-5 g++

5. Agregar -DCUDA_HOST_COMPILER=/usr/bin/gcc-5a su setup.pyarchivo, utilizado para la compilación

   if torch.cuda.is_available() and CUDA_HOME is not None:
       extension = CUDAExtension
       sources += source_cuda
       define_macros += [("WITH_CUDA", None)]
       extra_compile_args["nvcc"] = [
           "-DCUDA_HAS_FP16=1",
           "-D__CUDA_NO_HALF_OPERATORS__",
           "-D__CUDA_NO_HALF_CONVERSIONS__",
           "-D__CUDA_NO_HALF2_OPERATORS__",
           "-DCUDA_HOST_COMPILER=/usr/bin/gcc-5"
       ]

6. Eliminar el directorio de compilación anterior

   rm -rd build/

7. Compilar de nuevo configurando CUDAHOSTCXX=/usr/bin/gcc-5

   CUDAHOSTCXX=/usr/bin/gcc-5 python setup.py build develop

Nota: Si sigue apareciendo el gcc: error trying to exec 'cc1plus': execvp: no such file or directoryerror después de seguir estos pasos, intente reinstalar el GCC de esta manera y luego compile nuevamente:

sudo apt-get install --reinstall gcc-5
sudo apt-get install --reinstall g++-5

Créditos: https://github.com/facebookresearch/maskrcnn-benchmark/issues/25#issuecomment-433382510