Remove support for CUDA 11.0 and 11.1 and switch from Thrust to CCCL >= 2.3.2

- Does not remove all code/workarounds/checks related to 11.0 and 11.1, i.e. in case the previsouly compiler issues re-emerge
- Fixes some typos in nearby code
- CCCL >= 2.3.2 is required due for CMake and MSVC fixes in previous CCCL releases
- Removes known issues for CUDA <= 11.1 from the readme

Closes #1021

Author: ptheywood

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -48,7 +48,7 @@ body:
     attributes:
       label: CUDA Versions
       description: 
-      placeholder: e.g. CUDA 11.0, CUDA 12.2
+      placeholder: e.g. CUDA 11.2, CUDA 12.2
     validations:
       required: false
   - type: input

.github/workflows/Draft-Release.yml

@@ -194,7 +194,7 @@ jobs:
             cuda_arch: "35-real;90-real;90-virtual"
             hostcxx: "Visual Studio 16 2019"
             os: windows-2019
-          - cuda: "11.0.3"
+          - cuda: "11.2.2"
             cuda_arch: "35-real;80-real;80-virtual"
             hostcxx: "Visual Studio 16 2019"
             os: windows-2019

.github/workflows/Ubuntu.yml

@@ -64,7 +64,7 @@ jobs:
               cuda: "12.0"
             VISUALISATION: "ON"
           - cudacxx:
-              cuda: "11.0"
+              cuda: "11.2"
             VISUALISATION: "ON"
           # Exclude beltsoff builds for all but the most recent cuda
           - cudacxx:
@@ -76,7 +76,7 @@ jobs:
             config:
               name: "Beltsoff"
           - cudacxx:
-              cuda: "11.0"
+              cuda: "11.2"
             config:
               name: "Beltsoff"
           # Exclude beltsoff vis builds to keep the matrix lighter.

.github/workflows/Windows-Tests.yml

@@ -35,7 +35,7 @@ jobs:
             cuda_arch: "35"
             hostcxx: "Visual Studio 16 2019"
             os: windows-2019
-          - cuda: "11.0.3"
+          - cuda: "11.2.2"
             cuda_arch: "35"
             hostcxx: "Visual Studio 16 2019"
             os: windows-2019

.github/workflows/Windows.yml

@@ -41,7 +41,7 @@ jobs:
             cuda_arch: "35"
             hostcxx: "Visual Studio 16 2019"
             os: windows-2019
-          - cuda: "11.0.3"
+          - cuda: "11.2.2"
             cuda_arch: "35"
             hostcxx: "Visual Studio 16 2019"
             os: windows-2019
@@ -63,7 +63,7 @@ jobs:
               cuda: "12.0.0"
             VISUALISATION: "ON"
           - cudacxx:
-              cuda: "11.0.3"
+              cuda: "11.2.2"
             VISUALISATION: "ON"
           # Exclude beltsoff builds for all but the most recent cuda
           - cudacxx:
@@ -75,7 +75,7 @@ jobs:
             config:
               name: "Beltsoff"
           - cudacxx:
-              cuda: "11.0.3"
+              cuda: "11.2.2"
             config:
               name: "Beltsoff"
           # Exclude beltsoff vis builds to keep the matrix lighter.

CMakeLists.txt

@@ -49,22 +49,15 @@ if(CMAKE_CUDA_COMPILER)
     flamegpu_set_cuda_architectures()
 endif()
 
-# Set the minimum supported version of CUDA for FLAME GPU, currently 11.0
-set(MINIMUM_SUPPORTED_CUDA_VERSION 11.0)
-# Set the minimum, usable, but deprecated CUDA version. Currently there are no deprecated versions
-set(MINIMUM_CUDA_VERSION 11.0)
+# Set the minimum supported CUDA VERSION. 
+set(MINIMUM_SUPPORTED_CUDA_VERSION 11.2)
 
 # If the CUDA compiler is too old, trigger a docs only build.
-if(NOT DOCUMENTATION_ONLY_BUILD AND CMAKE_CUDA_COMPILER_VERSION VERSION_LESS ${MINIMUM_CUDA_VERSION})
+if(NOT DOCUMENTATION_ONLY_BUILD AND CMAKE_CUDA_COMPILER_VERSION VERSION_LESS ${MINIMUM_SUPPORTED_CUDA_VERSION})
     set(DOCUMENTATION_ONLY_BUILD ON)
     message(STATUS "Documentation-only build: CUDA ${MINIMUM_SUPPORTED_CUDA_VERSION} or greater is required for compilation.")
 endif()
 
-# If the CUDA compiler is atleast the minimum deprecated version, but less than the minimum actually supported version, issue a dev warning.
-if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL ${MINIMUM_CUDA_VERSION} AND CMAKE_CUDA_COMPILER_VERSION VERSION_LESS ${MINIMUM_SUPPORTED_CUDA_VERSION})
-    message(DEPRECATION "Support for CUDA verisons <= ${MINIMUM_SUPPORTED_CUDA_VERSION} is deprecated and will be removed in a future release.")
-endif()
-
 # If CUDA is not available, or the minimum version is too low only build the docs.
 if(DOCUMENTATION_ONLY_BUILD)
     # Not able to build code, so just make docs    
@@ -78,7 +71,7 @@ endif()
 # include for dependent modules
 include(CMakeDependentOption)
 
-# Option to enable building all examples, defaults to ON if FLAMEPGU is the top level cmake, else OFF
+# Option to enable building all examples, defaults to ON if FLAMEGPU is the top level cmake, else OFF
 cmake_dependent_option(FLAMEGPU_BUILD_ALL_EXAMPLES "Enable building all FLAMEGPU examples" ON "FLAMEGPU_PROJECT_IS_TOP_LEVEL" OFF)
 
 # Options to enable building individual examples, if FLAMEGPU_BUILD_ALL_EXAMPLES is off. 

README.md

@@ -63,7 +63,7 @@ Building FLAME GPU has the following requirements. There are also optional depen
 
 + [CMake](https://cmake.org/download/) `>= 3.18`
   + `>= 3.20` if building python bindings using a multi-config generator (Visual Studio, Eclipse or Ninja Multi-Config)
-+ [CUDA](https://developer.nvidia.com/cuda-downloads) `>= 11.0` and a [Compute Capability](https://developer.nvidia.com/cuda-gpus) `>= 3.5` NVIDIA GPU.
++ [CUDA](https://developer.nvidia.com/cuda-downloads) `>= 11.2` and a [Compute Capability](https://developer.nvidia.com/cuda-gpus) `>= 3.5` NVIDIA GPU.
 + C++17 capable C++ compiler (host), compatible with the installed CUDA version
   + [Microsoft Visual Studio 2019 or 2022](https://visualstudio.microsoft.com/) (Windows)
     + *Note:* Visual Studio must be installed before the CUDA toolkit is installed. See the [CUDA installation guide for Windows](https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html) for more information.
@@ -144,7 +144,7 @@ REM Alternatively, build from the command line specifying the build configuratio
 cmake --build . --config Release --target flamegpu boids_bruteforce --verbose
 ```
 
-On Windows, by default CMake will select the newest version of CUDA available when configuring. If you have multiple versions of CUDA installed then you can select an earlier installed CUDA version (e.g. CUDA 11.0) by additionally passing `-T cuda=11.0` when calling CMake configure (`cmake ..`).
+On Windows, by default CMake will select the newest version of CUDA available when configuring. If you have multiple versions of CUDA installed then you can select an earlier installed CUDA version (e.g. CUDA 11.2) by additionally passing `-T cuda=11.2` when calling CMake configure (`cmake ..`).
 
 #### Configuring and Building a single example
 
@@ -252,7 +252,7 @@ Several environmental variables are used or required by FLAME GPU 2.
 
 | Environment Variable                 | Description |
 |--------------------------------------|-------------|
-| `CUDA_PATH`                          | Required when using RunTime Compilation (RTC), pointing to the root of the CUDA Toolkit where NVRTC resides. <br /> i.e. `/usr/local/cuda-11.0/` or `C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v11.0`. <br /> Alternatively `CUDA_HOME` may be used if `CUDA_PATH` was not set. |
+| `CUDA_PATH`                          | Required when using RunTime Compilation (RTC), pointing to the root of the CUDA Toolkit where NVRTC resides. <br /> i.e. `/usr/local/cuda-11.2/` or `C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v11.2`. <br /> Alternatively `CUDA_HOME` may be used if `CUDA_PATH` was not set. |
 | `FLAMEGPU_INC_DIR`                   | When RTC compilation is required, if the location of the `include` directory cannot be found it must be specified using the `FLAMEGPU_INC_DIR` environment variable. |
 | `FLAMEGPU_TMP_DIR`                   | FLAME GPU may cache some files to a temporary directory on the system, using the temporary directory returned by [`std::filesystem::temp_directory_path`](https://en.cppreference.com/w/cpp/filesystem/temp_directory_path). The location can optionally be overridden using the `FLAMEGPU_TMP_DIR` environment variable. |
 | `FLAMEGPU_RTC_INCLUDE_DIRS`          | A list of include directories that should be provided to the RTC compiler, these should be separated using `;` (Windows) or `:` (Linux). If this variable is not found, the working directory will be used as a default. |
@@ -372,8 +372,5 @@ For a full list of known issues pleases see the [Issue Tracker](https://github.c
 
 + Warnings and a loss of performance due to hash collisions in device code ([#356](https://github.com/FLAMEGPU/FLAMEGPU2/issues/356))
 + Multiple known areas where performance can be improved (e.g. [#449](https://github.com/FLAMEGPU/FLAMEGPU2/issues/449), [#402](https://github.com/FLAMEGPU/FLAMEGPU2/issues/402))
-+ Windows/MSVC builds using CUDA 11.0 may encounter errors when performing incremental builds if the static library has been recompiled. If this presents itself, re-save any `.cu` file in your executable producing project and re-trigger the build.
-+ Debug builds under linux with CUDA 11.0 may encounter cuda errors during `validateIDCollisions`. Consider using an alternate CUDA version if this is required ([#569](https://github.com/FLAMEGPU/FLAMEGPU2/issues/569)).
-+ CUDA 11.0 with GCC 9 may encounter a segmentation fault during compilation of the test suite. Consider using GCC 8 with CUDA 11.0.
 + CUDA 12.2+ suffers from poor RTC compilation times, to be fixed in a future release ([#1118](https://github.com/FLAMEGPU/FLAMEGPU2/issues/1118)).
 + Wrapped spatial message iteration with may incorrectly report that the radius is not a factor of the environment with `FLAMEGPU_SEATBELTS=ON` for certain floating point values, to be fixed in a future release ([#1177](https://github.com/FLAMEGPU/FLAMEGPU2/issues/1177)).

cmake/CUDAArchitectures.cmake

@@ -215,7 +215,7 @@ function(flamegpu_set_cuda_architectures)
                 endif()
                 message(AUTHOR_WARNING
                     "  ${CMAKE_CURRENT_FUNCTION} failed to parse NVCC --help output for default architecture generation\n"
-                    "  Using ${default_archs} based on CUDA 11.0 to 11.8."
+                    "  Using ${default_archs} based on CUDA 11.2 to 11.8."
                 )
             endif()
             # We actually want real for each arch, then virtual for the final, but only for library-provided values, to only embed one arch worth of ptx.

cmake/common.cmake

@@ -28,7 +28,7 @@ endif()
 
 # Ensure that other dependencies are downloaded and available. 
 # As flamegpu is a static library, linking only only occurs at consumption not generation, so dependent targets must also know of PRIVATE shared library dependencies such as tinyxml2 and rapidjson, as well any intentionally public dependencies (for include dirs)
-include(${CMAKE_CURRENT_LIST_DIR}/dependencies/Thrust.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/dependencies/CCCL.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/dependencies/Jitify.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/dependencies/Tinyxml2.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/dependencies/rapidjson.cmake)
@@ -134,22 +134,14 @@ if(FLAMEGPU_ENABLE_NVTX)
     endif()
 endif(FLAMEGPU_ENABLE_NVTX)
 
-# Set the minimum supported cuda version, if not already set. Currently duplicated due to docs only build logic.
-# CUDA 11.0 is current minimum cuda version, and the minimum supported
-if(NOT DEFINED MINIMUM_CUDA_VERSION)
-    set(MINIMUM_CUDA_VERSION 11.0)
-    # Require a minimum cuda version
-    if(CMAKE_CUDA_COMPILER_VERSION VERSION_LESS ${MINIMUM_CUDA_VERSION})
-        message(FATAL_ERROR "CUDA version must be at least ${MINIMUM_CUDA_VERSION}")
-    endif()
-endif()
-# CUDA 11.0 is the current minimum supported version.
+# Set the minimum supported cuda version, if not already set.
+# Currently duplicated due to docs only build logic.
+# CUDA 11.2 is the current minimum supported version.
 if(NOT DEFINED MINIMUM_SUPPORTED_CUDA_VERSION)
-    set(MINIMUM_SUPPORTED_CUDA_VERSION 11.0)
-    # Warn on deprecated cuda version.
-    # If the CUDA compiler is atleast the minimum deprecated version, but less than the minimum actually supported version, issue a dev warning.
-    if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL ${MINIMUM_CUDA_VERSION} AND CMAKE_CUDA_COMPILER_VERSION VERSION_LESS ${MINIMUM_SUPPORTED_CUDA_VERSION})
-        message(DEPRECATION "Support for CUDA verisons <= ${MINIMUM_SUPPORTED_CUDA_VERSION} is deprecated and will be removed in a future release.")
+    set(MINIMUM_SUPPORTED_CUDA_VERSION 11.2)
+    # Require a minimum cuda version
+    if(CMAKE_CUDA_COMPILER_VERSION VERSION_LESS ${MINIMUM_SUPPORTED_CUDA_VERSION})
+        message(FATAL_ERROR "CUDA version must be at least ${MINIMUM_SUPPORTED_CUDA_VERSION}")
     endif()
 endif()
 

cmake/dependencies/CCCL.cmake

@@ -0,0 +1,75 @@
+###################################
+# CCCL (Thrust, CUB and libcucxx) #
+###################################
+
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/modules/ ${CMAKE_MODULE_PATH})
+
+include(FetchContent)
+cmake_policy(SET CMP0079 NEW)
+# Temporary CMake >= 3.30 fix https://github.com/FLAMEGPU/FLAMEGPU2/issues/1223
+if(POLICY CMP0169)
+    cmake_policy(SET CMP0169 OLD)
+endif()
+
+# Set the minimum supported CCCL version, and the version to fetch
+# using find_package(version) means it's up to CCCL's cmake to determine if newer versions are compatible, but this will likely need changing for CUDA 13, when CCCL is planned to have a major version bump (and drop CUDA 11 support).
+set(MIN_REQUIRED_CCCL_VERSION 2.3.2)
+set(CCCL_DOWNLOAD_TAG v2.3.2)
+
+# Use the FindCUDATooklit package (CMake > 3.17) to get the CUDA version and CUDA include directories for cub/thrust location hints
+find_package(CUDAToolkit REQUIRED)
+
+# Quietly find CCCL, to check if the version included with CUDA (if CCCL) is sufficiently new.
+# Using CCCL avoids complex cub/thrust version workarounds previously required.
+# However we cannot find thrust due to a missing guard in CCCL's cmake config file, and cannot find cub without finding libcudacxx, so just find libcudacxx quietly.
+# The fix for this was first included in the 2.3.2 release
+find_package(CCCL ${MIN_REQUIRED_CCCL_VERSION} QUIET COMPONENTS libcudacxx CONFIG HINTS ${CUDAToolkit_INCLUDE_DIRS} ${CUDAToolkit_LIBRARY_DIR}/cmake)
+
+# If CCCL was found, find it again but loudly (with all components)
+if(CCCL_FOUND)
+    # Find the packages again but less quietly (and include all components)
+    find_package(CCCL ${MIN_REQUIRED_CCCL_VERSION} REQUIRED CONFIG COMPONENTS HINTS ${CUDAToolkit_INCLUDE_DIRS} ${CUDAToolkit_LIBRARY_DIR}/cmake)
+# If CCCL does need downloading, fetch it and find it (no need to add_subdirectory)
+else()
+    # Declare information about where and what we want from thrust.
+    FetchContent_Declare(
+        cccl
+        GIT_REPOSITORY https://github.com/NVIDIA/CCCL.git
+        GIT_TAG        ${CCCL_DOWNLOAD_TAG}
+        GIT_SHALLOW    0 # @todo - set this back to 1.
+        GIT_PROGRESS   ON
+        # UPDATE_DISCONNECTED   ON
+    )
+    # Fetch and populate the content if required.
+    FetchContent_GetProperties(cccl)
+    if(NOT cccl_POPULATED)
+        message(STATUS "Fetching CCCL ${CCCL_DOWNLOAD_TAG}")
+        FetchContent_Populate(cccl)
+        # Use find_package for CCLL, only looking for the fetched version.
+        # This creates a non-system target due to nvcc magic to avoid the cuda toolkit version being used instead, so warnings are not suppressible without push/pop macros.
+        find_package(CCCL REQUIRED CONFIG
+            PATHS "${cccl_SOURCE_DIR}"
+            NO_CMAKE_PATH
+            NO_CMAKE_ENVIRONMENT_PATH
+            NO_SYSTEM_ENVIRONMENT_PATH
+            NO_CMAKE_PACKAGE_REGISTRY
+            NO_CMAKE_SYSTEM_PATH)
+    endif()
+    # Mark some CACHE vars as advanced for a cleaner CMake GUI
+    mark_as_advanced(FETCHCONTENT_QUIET)
+    mark_as_advanced(FETCHCONTENT_BASE_DIR)
+    mark_as_advanced(FETCHCONTENT_FULLY_DISCONNECTED)
+    mark_as_advanced(FETCHCONTENT_UPDATES_DISCONNECTED)
+    mark_as_advanced(FETCHCONTENT_SOURCE_DIR_CCCL)
+    mark_as_advanced(FETCHCONTENT_UPDATES_DISCONNECTED_CCCL)
+endif()
+
+# Unset temporary variables
+unset(MIN_REQUIRED_CCCL_VERSION)
+unset(CCCL_DOWNLOAD_TAG)
+
+# Mark some CACHE vars as advanced for a cleaner CMake GUI
+mark_as_advanced(CCCL_DIR)
+mark_as_advanced(CUB_DIR)
+mark_as_advanced(Thrust_DIR)
+mark_as_advanced(libcudacxx_DIR)