CUDA incompatibile con la mia versione gcc

Ho problemi a compilare alcuni degli esempi forniti con CUDA SDK. Ho installato il driver per sviluppatori (versione 270.41.19) e il toolkit CUDA, quindi finalmente l'SDK (entrambe le versioni 4.0.17).

Inizialmente non si compilava affatto dando:

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

Ho trovato la riga responsabile in 81: /usr/local/cuda/include/host_config.h e l'ho cambiata in:

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

da quel momento in poi ho avuto solo alcuni degli esempi da compilare, si ferma 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

Poiché alcuni degli esempi vengono compilati, ritengo che questo non sia un problema di driver, ma piuttosto deve avere qualcosa a che fare con una versione di gcc non supportata. Il downgrade non è un'opzione in quanto gcc4.6 ha un intero sistema come dipendenza a questo punto ...

Come già sottolineato, nvcc dipende da gcc 4.4. È possibile configurare nvcc per utilizzare la versione corretta di gcc senza passare alcun parametro del compilatore aggiungendo softlink alla directory bin creata con l'installazione di nvcc.

La directory binaria predefinita di cuda (l'impostazione predefinita di installazione) è / usr / local / cuda / bin, è sufficiente aggiungere un softlink alla versione corretta di gcc da questa directory:

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

gcc 4.5 e 4.6 non sono supportati con CUDA - il codice non verrà compilato e il resto della toolchain, incluso cuda-gdb, non funzionerà correttamente. Non puoi usarli e la restrizione non è negoziabile.

La tua unica soluzione è installare una versione di gcc 4.4 come secondo compilatore (la maggior parte delle distribuzioni lo consente). C'è un'opzione per nvcc --compiler-bindirche può essere usata per puntare a un compilatore alternativo. Creare una directory locale e quindi creare collegamenti simbolici agli eseguibili della versione gcc supportati. Passa quella directory locale a nvcc tramite l' --compiler-bindiropzione e dovresti essere in grado di compilare il codice CUDA senza influire sul resto del tuo sistema.

MODIFICA :

Nota che questa domanda e risposta riguardano CUDA 4.

Da quando è stato scritto, NVIDIA ha continuato ad espandere il supporto per le versioni successive di gcc nella versione più recente della toolchain CUDA

• A partire dalla versione CUDA 4.1, gcc 4.5 è ora supportato. gcc 4.6 e 4.7 non sono supportati.
  
• A partire dalla versione CUDA 5.0, gcc 4.6 è ora supportato. gcc 4.7 non è supportato.
  
• A partire dalla versione CUDA 6.0, gcc 4.7 è ora supportato.
• A partire dalla versione CUDA 7.0, gcc 4.8 è completamente supportato, con supporto 4.9 su Ubuntu 14.04 e Fedora 21.
• A partire dalla versione CUDA 7.5, gcc 4.8 è completamente supportato, con supporto 4.9 su Ubuntu 14.04 e Fedora 21.
• A partire dalla versione CUDA 8, gcc 5.3 è completamente supportato su Ubuntu 16.06 e Fedora 23.
• A partire dalla versione CUDA 9, gcc 6 è completamente supportato su Ubuntu 16.04, Ubuntu 17.04 e Fedora 25.
• La versione CUDA 9.2 aggiunge il supporto per gcc 7
• La versione CUDA 10.1 aggiunge il supporto per gcc 8

Al momento (a partire da CUDA 10.1) non c'è supporto per gcc 9 in CUDA.

Si noti che NVIDIA ha recentemente aggiunto una tabella molto utile qui che contiene il compilatore supportato e la matrice del sistema operativo per l'attuale versione CUDA.

1. Controlla la versione GCC massima supportata per la tua versione 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. Imposta una variabile env per quella versione di GCC. Ad esempio, per CUDA 10.2:

    MAX_GCC_VERSION=8

3. Assicurati di avere quella versione installata:

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

4. Aggiungi collegamenti simbolici nelle cartelle 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 sostituire /usr/local/cudacon il percorso di installazione CUDA, se non è presente)

Vedi questa sintesi di GitHub per ulteriori informazioni sulla tabella di compatibilità CUDA-GCC .

La soluzione di Gearoid Murphy funziona meglio per me poiché sulla mia distribuzione (Ubuntu 11.10), gcc-4.4 e gcc-4.6 sono nella stessa directory, quindi --compiler-bindir non è di aiuto. L'unico avvertimento è che ho anche dovuto installare g ++ - 4.4 e collegarlo anche simbolicamente:

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

Per CUDA7.5 funzionano queste linee:

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

Scopri come utilizzare "update-alternatives" per aggirare questo problema:

... Se installi gcc 4.6 puoi anche usare il comando update-alternatives per consentire un facile passaggio tra le versioni. Questo può essere configurato 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

Se usando cmakeper me nessuno degli hack per modificare i file e il collegamento ha funzionato, ho compilato usando i flag che specificano la versione gcc / g ++.
cmake -DCMAKE_C_COMPILER=gcc-6 -DCMAKE_CXX_COMPILER=g++-6 ..

Ha funzionato come un fascino.

Sulla maggior parte delle distribuzioni hai la possibilità di installare un'altra versione di gcc e g ++ accanto a un compilatore più recente come gcc-4.7. Inoltre la maggior parte dei sistemi di compilazione conosce le variabili di ambiente CCe CXX, che consentono di specificare rispettivamente altri compilatori C e C ++. Quindi suggerisco qualcosa come:

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

Per i Makefile dovrebbe esserci un modo simile. Non consiglio di impostare collegamenti simbolici personalizzati in / usr / local a meno che tu non sappia cosa stai facendo.

Questo funziona per fedora 23. I repository compat gcc saranno leggermente diversi in base alla tua versione di fedora.

Se installi i seguenti repository:

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

Ora crea i collegamenti software come menzionato sopra supponendo che la tua cartella cuda bin sia in /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++

Ora dovresti essere in grado di compilare con nvccsenza l'errore di versione di gcc.

La soluzione di Gearoid Murphy funziona a meraviglia. Per me avevo due directory per cuda -

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

I collegamenti software dovevano essere aggiunti solo alla directory menzionata di seguito -

/usr/local/cuda 

Inoltre, come menzionato da SchighSchagh, erano richiesti sia i soft link g ++ che gcc.

Un altro modo per configurare nvcc per utilizzare una versione specifica di gcc (gcc-4.4, per esempio), è modificare nvcc.profile e alterare PATH per includere il percorso del gcc che si desidera utilizzare per primo.

Ad esempio (gcc-4.4.6 installato in / 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 posizione di nvcc.profile varia, ma dovrebbe essere nella stessa directory dell'eseguibile nvcc stesso.

Questo è un po 'un trucco, poiché nvcc.profile non è inteso per la configurazione dell'utente come da manuale di nvcc, ma era la soluzione che ha funzionato meglio per me.

Dopo alcune modifiche all'intestazione, CUDA è compatibile con gcc4.7 e forse una versione successiva: https://www.udacity.com/wiki/cs344/troubleshoot_gcc47

Per le persone come me che si confondono durante l'utilizzo cmake, lo FindCUDA.cmakescript sovrascrive alcune delle cose da nvcc.profile. Puoi specificare il filenvcc compilatore host impostando CUDA_HOST_COMPILERcome per http://public.kitware.com/Bug/view.php?id=13674 .

Ho dovuto installare le versioni precedenti di gcc, g ++.

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

Controlla che gcc-4.4 sia in / usr / bin / e lo stesso per g ++ Quindi potrei usare la soluzione sopra:

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

In $CUDA_HOME/include/host_config.h, trova linee come queste (possono variare leggermente tra le diverse versioni di 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) <]
//...

Rimuovili o modificali in base alle tue condizioni.

Nota che questo metodo è potenzialmente pericoloso e potrebbe danneggiare la tua build. Ad esempio, gcc 5 utilizza C ++ 11 come impostazione predefinita, tuttavia questo non è il caso di nvcc a partire da CUDA 7.5. Una soluzione alternativa è aggiungere

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

o

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

Se si verifica questo errore, leggere il file di 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.

Segui semplicemente il suggerimento nel file di registro:

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

Lavoro fatto :)

Ho appena installato CUDA 10.2 con gcc 9.2 su Kubuntu 19.10 usando l' --overrideopzione.

Per compilare gli esempi CUDA 8.0 su Ubuntu 16.10, ho fatto:

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

Questo ha il vantaggio di non modificare l'intero sistema o creare collegamenti simbolici solo ai binari (ciò potrebbe causare problemi di collegamento delle librerie).

Questo ha risolto il mio 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++

Per CUDA 6.5 (e apparentemente 7.0 e 7.5), ho creato una versione del pacchetto gcc 4.8.5 RPM (sotto Fedora Core 30) che consente di installare quella versione di gcc insieme all'attuale GCC del tuo sistema.

Puoi trovare tutte queste informazioni qui .

Nel mio caso, avevo CUDA già installato dalla versione di Ubuntu e cmake avrebbe rilevato quello invece della versione appena installata utilizzando NVidia SDK Manager.

Ho corso dpkg -l | grep cuda e potuto vedere entrambe le versioni.

Quello che dovevo fare è disinstallare il vecchio CUDA (versione 9.1 nel mio caso) e lasciare da sola la nuova versione (versione 10.2). Ho usato il comando di eliminazione in questo modo:

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

Verifica che i nomi dei pacchetti corrispondano alla versione che desideri rimuovere dall'installazione.

Ho dovuto eseguire di nuovo cmakeda una BUILDdirectory vuota per reindirizzare tutte le #includelibrerie e alla versione SDK (poiché i vecchi percorsi erano cotti nell'ambiente di compilazione esistente).

Questo accade perché la tua attuale versione di CUDA non supporta la tua attuale versione di GCC. Devi fare quanto segue:

1. Trova la versione GCC supportata (nel mio caso 5 per 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. Installa la versione GCC supportata

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

3. Modificare i collegamenti software per GCC nella /usr/bindirectory

   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. Modificare i collegamenti software per GCC nella /usr/local/cuda-9.0/bindirectory

   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. Aggiungi -DCUDA_HOST_COMPILER=/usr/bin/gcc-5al tuo setup.pyfile, usato per la compilazione

   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. Rimuovi la vecchia directory di build

   rm -rd build/

7. Compilare di nuovo impostando CUDAHOSTCXX=/usr/bin/gcc-5

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

Nota: se continui a ricevere l' gcc: error trying to exec 'cc1plus': execvp: no such file or directoryerrore dopo aver seguito questi passaggi, prova a reinstallare GCC in questo modo e quindi a compilare di nuovo:

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

Crediti: https://github.com/facebookresearch/maskrcnn-benchmark/issues/25#issuecomment-433382510