sci-chemistry/gromacs: Fix build with cuda-12

Thanks to pacho@gentoo.org for patch

Closes: https://bugs.gentoo.org/900204
Signed-off-by: Alexey Shvetsov <alexxy@gentoo.org>

2 files changed, 343 insertions, 1 deletions

diff --git a/sci-chemistry/gromacs/files/gromacs-2021-cuda-detection.patch b/sci-chemistry/gromacs/files/gromacs-2021-cuda-detection.patch
new file mode 100644
index 000000000000..8b458e96cb53
--- /dev/null
+++ b/sci-chemistry/gromacs/files/gromacs-2021-cuda-detection.patch
@@ -0,0 +1,339 @@
+--- gromacs-2021.7/cmake/gmxManageNvccConfig.cmake	2023-01-31 12:45:45.000000000 +0100
++++ gromacs-2022.5/cmake/gmxManageNvccConfig.cmake	2023-02-03 12:53:34.000000000 +0100
+@@ -1,11 +1,9 @@
+ #
+ # This file is part of the GROMACS molecular simulation package.
+ #
+-# Copyright (c) 2012,2013,2014,2015,2016 by the GROMACS development team.
+-# Copyright (c) 2017,2018,2019,2020,2021, by the GROMACS development team, led by
+-# Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
+-# and including many others, as listed in the AUTHORS file in the
+-# top-level source directory and at http://www.gromacs.org.
++# Copyright 2012- The GROMACS Authors
++# and the project initiators Erik Lindahl, Berk Hess and David van der Spoel.
++# Consult the AUTHORS/COPYING files and https://www.gromacs.org for details.
+ #
+ # GROMACS is free software; you can redistribute it and/or
+ # modify it under the terms of the GNU Lesser General Public License
+@@ -19,7 +17,7 @@
+ #
+ # You should have received a copy of the GNU Lesser General Public
+ # License along with GROMACS; if not, see
+-# http://www.gnu.org/licenses, or write to the Free Software Foundation,
++# https://www.gnu.org/licenses, or write to the Free Software Foundation,
+ # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ #
+ # If you want to redistribute modifications to GROMACS, please
+@@ -28,10 +26,10 @@
+ # consider code for inclusion in the official distribution, but
+ # derived work must not be called official GROMACS. Details are found
+ # in the README & COPYING files - if they are missing, get the
+-# official version at http://www.gromacs.org.
++# official version at https://www.gromacs.org.
+ #
+ # To help us fund GROMACS development, we humbly ask that you cite
+-# the research papers on the package. Check out http://www.gromacs.org.
++# the research papers on the package. Check out https://www.gromacs.org.
+ 
+ # Manage CUDA nvcc compilation configuration, try to be smart to ease the users'
+ # pain as much as possible:
+@@ -51,7 +49,7 @@
+ # glibc source shows that _FORCE_INLINES is only used in this string.h
+ # feature and performance of memcpy variants is unimportant for CUDA
+ # code in GROMACS. So this workaround is good enough to keep problems
+-# away from users installing GROMACS. See Issue #1942.
++# away from users installing GROMACS. See Issue #1982.
+ function(work_around_glibc_2_23)
+     try_compile(IS_GLIBC_2_23_OR_HIGHER ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}/cmake/TestGlibcVersion.cpp)
+     if(IS_GLIBC_2_23_OR_HIGHER)
+@@ -83,67 +81,158 @@
+     mark_as_advanced(CUDA_HOST_COMPILER CUDA_HOST_COMPILER_OPTIONS)
+ endif()
+ 
++# We would like to be helpful and reject the host compiler with a
++# clear error message at configure time, rather than let nvcc
++# later reject the host compiler as not supported when the first
++# CUDA source file is built. We've implemented that for current
++# nvcc running on Unix-like systems, but e.g. changes to nvcc
++# will further affect the limited portability of this checking
++# code. Set the CMake variable GMX_NVCC_WORKS on if you want to
++# bypass this check.
++if((_cuda_nvcc_executable_or_flags_changed OR CUDA_HOST_COMPILER_CHANGED OR NOT GMX_NVCC_WORKS) AND NOT WIN32)
++    message(STATUS "Check for working NVCC/C++ compiler combination with nvcc '${CUDA_NVCC_EXECUTABLE}'")
++    execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} --compiler-bindir=${CUDA_HOST_COMPILER} -c ${CUDA_NVCC_FLAGS} ${CUDA_NVCC_FLAGS_${_build_type}} ${CMAKE_SOURCE_DIR}/cmake/TestCUDA.cu
++        RESULT_VARIABLE _cuda_test_res
++        OUTPUT_VARIABLE _cuda_test_out
++        ERROR_VARIABLE  _cuda_test_err
++        OUTPUT_STRIP_TRAILING_WHITESPACE)
++
++    if(${_cuda_test_res})
++        message(STATUS "Check for working NVCC/C compiler combination - broken")
++        message(STATUS "${CUDA_NVCC_EXECUTABLE} standard output: '${_cuda_test_out}'")
++        message(STATUS "${CUDA_NVCC_EXECUTABLE} standard error:  '${_cuda_test_err}'")
++        if(${_cuda_test_err} MATCHES "nsupported")
++            message(FATAL_ERROR "NVCC/C++ compiler combination does not seem to be supported. CUDA frequently does not support the latest versions of the host compiler, so you might want to try an earlier C++ compiler version and make sure your CUDA compiler and driver are as recent as possible. Set the GMX_NVCC_WORKS CMake cache variable to bypass this check if you know what you are doing.")
++        elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 11.2 AND CUDA_VERSION VERSION_GREATER 11.4 AND CUDA_VERSION VERSION_LESS 11.7) # Issue #4574, #4641
++            # Above, we should be checking for VERSION_LESS 11.6.2, but CUDA_VERSION is only "major.minor"
++            message(FATAL_ERROR "CUDA versions 11.5-11.6.1 are known to be incompatible with some GCC 11.x. Use a different GCC or update your CUDA installation to at least CUDA 11.6.2")
++        else()
++            message(FATAL_ERROR "CUDA compiler does not seem to be functional or is not compatible with the host compiler. Set the GMX_NVCC_WORKS CMake cache variable to bypass this check if you know what you are doing.")
++        endif()
++    elseif(NOT GMX_CUDA_TEST_COMPILER_QUIETLY)
++        message(STATUS "Check for working NVCC/C++ compiler combination - works")
++        set(GMX_NVCC_WORKS TRUE CACHE INTERNAL "Nvcc can compile a trivial test program")
++    endif()
++endif() # GMX_CHECK_NVCC
++
++# Tests a single flag to use with nvcc.
++#
++# If the flags are accepted, they are appended to the variable named
++# in the first argument. The cache variable named in the second
++# argument is used to avoid rerunning the check in future invocations
++# of cmake. The list of flags to check follows these two required
++# arguments.
++#
++# Note that a space-separated string of flags, or a flag-value pair
++# separated by spaces will not work. Use the single-argument forms
++# accepted by nvcc, like "--arg=value".
++#
++# As this code is not yet tested on Windows, it always accepts the
++# flags in that case.
++function(gmx_add_nvcc_flag_if_supported _output_variable_name_to_append_to _flags_cache_variable_name)
++    # If the check has already been run, do not re-run it
++    if (NOT ${_flags_cache_variable_name} AND NOT WIN32)
++        message(STATUS "Checking if nvcc accepts flags ${ARGN}")
++        # See detailed comment about gcc 7 below
++        if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8)
++            set(_cache_variable_value TRUE)
++            message(STATUS "Checking if nvcc accepts flags ${ARGN} - Assuming success when using gcc 7")
++        else()
++            if(NOT(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11))
++              set(CCBIN "--compiler-bindir=${CUDA_HOST_COMPILER}")
++            endif()
++            execute_process(
++                COMMAND ${CUDA_NVCC_EXECUTABLE} ${ARGN} ${CCBIN} "${CMAKE_SOURCE_DIR}/cmake/TestCUDA.cu"
++                RESULT_VARIABLE _cuda_success
++                OUTPUT_QUIET
++                ERROR_QUIET
++                )
++            # Convert the success value to a boolean and report status
++            if (_cuda_success EQUAL 0)
++                set(_cache_variable_value TRUE)
++                message(STATUS "Checking if nvcc accepts flags ${ARGN} - Success")
++            else()
++                set(_cache_variable_value FALSE)
++                message(STATUS "Checking if nvcc accepts flags ${ARGN} - Failed")
++            endif()
++        endif()
++        set(${_flags_cache_variable_name} ${_cache_variable_value} CACHE BOOL "Whether NVCC supports flag(s) ${ARGN}")
++    endif()
++    # Append the flags to the output variable if they have been tested to work
++    if (${_flags_cache_variable_name} OR WIN32)
++        list(APPEND ${_output_variable_name_to_append_to} ${ARGN})
++        set(${_output_variable_name_to_append_to} ${${_output_variable_name_to_append_to}} PARENT_SCOPE)
++    endif()
++endfunction()
++
++# Versions of gcc 7 have differing behavior when executing
++#
++#  nvcc $args --compiler-bindir=gcc TestCUDA.cu
++#
++# and would need e.g. adding -lstdc++ to the command line so that
++# linking of a C++/CUDA object by the C-compiler flavor of gcc works.
++# This means we can't reliably test compiler flags in this case
++# without risking creating other problems. Instead we assume (above)
++# that all compiler flags will work, and issue this warning.
++# We also want to skip this warning during GROMACS CI testing.
++if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8
++    AND NOT DEFINED ENV{GITLAB_CI})
++    message(WARNING "You are using gcc version 7 with the CUDA compiler nvcc. GROMACS cannot reliably test compiler arguments for this combination, so if you later experience errors in building GROMACS, please use a more recent version of gcc.")
++endif()
++
+ # If any of these manual override variables for target CUDA GPU architectures
+ # or virtual architecture is set, parse the values and assemble the nvcc
+ # command line for these. Otherwise use our defaults.
+ # Note that the manual override variables require a semicolon separating
+ # architecture codes.
++set(GMX_CUDA_NVCC_GENCODE_FLAGS)
+ if (GMX_CUDA_TARGET_SM OR GMX_CUDA_TARGET_COMPUTE)
+-    set(GMX_CUDA_NVCC_GENCODE_FLAGS)
+     set(_target_sm_list ${GMX_CUDA_TARGET_SM})
+     foreach(_target ${_target_sm_list})
+-        list(APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_${_target},code=sm_${_target}")
++        gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_${_target} "--generate-code=arch=compute_${_target},code=sm_${_target}")
++        if (NOT NVCC_HAS_GENCODE_COMPUTE_AND_SM_${_target} AND NOT WIN32)
++            message(FATAL_ERROR "Your choice of ${_target} in GMX_CUDA_TARGET_SM was not accepted by nvcc, please choose a target that it accepts")
++        endif()
+     endforeach()
+     set(_target_compute_list ${GMX_CUDA_TARGET_COMPUTE})
+     foreach(_target ${_target_compute_list})
+-        list(APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_${_target},code=compute_${_target}")
++        gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_${_target} --generate-code=arch=compute_${_target},code=compute_${_target})
++        if (NOT NVCC_HAS_GENCODE_COMPUTE_${_target} AND NOT WIN32)
++            message(FATAL_ERROR "Your choice of ${_target} in GMX_CUDA_TARGET_COMPUTE was not accepted by nvcc, please choose a target that it accepts")
++        endif()
+     endforeach()
+ else()
+     # Set the CUDA GPU architectures to compile for:
+-    # - with CUDA >=9.0         CC 7.0 is supported and CC 2.0 is no longer supported
+-    #     => compile sm_30, sm_35, sm_37, sm_50, sm_52, sm_60, sm_61, sm_70 SASS, and compute_35, compute_70 PTX
+-    # - with CUDA >=10.0        CC 7.5 is supported
+-    #     => compile sm_30, sm_35, sm_37, sm_50, sm_52, sm_60, sm_61, sm_70, sm_75 SASS, and compute_35, compute_75 PTX
+     # - with CUDA >=11.0        CC 8.0 is supported
+     #     => compile sm_35, sm_37, sm_50, sm_52, sm_60, sm_61, sm_70, sm_75, sm_80 SASS, and compute_35, compute_80 PTX
+ 
+     # First add flags that trigger SASS (binary) code generation for physical arch
+-    if(CUDA_VERSION VERSION_LESS "11.0")
+-        list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_30,code=sm_30")
+-    endif()
+-    list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_35,code=sm_35")
+-    list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_37,code=sm_37")
+-    list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_50,code=sm_50")
+-    list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_52,code=sm_52")
+-    list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_60,code=sm_60")
+-    list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_61,code=sm_61")
+-    list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_70,code=sm_70")
+-    if(NOT CUDA_VERSION VERSION_LESS "10.0")
+-        list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_75,code=sm_75")
+-    endif()
+-    if(NOT CUDA_VERSION VERSION_LESS "11.0")
+-        list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_80,code=sm_80")
+-        # Requesting sm or compute 35, 37, or 50 triggers deprecation messages with
+-        # nvcc 11.0, which we need to suppress for use in CI
+-        list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-Wno-deprecated-gpu-targets")
+-    endif()
+-    if(NOT CUDA_VERSION VERSION_LESS "11.1")
+-        list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_86,code=sm_86")
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_35 --generate-code=arch=compute_35,code=sm_35)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_37 --generate-code=arch=compute_37,code=sm_37)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_50 --generate-code=arch=compute_50,code=sm_50)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_52 --generate-code=arch=compute_52,code=sm_52)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_60 --generate-code=arch=compute_60,code=sm_60)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_61 --generate-code=arch=compute_61,code=sm_61)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_70 --generate-code=arch=compute_70,code=sm_70)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_75 --generate-code=arch=compute_75,code=sm_75)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_80 --generate-code=arch=compute_80,code=sm_80)
++    # Don't attempt to add newest architectures with old GNU compiler, to avoid issues in CI
++    # related to being unable to test which flags are supported
++    if (NOT (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8))
++        gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_86 --generate-code=arch=compute_86,code=sm_86)
++        gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_89 --generate-code=arch=compute_89,code=sm_89)
++        gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_AND_SM_90 --generate-code=arch=compute_90,code=sm_90)
+     endif()
++    # Requesting sm or compute 35, 37, or 50 triggers deprecation messages with
++    # nvcc 11.0, which we need to suppress for use in CI
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_WARNING_NO_DEPRECATED_GPU_TARGETS -Wno-deprecated-gpu-targets)
+ 
+     # Next add flags that trigger PTX code generation for the
+     # newest supported virtual arch that's useful to JIT to future architectures
+     # as well as an older one suitable for JIT-ing to any rare intermediate arch
+     # (like that of Jetson / Drive PX devices)
+-    list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_35,code=compute_35")
+-    if(CUDA_VERSION VERSION_LESS "11.0")
+-        list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_32,code=compute_32")
+-    else()
+-        list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_53,code=compute_53")
+-    endif()
+-    if(NOT CUDA_VERSION VERSION_LESS "11.0")
+-        list (APPEND GMX_CUDA_NVCC_GENCODE_FLAGS "-gencode;arch=compute_80,code=compute_80")
+-    endif()
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_53 --generate-code=arch=compute_53,code=sm_53)
++    gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_GENCODE_FLAGS NVCC_HAS_GENCODE_COMPUTE_80 --generate-code=arch=compute_80,code=sm_80)
+ endif()
+ 
+ if (GMX_CUDA_TARGET_SM)
+@@ -158,27 +247,20 @@
+ # FindCUDA.cmake is unaware of the mechanism used by cmake to embed
+ # the compiler flag for the required C++ standard in the generated
+ # build files, so we have to pass it ourselves
+-if (CUDA_VERSION VERSION_LESS 11.0)
+-    # CUDA doesn't formally support C++17 until version 11.0, so for
+-    # now host-side code that compiles with CUDA is restricted to
+-    # C++14. This needs to be expressed formally for older CUDA
+-    # version.
++
++# gcc-7 pre-dated C++17, so uses the -std=c++1z compiler flag for it,
++# which modern nvcc does not recognize. So we work around that by
++# compiling in C++14 mode. Clang doesn't have this problem because nvcc
++# only supports version of clang that already understood -std=c++17
++if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8)
+     list(APPEND GMX_CUDA_NVCC_FLAGS "${CMAKE_CXX14_STANDARD_COMPILE_OPTION}")
+ else()
+-    # gcc-7 pre-dated C++17, so uses the -std=c++1z compiler flag for it,
+-    # which modern nvcc does not recognize. So we work around that by
+-    # compiling in C++14 mode. Clang doesn't have this problem because nvcc
+-    # only supports version of clang that already understood -std=c++17
+-    if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8)
+-        list(APPEND GMX_CUDA_NVCC_FLAGS "${CMAKE_CXX14_STANDARD_COMPILE_OPTION}")
+-    else()
+-        list(APPEND GMX_CUDA_NVCC_FLAGS "${CMAKE_CXX17_STANDARD_COMPILE_OPTION}")
+-    endif()
++    list(APPEND GMX_CUDA_NVCC_FLAGS "${CMAKE_CXX17_STANDARD_COMPILE_OPTION}")
+ endif()
+ 
+ # assemble the CUDA flags
+ list(APPEND GMX_CUDA_NVCC_FLAGS "${GMX_CUDA_NVCC_GENCODE_FLAGS}")
+-list(APPEND GMX_CUDA_NVCC_FLAGS "-use_fast_math")
++gmx_add_nvcc_flag_if_supported(GMX_CUDA_NVCC_FLAGS NVCC_HAS_USE_FAST_MATH -use_fast_math)
+ 
+ # assemble the CUDA host compiler flags
+ list(APPEND GMX_CUDA_NVCC_FLAGS "${CUDA_HOST_COMPILER_OPTIONS}")
+@@ -187,12 +269,18 @@
+     # CUDA header cuda_runtime_api.h in at least CUDA 10.1 uses 0
+     # where nullptr would be preferable. GROMACS can't fix these, so
+     # must suppress them.
+-    GMX_TEST_CXXFLAG(CXXFLAGS_NO_ZERO_AS_NULL_POINTER_CONSTANT "-Wno-zero-as-null-pointer-constant" NVCC_CLANG_SUPPRESSIONS_CXXFLAGS)
++    GMX_TEST_CXXFLAG(HAS_WARNING_NO_ZERO_AS_NULL_POINTER_CONSTANT "-Wno-zero-as-null-pointer-constant" NVCC_CLANG_SUPPRESSIONS_CXXFLAGS)
+ 
+     # CUDA header crt/math_functions.h in at least CUDA 10.x and 11.1
+     # used throw() specifications that are deprecated in more recent
+     # C++ versions. GROMACS can't fix these, so must suppress them.
+-    GMX_TEST_CXXFLAG(CXXFLAGS_NO_DEPRECATED_DYNAMIC_EXCEPTION_SPEC "-Wno-deprecated-dynamic-exception-spec" NVCC_CLANG_SUPPRESSIONS_CXXFLAGS)
++    GMX_TEST_CXXFLAG(HAS_WARNING_NO_DEPRECATED_DYNAMIC_EXCEPTION_SPEC "-Wno-deprecated-dynamic-exception-spec" NVCC_CLANG_SUPPRESSIONS_CXXFLAGS)
++
++    # CUDA headers cuda_runtime.h and channel_descriptor.h in at least
++    # CUDA 11.0 uses many C-style casts, which are ncessary for this
++    # header to work for C. GROMACS can't fix these, so must suppress
++    # the warnings they generate
++    GMX_TEST_CXXFLAG(HAS_WARNING_NO_OLD_STYLE_CAST "-Wno-old-style-cast" NVCC_CLANG_SUPPRESSIONS_CXXFLAGS)
+ 
+     # Add these flags to those used for the host compiler. The
+     # "-Xcompiler" prefix directs nvcc to only use them for host
+@@ -205,37 +293,6 @@
+ string(TOUPPER "${CMAKE_BUILD_TYPE}" _build_type)
+ gmx_check_if_changed(_cuda_nvcc_executable_or_flags_changed CUDA_NVCC_EXECUTABLE CUDA_NVCC_FLAGS CUDA_NVCC_FLAGS_${_build_type})
+ 
+-# We would like to be helpful and reject the host compiler with a
+-# clear error message at configure time, rather than let nvcc
+-# later reject the host compiler as not supported when the first
+-# CUDA source file is built. We've implemented that for current
+-# nvcc running on Unix-like systems, but e.g. changes to nvcc
+-# will further affect the limited portability of this checking
+-# code. Set the CMake variable GMX_NVCC_WORKS on if you want to
+-# bypass this check.
+-if((_cuda_nvcc_executable_or_flags_changed OR CUDA_HOST_COMPILER_CHANGED OR NOT GMX_NVCC_WORKS) AND NOT WIN32)
+-    message(STATUS "Check for working NVCC/C++ compiler combination with nvcc '${CUDA_NVCC_EXECUTABLE}'")
+-    execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} -ccbin ${CUDA_HOST_COMPILER} -c ${CUDA_NVCC_FLAGS} ${CUDA_NVCC_FLAGS_${_build_type}} ${CMAKE_SOURCE_DIR}/cmake/TestCUDA.cu
+-        RESULT_VARIABLE _cuda_test_res
+-        OUTPUT_VARIABLE _cuda_test_out
+-        ERROR_VARIABLE  _cuda_test_err
+-        OUTPUT_STRIP_TRAILING_WHITESPACE)
+-
+-    if(${_cuda_test_res})
+-        message(STATUS "Check for working NVCC/C compiler combination - broken")
+-        message(STATUS "${CUDA_NVCC_EXECUTABLE} standard output: '${_cuda_test_out}'")
+-        message(STATUS "${CUDA_NVCC_EXECUTABLE} standard error:  '${_cuda_test_err}'")
+-        if(${_cuda_test_err} MATCHES "nsupported")
+-            message(FATAL_ERROR "NVCC/C++ compiler combination does not seem to be supported. CUDA frequently does not support the latest versions of the host compiler, so you might want to try an earlier C++ compiler version and make sure your CUDA compiler and driver are as recent as possible.")
+-        else()
+-            message(FATAL_ERROR "CUDA compiler does not seem to be functional.")
+-        endif()
+-    elseif(NOT GMX_CUDA_TEST_COMPILER_QUIETLY)
+-        message(STATUS "Check for working NVCC/C++ compiler combination - works")
+-        set(GMX_NVCC_WORKS TRUE CACHE INTERNAL "Nvcc can compile a trivial test program")
+-    endif()
+-endif() # GMX_CHECK_NVCC
+-
+ 
+ # The flags are set as local variables which shadow the cache variables. The cache variables
+ # (can be set by the user) are appended. This is done in a macro to set the flags when all
diff --git a/sci-chemistry/gromacs/gromacs-2021.7.ebuild b/sci-chemistry/gromacs/gromacs-2021.7.ebuild
index 8cb244317617..1a6dbcab47f4 100644
--- a/sci-chemistry/gromacs/gromacs-2021.7.ebuild
+++ b/sci-chemistry/gromacs/gromacs-2021.7.ebuild
@@ -85,7 +85,10 @@ DOCS=( AUTHORS README )
 
 RESTRICT="!test? ( test )"
 
-PATCHES=( "${FILESDIR}/${PN}-2021-musl-stdint.patch" )
+PATCHES=(
+	"${FILESDIR}/${PN}-2021-musl-stdint.patch"
+	"${FILESDIR}/${PN}-2021-cuda-detection.patch"
+)
 
 if [[ ${PV} != *9999 ]]; then
 	S="${WORKDIR}/${PN}-${PV/_/-}"