Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Teams

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

I have troubles compiling some of the examples shipped with CUDA SDK. I have installed the developers driver (version 270.41.19) and the CUDA toolkit, then finally the SDK (both the 4.0.17 version).

Initially it didn't compile at all giving:

error -- unsupported GNU version! gcc 4.5 and up are not supported!
I found the line responsible in 81:/usr/local/cuda/include/host_config.h  and changed it to:
//#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4)
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6)
from that point on I got only a few of the examples to compile, it stops with:
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
As some of the examples compile I reckon this is not a driver problem, but rather must have something to do with an unsupported gcc version. Downgrading is not an option as gcc4.6 has a whole system as a dependency at this point...    
                For future readers: Make sure you're using the latest version of CUDA (unless you absolutely have to use an early one). NVIDIA ups the maximum supported compiler version with almost every release.
– einpoklum
                Aug 3, 2015 at 21:56
                This may be helpful for those with CUDA 10 and getting the error of a too high a gnu compiler chain version: stackoverflow.com/questions/53344283/…
– Douglas Daseeco
                Dec 18, 2018 at 8:27
                While installing detectron2 I got a similar message, for that I passed the system variable export TORCH_DONT_CHECK_COMPILER_ABI=1 and re-ran the setup.py and everything was installed smoothly. I am on CUDA 12.0 g++ 12.x
– Muneeb Ahmad Khurram
                Dec 4, 2022 at 19:20
As already pointed out, nvcc depends on gcc 4.4. It is possible to configure nvcc to use the correct version of gcc without passing any compiler parameters by adding softlinks to the bin directory created with the nvcc install.
The default cuda binary directory (the installation default) is /usr/local/cuda/bin, adding a softlink to the correct version of gcc from this directory is sufficient: 
sudo ln -s /usr/bin/gcc-4.4 /usr/local/cuda/bin/gcc
                I also had to link to g++. Otherwise, simple nvcc invocations work, but say, applying make to the CUDA Samples, soon brings in invocations starting with: nvcc -ccbin g++. For me I used sudo ln -s /usr/bin/gcc-4.9 /usr/local/cuda/bin/gcc and sudo ln -s /usr/bin/g++-4.9 /usr/local/cuda/bin/g++.
– user2023370
                Dec 21, 2015 at 12:32
                If you compile with cmake .. && make you can try cmake -D CUDA_NVCC_FLAGS="-ccbin gcc-4.4" .. && make. If you use plain Makefile you can try make CXX=g++-4.4 CC=gcc-4.4.
– patryk.beza
                Apr 4, 2016 at 18:54
Make sure you have that version installed:
sudo apt install gcc-$MAX_GCC_VERSION g++-$MAX_GCC_VERSION
Add symlinks within CUDA folders:
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++
(or substitute /usr/local/cuda with your CUDA installation path, if it's not there)
See this GitHub gist for more information on the CUDA-GCC compatibility table.
                Saved my life lol configuration nightmare!!!! thank you. I applied this to cuda 10 with gcc and g++ 7 system links. For anyone that comes across this.
– thekevshow
                Apr 3, 2019 at 6:13
                Should I create the /usr/bin/gcc and /usr/bin/g++ or /usr/local/cuda/bin/gcc folders myself?
– Josh Desmond
                May 13, 2020 at 16:07
                @bryant1410 When I ran the commands in step four, I remember getting an error along the lines of, "Error: directory /usr/local/cuda/bin/gcc does not exist, aborting," or something similar. I'm realizing now, (after reading the details of the question), that your answer assumes a step 0 mentioned by OP: "I have installed the CUDA toolkit, then finally the SDK". I was trying to do the installation with NVIDIA's cuda_10.2.89_440.33.01_linux.run wizard thingy, which simply failed on runtime with a complaint about gcc compatibility. I ended up just deciding to uninstall gcc 9 :P
– Josh Desmond
                May 14, 2020 at 4:34
                If you installed NVCC with [ana|mini]conda (conda-forge package cudatoolkit-dev), then you need to link inside your env like ln -s /usr/bin/gcc-8 /home/user/miniconda3/envs/your_env/bin/gcc and ln -s /usr/bin/g++-8 /home/user/miniconda3/envs/your_env/bin/g++
– Diego Ferri
                Jul 8, 2020 at 16:42
gcc 4.5 and 4.6 are not supported with CUDA - code won't compile and the rest of the toolchain, including cuda-gdb, won't work properly. You cannot use them, and the restriction is non-negotiable.
Your only solution is to install a gcc 4.4 version as a second compiler (most distributions will allow that). There is an option to nvcc --compiler-bindir which can be used to point to an alternative compiler. Create a local directory and then make symbolic links to the supported gcc version executables. Pass that local directory to nvcc via the --compiler-bindir option, and you should be able to compile CUDA code without affecting the rest of your system.
EDIT:
Note that this question, and answer, pertain to CUDA 4.
Since it was written, NVIDIA has continued to expand support for later gcc versions in newer CUDA toolchain release
As of the CUDA 4.1 release, gcc 4.5 is now supported. gcc 4.6 and 4.7 are unsupported.

As of the CUDA 5.0 release, gcc 4.6 is now supported. gcc 4.7 is unsupported.

As of the CUDA 6.0 release, gcc 4.7 is now supported.
As of the CUDA 7.0 release, gcc 4.8 is fully supported, with 4.9 support on Ubuntu 14.04 and Fedora 21.
As of the CUDA 7.5 release, gcc 4.8 is fully supported, with 4.9 support on Ubuntu 14.04 and Fedora 21.
As of the CUDA 8 release, gcc 5.3 is fully supported on Ubuntu 16.06 and Fedora 23.
As of the CUDA 9 release, gcc 6 is fully supported on Ubuntu 16.04, Ubuntu 17.04 and Fedora 25.
The CUDA 9.2 release adds support for gcc 7
The CUDA 10.1 release adds support for gcc 8
The CUDA 10.2 release continues support for gcc 8
The CUDA 11.0 release adds support for gcc 9 on Ubuntu 20.04
The CUDA 11.1 release expands gcc 9 support across most distributions and adds support for gcc 10 on Fedora linux
There is presently (as of CUDA 11.1) no gcc 10 support in CUDA other than Fedora linux
Note that NVIDIA has recently added a very useful table here which contains the supported compiler and OS matrix for the current CUDA release.
                What? How is a code supposed to not compile with higher versions (except for hardcoded limitations of course)? The only thing I can think of is that since some version there's C11/C++11 are enabled by default, but if that is causing a problem with an old code, that could be easy workarounded with a command line switch.
– Hi-Angel
                Feb 11, 2016 at 11:38
                Seconding @Hi-Angel.  #talonmies what does "the restriction is non-negotiable" even mean?  Newer versions of gcc and gdb support older binary headers for object files, as they "always" (sort of) have, there's no reason newer gcc versions shouldn't work.  Symlinking solutions aside, any other problem is most likely a c preprocessor version flag setting, and if the gcc version test is "hardcoded" in some cuda header as part of a define or macro, it is easy enough to fix.  The exception could be the cuda gpu compiler itself.
– Beracah
                Nov 28, 2016 at 19:35
                This isn't s binary compatibility question. The CUDA toolchain requires that nvcc and the GPU front end parser can intercept and overload various compiler and libc/libc++ internal headers to both compile host and device code and integrate them together. The CUDA parser needs to be able to parse the gcc internal headers correctly, amongst other things. Untested gcc versions can and do fail, irrespective of preprocessor guards built into the NVIDIA headers. You can either believe me (as someone who has been hacking on the CUDA toolchain for almost 10 years), or not. At this point I don't really
– talonmies
                Nov 28, 2016 at 20:33
Gearoid Murphy's solution works better for me since on my distro (Ubuntu 11.10), gcc-4.4 and gcc-4.6 are in the same directory, so --compiler-bindir is no help. The only caveat is I also had to install g++-4.4 and symlink it as well:
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++
If using cmake for me none of the hacks of editing the files and linking worked so I compiled using the flags which specify the gcc/g++ version.

cmake -DCMAKE_C_COMPILER=gcc-6 -DCMAKE_CXX_COMPILER=g++-6 .. 
Worked like charm.
                haha I was going to try to link your answer from the other question here because I thought it needed to be put on this thread. Good work again! Thanks
– MikeDoho
                Jul 24, 2018 at 2:46
  
... If you install gcc 4.6 you can also use the update-alternatives
  command to allow for easily switching between versions. This can be
  configured with:
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
On most distributions you have the possibility to install another gcc and g++ version beside a most recent compiler like gcc-4.7. In addition most build systems are aware of the CC and CXX environment variables, which let specify you other C and C++ compilers respectively. SO I suggest something like:
CC=gcc-4.4 CXX=g++-4.4 cmake path/to/your/CMakeLists.txt
For Makefiles there should be a similar way. I do not recommend setting custom symlinks within /usr/local unless you know what you are doing.
This works for fedora 23. The compat gcc repositories will be slightly different based on your version of fedora.
If you install the following repositories:
sudo yum install compat-gcc-34-c++-3.4.6-37.fc23.x86_64 compat-gcc-34-3.4.6-37.fc23.x86_64 
Now make the soft links as mentioned above assuming your cuda bin folder is 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++
You should now be able to compile with nvcc without the gcc version error.
Gearoid Murphy's solution works like a charm. For me I had two directories for cuda - 
/usr/local/cuda 
/usr/local/cuda-5.0
The soft links had to be added only to the directory mentioned below - 
/usr/local/cuda 
Also, both g++ and gcc soft links were required as mentioned by SchighSchagh. 
Another way of configuring nvcc to use a specific version of gcc (gcc-4.4, for instance), is to edit nvcc.profile and alter PATH to include the path to the gcc you want to use first.
For example (gcc-4.4.6 installed 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_):
The location of nvcc.profile varies, but it should be in the same directory as the nvcc executable itself.
This is a bit of a hack, as nvcc.profile is not intended for user configuration as per the nvcc manual, but it was the solution which worked best for me.
                I suggest doing this, but pointing the path to a directory with g++ symlinked to the correct gcc version (especially useful if your distribution provides a supported gcc version). For example: mkdir /usr/local/bin/cuda-hack && ln -s /usr/bin/g++-5 /usr/local/bin/cuda-hack
– Sami Liedes
                Jun 9, 2017 at 21:00
                cmake .. -DCMAKE_INSTALL_PREFIX=/InstallPos_GPU/  -DCMAKE_C_COMPILER="/gcc-8.3.0/bin/gcc" -DCMAKE_CXX_COMPILER="/gcc-8.3.0/bin/g++"  -DGMX_GPU=ON -DCUDA_TOOLKIT_ROOT_DIR=/cuda-7.5/  -D NVCCFLAGS=" -ccbin /cuda-7.5/bin/" -DCUDA_HOST_COMPILER=/cuda-7.5/bin/gcc I have successfully installed the gromacs with GPU supporting.
– pengchy
                Apr 15, 2019 at 8:24
                I'm afraid I'm too far removed from thinking about this to know what to say. Hopefully others can help.
– travelingbones
                May 27, 2016 at 16:08
In $CUDA_HOME/include/host_config.h, find lines like these (may slightly vary between different CUDA version):
//...
#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) <]
//...
Remove or change them matching your condition.
Note this method is potentially unsafe and may break your build. For example, gcc 5 uses C++11 as default, however this is not the case for nvcc as of CUDA 7.5. A workaround is to add
--Xcompiler="--std=c++98" for CUDA<=6.5 
--std=c++11 for CUDA>=7.0.
$ 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.
Just follow the suggestion in the log file:
sudo sh cuda_<version>_linux.run --override
Job done :)
I just installed CUDA 10.2 with gcc 9.2 on Kubuntu 19.10 using the --override option.
For CUDA 6.5 (and apparently 7.0 and 7.5), I've created a version of the gcc 4.8.5 RPM package (under Fedora Core 30) that allows that version of gcc to be install alongside your system's current GCC.
You can find all of that information here.
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
This has the advantage of not modifying the whole system or making symlinks to just the binaries (that could cause library linking problems.)
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++
In my case, I had CUDA already installed from the Ubuntu version and cmake would detect that one instead of the newly installed version using the NVidia SDK Manager.
I ran dpkg -l | grep cuda and could see both versions.
What I had to do is uninstall the old CUDA (version 9.1 in my case) and leave the new version alone (version 10.2). I used the purge command like so:
sudo apt-get purge libcudart9.1 nvidia-cuda-dev nvidia-cuda-doc \
                                nvidia-cuda-gdb nvidia-cuda-toolkit
Please verify that the package names match the version you want to remove from your installation.
I had to rerun cmake from a blank BUILD directory to redirect all the #include and libraries to the SDK version (since the old paths were baked in the existing build environment).
This is happening because your current CUDA version doesn't support your current GCC version. You need to do the following:
Find the supported GCC version (in my case 5 for 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
Install the supported GCC version
sudo apt-get install gcc-5
sudo apt-get install g++-5
Change the softlinks for GCC in the /usr/bin directory
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++
Change the softlinks for GCC in the /usr/local/cuda-9.0/bin directory
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++
Add -DCUDA_HOST_COMPILER=/usr/bin/gcc-5 to your setup.py file, used for compilation
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"
Remove the old build directory
rm -rd build/
Compile again by setting CUDAHOSTCXX=/usr/bin/gcc-5
CUDAHOSTCXX=/usr/bin/gcc-5 python setup.py build develop
Note: If you still get the gcc: error trying to exec 'cc1plus': execvp: no such file or directory error after following these steps, try reinstalling the GCC like this and then compiling again:
sudo apt-get install --reinstall gcc-5
sudo apt-get install --reinstall g++-5
Credits: https://github.com/facebookresearch/maskrcnn-benchmark/issues/25#issuecomment-433382510