CUDA incompatível com minha versão gcc

Eu tenho problemas para compilar alguns dos exemplos fornecidos com CUDA SDK. Instalei o driver de desenvolvedores (versão 270.41.19) e o kit de ferramentas CUDA e, finalmente, o SDK (ambos na versão 4.0.17).

Inicialmente, ele não compilou, dando:

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

Encontrei a linha responsável em 81: /usr/local/cuda/include/host_config.h e mudei para:

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

daquele ponto em diante, tenho apenas alguns dos exemplos para compilar, ele pára com:

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

Como alguns dos exemplos compilam, acho que este não é um problema de driver, mas deve ter algo a ver com uma versão do gcc não suportada. O downgrade não é uma opção, pois o gcc4.6 tem um sistema inteiro como uma dependência neste ponto ...

Como já apontado, o nvcc depende do gcc 4.4. É possível configurar o nvcc para usar a versão correta do gcc sem passar nenhum parâmetro do compilador adicionando softlinks ao diretório bin criado com a instalação do nvcc.

O diretório binário cuda padrão (o padrão de instalação) é / usr / local / cuda / bin, adicionar um softlink para a versão correta do gcc a partir deste diretório é suficiente:

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

gcc 4.5 e 4.6 não são suportados com CUDA - o código não compilará e o resto da cadeia de ferramentas, incluindo cuda-gdb, não funcionará corretamente. Você não pode usá-los e a restrição não é negociável.

Sua única solução é instalar uma versão do gcc 4.4 como um segundo compilador (a maioria das distribuições permite isso). Existe uma opção para nvcc --compiler-bindirque pode ser usada para apontar para um compilador alternativo. Crie um diretório local e faça links simbólicos para os executáveis ​​da versão gcc com suporte. Passe esse diretório local para nvcc por meio da --compiler-bindiropção e você poderá compilar o código CUDA sem afetar o resto do seu sistema.

EDITAR :

Observe que esta pergunta e resposta referem-se a CUDA 4.

Desde que foi escrito, a NVIDIA continuou a expandir o suporte para versões posteriores do gcc na versão mais recente do conjunto de ferramentas CUDA

• A partir da versão CUDA 4.1, o gcc 4.5 agora é compatível. gcc 4.6 e 4.7 não são suportados.
  
• A partir do lançamento do CUDA 5.0, o gcc 4.6 agora é compatível. gcc 4.7 não é compatível.
  
• A partir da versão CUDA 6.0, o gcc 4.7 agora é compatível.
• A partir da versão CUDA 7.0, gcc 4.8 é totalmente compatível, com suporte 4.9 no Ubuntu 14.04 e Fedora 21.
• A partir do lançamento do CUDA 7.5, o gcc 4.8 é totalmente compatível, com o suporte 4.9 no Ubuntu 14.04 e Fedora 21.
• A partir do lançamento do CUDA 8, o gcc 5.3 é totalmente compatível com Ubuntu 16.06 e Fedora 23.
• A partir do lançamento do CUDA 9, o gcc 6 é totalmente compatível com Ubuntu 16.04, Ubuntu 17.04 e Fedora 25.
• A versão CUDA 9.2 adiciona suporte para gcc 7
• A versão CUDA 10.1 adiciona suporte para gcc 8

Atualmente (a partir do CUDA 10.1) não há suporte para gcc 9 no CUDA.

Observe que a NVIDIA adicionou recentemente uma tabela muito útil aqui, que contém o compilador compatível e a matriz do sistema operacional para a versão CUDA atual.

1. Verifique a versão GCC máxima suportada para sua versão 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. Defina um env var para essa versão do GCC. Por exemplo, para CUDA 10.2:

    MAX_GCC_VERSION=8

3. Certifique-se de ter essa versão instalada:

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

4. Adicione links simbólicos nas pastas 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++

   (ou substitua /usr/local/cudapelo caminho de instalação do CUDA, se não estiver lá)

Consulte esta gist GitHub para obter mais informações sobre a tabela de compatibilidade CUDA-GCC .

A solução de Gearoid Murphy funciona melhor para mim, já que na minha distro (Ubuntu 11.10), gcc-4.4 e gcc-4.6 estão no mesmo diretório, então --compiler-bindir não ajuda. A única ressalva é que eu também tive que instalar o g ++ - 4.4 e criar um link simbólico:

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 linhas funcionam:

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++

Veja como usar "alternativas de atualização" para contornar esse problema:

... Se você instalar o gcc 4.6, você também pode usar o comando update-transactions para permitir a troca fácil entre as versões. Isso pode ser configurado com:

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

Se estiver usando cmakepara mim, nenhum dos hacks de edição de arquivos e vinculação funcionou, então compilei usando os sinalizadores que especificam a versão gcc / g ++.
cmake -DCMAKE_C_COMPILER=gcc-6 -DCMAKE_CXX_COMPILER=g++-6 ..

Funcionou como charme.

Na maioria das distribuições, você tem a possibilidade de instalar outra versão do gcc e g ++ ao lado do compilador mais recente como o gcc-4.7. Além disso, a maioria dos sistemas de construção está ciente das variáveis ​​de ambiente CCe CXX, que permitem especificar outros compiladores C e C ++, respectivamente. Portanto, sugiro algo como:

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

Para Makefiles, deve haver uma maneira semelhante. Eu não recomendo definir links simbólicos personalizados em / usr / local a menos que você saiba o que está fazendo.

Isso funciona para o fedora 23. Os repositórios compat gcc serão ligeiramente diferentes com base na sua versão do fedora.

Se você instalar os seguintes repositórios:

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

Agora faça os links virtuais conforme mencionado acima, assumindo que sua pasta cuda bin está /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++

Agora você deve ser capaz de compilar nvccsem o erro de versão do gcc.

A solução de Gearoid Murphy funciona perfeitamente. Para mim, eu tinha dois diretórios para cuda -

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

Os links virtuais tiveram que ser adicionados apenas ao diretório mencionado abaixo -

/usr/local/cuda 

Além disso, ambos os soft links g ++ e gcc foram necessários conforme mencionado por SchighSchagh.

Outra maneira de configurar o nvcc para usar uma versão específica do gcc (gcc-4.4, por exemplo) é editar nvcc.profile e alterar o PATH para incluir o caminho para o gcc que você deseja usar primeiro.

Por exemplo (gcc-4.4.6 instalado em / 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_):

A localização de nvcc.profile varia, mas deve estar no mesmo diretório que o próprio executável nvcc .

Isso é um pouco um hack, já que nvcc.profile não se destina à configuração do usuário conforme o manual do nvcc, mas foi a solução que funcionou melhor para mim.

CUDA é após algumas modificações de cabeçalho compatíveis com gcc4.7 e talvez uma versão superior: https://www.udacity.com/wiki/cs344/troubleshoot_gcc47

Para pessoas como eu, que ficam confusas durante o uso cmake, o FindCUDA.cmakescript substitui algumas das coisas do nvcc.profile. Você pode especificar o nvcccompilador de host configurando CUDA_HOST_COMPILERconforme http://public.kitware.com/Bug/view.php?id=13674 .

Tive que instalar as versões anteriores do gcc, g ++.

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

Verifique se gcc-4.4 está em / usr / bin / e o mesmo para g ++. Então, eu poderia usar a solução acima:

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

Em $CUDA_HOME/include/host_config.h, encontre linhas como estas (podem variar ligeiramente entre as diferentes versões do 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) <]
//...

Remova ou altere-os de acordo com sua condição.

Observe que este método é potencialmente inseguro e pode interromper sua construção. Por exemplo, o gcc 5 usa C ++ 11 como padrão, entretanto este não é o caso do nvcc a partir do CUDA 7.5. Uma solução alternativa é adicionar

--Xcompiler="--std=c++98" para CUDA <= 6,5

ou

--std=c++11 para CUDA> = 7,0.

Se você encontrar esse erro, leia o arquivo de log:

$ 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.

Basta seguir a sugestão do arquivo de log:

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

Tarefa concluída :)

Acabei de instalar o CUDA 10.2 com gcc 9.2 no Kubuntu 19.10 usando a --overrideopção.

Para compilar os exemplos do CUDA 8.0 no Ubuntu 16.10, eu fiz:

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

Isso tem a vantagem de não modificar todo o sistema ou criar links simbólicos apenas para os binários (o que pode causar problemas de vinculação de bibliotecas).

Isso resolveu meu 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 (e aparentemente 7.0 e 7.5), criei uma versão do pacote gcc 4.8.5 RPM (no Fedora Core 30) que permite que essa versão do gcc seja instalada junto com o GCC atual do seu sistema.

Você pode encontrar todas essas informações aqui .

No meu caso, eu já tinha o CUDA instalado a partir da versão Ubuntu e o cmake detectaria esse em vez da versão recém-instalada usando o NVidia SDK Manager.

Eu corri dpkg -l | grep cuda e pude ver as duas versões.

O que eu tive que fazer é desinstalar o CUDA antigo (versão 9.1 no meu caso) e deixar a nova versão (versão 10.2). Usei o comando purge assim:

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

Verifique se os nomes dos pacotes correspondem à versão que você deseja remover da instalação.

Tive que executar novamente a cmakepartir de um BUILDdiretório em branco para redirecionar todas as #includebibliotecas e para a versão do SDK (já que os caminhos antigos foram criados no ambiente de construção existente).

Isso está acontecendo porque sua versão CUDA atual não suporta sua versão GCC atual. Você precisa fazer o seguinte:

1. Encontre a versão GCC compatível (no meu 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: GCC 5.3
   • CUDA 9: GCC 5.5
   • CUDA 9.2: GCC 7
   • CUDA 10.1: GCC 8

2. Instale a versão GCC compatível

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

3. Altere os softlinks para GCC no /usr/bindiretório

   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. Altere os softlinks para GCC no /usr/local/cuda-9.0/bindiretório

   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. Adicione -DCUDA_HOST_COMPILER=/usr/bin/gcc-5ao seu setup.pyarquivo, usado para compilação

   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. Remova o diretório de construção antigo

   rm -rd build/

7. Compile novamente definindo CUDAHOSTCXX=/usr/bin/gcc-5

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

Observação: se você ainda receber o gcc: error trying to exec 'cc1plus': execvp: no such file or directoryerro após seguir essas etapas, tente reinstalar o GCC desta forma e compilar novamente:

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