compile_time: pull_request: - id: public-headers-gcc13 name: Public headers compile-time bench gpu: rtx2080 launch_args: "--cuda 13.3 --host gcc13" baseline_ref: origin/main preset: all-dev targets: - cub.headers.base - thrust.cpp.cuda.headers.base - libcudacxx.test.public_headers args: "-arch native" slices: - id: total-compilation title: TU total compilation filter: total-compilation timing: inclusive sort: total top: 15 threshold: 3.0 - id: file-processing title: Direct file processing filter: file-processing timing: exclusive sort: total top: 15 threshold: 0.2 - id: function-bodies title: Function-body parsing filter: scanning-function-body timing: inclusive sort: total top: 15 threshold: 0.25 - id: template-instantiation title: Template instantiation filter: template-instantiation timing: inclusive sort: total top: 15 threshold: 0.2 workflows: # If any jobs appear here, they will be executed instead of `pull_request' for PRs. # This is useful for limiting resource usage when a full matrix is not needed. # The branch protection checks will fail when using this override workflow. # # Example: # override: # # Full project build: slow, expensive # - { jobs: ['test'], project: 'thrust', std: 17, ctk: '12.X', cxx: ['gcc12', 'clang16'] } # # # Build / run targeted tests: faster turnaround, less runner usage. # # Use project 'target'. # # args are passed to ci/util/build_and_test_targets.sh. See that script for available options. # - { jobs: ['run_cpu'], project: 'target', ctk: ['12.X', '13.X'], cxx: ['gcc', 'clang', 'msvc'], # args: '--preset cub-cpp20 --build-targets "cub.cpp20.test.iterator"' } # - { jobs: ['run_gpu'], project: 'target', ctk: ['12.X', '13.X'], cxx: ['gcc', 'clang'], gpu: 'rtxa6000', # args: '--preset cub-cpp20 --build-targets "cub.cpp20.test.iterator" --ctest-targets "cub.cpp20.test.iterator"' } # - { jobs: ['run_cpu'], project: 'target', ctk: ['12.X', '13.X'], cxx: ['gcc', 'clang', 'msvc'], # args: '--preset libcudacxx --lit-precompile-tests "cuda/utility/basic_any.pass.cpp"' } # - { jobs: ['run_gpu'], project: 'target', ctk: ['12.X', '13.X'], cxx: ['gcc', 'clang'], gpu: 'rtx2080', # args: '--preset libcudacxx --lit-tests "cuda/utility/basic_any.pass.cpp"' } # # IMPORTANT: Do NOT delete or remove the `override:` key below, even when it is empty. override: pull_request: # Old CTK: Oldest/newest supported host compilers: - {jobs: ['build'], std: 'minmax', ctk: '12.0', cxx: ['gcc12', 'clang14', 'msvc2019', 'msvc14.39']} - {jobs: ['build'], project: ['libcudacxx', 'thrust'], std: 'minmax', ctk: '12.0', cxx: 'gcc7'} - {jobs: ['build_nolid', 'build_lid1', 'build_lid2'], project: 'cub', std: 'minmax', ctk: '12.0', cxx: 'gcc7'} # CTK12.0/GCC7 CUB host-launch builds are memory-heavy with benchmarks enabled; keep this shard below # the 61 GiB linux-amd64-cpu16 runner limit. - {jobs: ['build_lid0'], project: 'cub', std: 'minmax', ctk: '12.0', cxx: 'gcc7', environment: ['PARALLEL_LEVEL=8']} - {jobs: ['build'], std: 'minmax', ctk: '12.X', cxx: ['gcc7', 'gcc14', 'clang14', 'clang19', 'msvc2019', 'msvc2022' ]} - {jobs: ['build'], std: 'minmax', ctk: '13.0', cxx: ['gcc11', 'gcc15', 'clang15', 'clang20', 'msvc2019', 'msvc2022' ]} # Old CTK: cudax has a different support matrix: - {jobs: ['build'], project: 'cudax', ctk: '12.0', std: 'minmax', cxx: ['gcc9', 'gcc12', 'clang14', 'msvc14.39']} - {jobs: ['build'], project: 'cudax', ctk: '12.X', std: 'minmax', cxx: ['gcc9', 'gcc14', 'clang14', 'clang19', 'msvc2022']} - {jobs: ['build'], project: 'cudax', ctk: '13.0', std: 'minmax', cxx: ['gcc11', 'gcc15', 'clang15', 'clang20', 'msvc2022']} # Current CTK build-only: - {jobs: ['build'], std: 'minmax', cxx: ['gcc11', 'clang15', 'msvc2019'] } # Oldest - {jobs: ['build'], std: 'max', cxx: ['gcc12', 'gcc13', 'gcc14'] } - {jobs: ['build'], std: 'max', cxx: ['clang16', 'clang17', 'clang18', 'clang19', 'clang20'] } - {jobs: ['build'], std: 'max', cxx: ['msvc2022'] } - {jobs: ['build'], std: 'all', cxx: ['gcc', 'clang', 'msvc']} # Latest # Current CTK build-only: cudax has a different support matrix: - {jobs: ['build'], project: 'cudax', std: 'minmax', cxx: ['gcc11', 'clang15', 'msvc2022']} # Oldest - {jobs: ['build'], project: 'cudax', std: 'max', cxx: ['gcc12']} - {jobs: ['build'], project: 'cudax', std: 'max', cxx: ['clang16', 'clang17', 'clang18', 'clang19', 'clang20']} - {jobs: ['build'], project: 'cudax', std: 'all', cxx: ['gcc', 'clang', 'msvc']} # Newest # Current CTK testing: - {jobs: ['test'], project: 'thrust', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx4090'} - {jobs: ['test'], project: ['libcudacxx', 'cudax'], std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 't4'} - {jobs: ['test_nolid', 'test_lid0'], project: 'cub', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtxa6000'} - {jobs: ['test_lid1', 'test_lid2'], project: 'cub', std: 'max', cxx: ['gcc'], gpu: 'rtxa6000'} # H100 coverage: - {jobs: ['test_nolid', 'test_lid0'], project: 'cub', std: 'max', gpu: 'h100' } - {jobs: ['test_gpu'], project: 'thrust', std: 'max', gpu: 'h100' } - {jobs: ['test'], project: ['libcudacxx', 'cudax'], std: 'max', gpu: 'h100' } # Multi-GPU coverage: - {jobs: ['test'], project: ['libcudacxx', 'cudax'], std: 'max', gpu: 'h100_2gpu', sm: 'gpu'} # RTX PRO 6000 coverage (limited due to small number of runners): - {jobs: ['test_lid0'], project: 'cub', std: 'max', cxx: 'gcc', gpu: 'rtxpro6000'} # Misc: - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'max', cxx: ['gcc', 'clang']} - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force32bit', gpu: 'rtx4090'} - {jobs: ['nvrtc'], project: 'libcudacxx', std: 'all', gpu: 'rtx2080', sm: 'gpu'} - {jobs: ['verify_codegen'], project: 'libcudacxx'} # c.parallel -- pinned to gcc13 / msvc2022 to match python - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '12.X', cxx: ['gcc13', 'msvc2022'], gpu: ['t4']} - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '13.X', cxx: ['gcc13', 'msvc2022'], gpu: ['rtx2080', 'l4', 'h100']} # RTX PRO 6000 coverage (limited due to small number of runners): - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '13.X', cxx: ['gcc13'], gpu: ['rtxpro6000']} # c.parallel v2 (HostJIT-based) # # For now, this is a separate job run for Linux/CUDA13. # Eventually v2 will replace v1 as the default and run across the # entire matrix. Currently blocked on libnvfatbin availability on # Windows containers, and for CUDA <12.4. - {jobs: ['test'], project: 'cccl_c_parallel_v2', ctk: '13.X', cxx: ['gcc13', 'msvc'], gpu: 'rtx2080'} # Python against c.parallel v2 (HostJIT-based). Single point of coverage # for the v2 Python path; the main `python` matrix continues to test # against v1 until v2 replaces it. - {jobs: ['test'], project: 'python_v2', ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'} - {jobs: ['test_py_compute_minimal'], project: 'python_v2', ctk: '13.X', py_version: '3.14t', gpu: 'l4', cxx: 'gcc13'} # c.experimental.stf-- pinned to gcc13 to match python - {jobs: ['test'], project: 'cccl_c_stf', ctk: ['12.X', '13.X'], cxx: 'gcc13', gpu: 't4'} - {jobs: ['test'], project: 'cccl_c_stf', ctk: '13.X', cxx: 'gcc13', gpu: ['l4', 'h100']} # Python -- pinned to gcc13 / msvc2022 for consistency across CTK images - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: ['3.10'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X','13.0', '13.X'], py_version: '3.14', gpu: 'l4', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test'], project: 'python', py_version: '3.14', gpu: 'h100', cxx: 'gcc13'} - {jobs: ['test'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: ['t4', 'rtxa6000', 'rtxpro6000'], cxx: 'gcc13'} - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'} - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test_py_compute_minimal'], project: 'python_tsan', ctk: '13.X', py_version: '3.14t', gpu: 'l4', cxx: 'gcc13'} # Deliberately unpinned: py_ctk_mode 'latest' skips the CTK pin so pip # resolves the latest minor -- catching breakage a plain `pip install # cuda-cccl[cu12]/[cu13]` would hit before the container CTK bumps. - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'latest'} # sysctk: install the sysctk extras (system-provided CTK, no pip cuda-toolkit) # rather than cu*. # Full test on 3.14, minimal (numba-free) on 3.14t; all CTKs, Linux+Windows. - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'} - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'} # cuda.cccl.headers: CPU-only (gpu:false), arch-insensitive - {jobs: ['test_headers'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: ['pinned', 'latest', 'sysctk']} # CCCL packaging: - {jobs: ['test'], project: 'packaging', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 't4', args: '-min-cmake'} - {jobs: ['test'], project: 'packaging', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 't4'} - {jobs: ['test'], project: 'packaging', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 't4', args: '-min-cmake'} - {jobs: ['test'], project: 'packaging', ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 't4'} - {jobs: ['install'], project: 'packaging'} # NVBench Helper testing: - {jobs: ['test'], project: 'nvbench_helper', ctk: ['12.0', '12.X'], cxx: ['gcc10', 'clang14'], gpu: 't4'} - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 't4'} - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 't4'} # NVHPC build - {jobs: ['build'], cxx: 'nvhpc', ctk: 'nvhpc', std: 'max', project: ['libcudacxx', 'thrust', 'stdpar'], cpu: 'amd64'} - {jobs: ['build_nolid'], cxx: 'nvhpc', ctk: 'nvhpc', std: 'max', project: 'cub', cpu: 'amd64'} # clang-cuda - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', std: 'all', sm: '75;80;90;100;120'} - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', std: 23, sm: '75;80;90;100;120'} # libc++ # - arm64 for now as it's closest to android. # - {jobs: ['build'], cpu: 'arm64', project: 'libcudacxx', std: 'all', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', cmake_options: '-DCCCL_USE_LIBCXX=ON', sm: '75;80;90;100;120'} # clang-tidy # # The precise value of sm is not important, but it is required for cmake to identify # clang as a CUDA compiler (see # https://discourse.cmake.org/t/cmake-cuda-clang-fails/8657/5). # # Standard being exactly "min" is required. clang-tidy may emit additional diagnostics # for later C++ versions (for example, warning that you should use designated # initializers in C++20 or higher). - { jobs: ['build'], project: 'tidy', std: 'min', cxx: ['clang'], cudacxx: ['clang'], ctk: 'clang-cuda', sm: '75' } # Used when an upstream project changes to reduce time spent smoke testing dependencies. pull_request_lite: # libcudacxx - Specialized, testing default SM - {project: 'libcudacxx', jobs: ['test'], std: 'max', cxx: ['gcc', 'msvc'], gpu: 'rtx2080', sm: 'gpu'} - {project: 'libcudacxx', jobs: ['build'], std: 'max', cxx: 'clang'} - {project: 'libcudacxx', jobs: ['build'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc'} - {project: 'libcudacxx', jobs: ['build'], std: 'max', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', sm: '70;80;90;100;120'} - {project: 'libcudacxx', jobs: ['nvrtc'], std: 'max', gpu: 't4', sm: 'gpu'} - {project: 'libcudacxx', jobs: ['verify_codegen']} # CUB - Specialized, testing default SM - {project: 'cub', jobs: ['test_nolid', 'test_lid0'], std: 'max', cxx: ['gcc', 'msvc'], gpu: 'rtxa6000', sm: 'gpu'} - {project: 'cub', jobs: ['build_nolid', 'build_lid0'], std: 'max', cxx: 'clang'} - {project: 'cub', jobs: ['build_nolid', 'build_lid0'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc'} - {project: 'cub', jobs: ['build_nolid', 'build_lid0'], std: 'max', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', sm: '75;80;90;100;120'} # Thrust - Keep number of sm small. Kernel coverage is in CUB. This just tests dispatch / glue in lite mode: - {project: 'thrust', jobs: ['test'], std: 'max', cxx: ['gcc', 'msvc'], gpu: 'rtx4090', sm: 'gpu'} - {project: 'thrust', jobs: ['build'], std: 'max', cxx: 'clang', sm: '75;120'} - {project: 'thrust', jobs: ['build'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc', sm: '75;120'} - {project: 'thrust', jobs: ['build'], std: 'max', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', sm: '75;120'} # cudax - {project: 'cudax', jobs: ['test'], std: 'max', cxx: ['gcc', 'msvc'], gpu: 'rtx2080', sm: 'gpu'} - {project: 'cudax', jobs: ['build'], std: 'max', cxx: 'clang', sm: '75;120'} - {project: 'cudax', jobs: ['build'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc', sm: '75;120'} # stdpar - {project: 'stdpar', jobs: ['build'], std: 'max', ctk: 'nvhpc', cxx: 'nvhpc'} # Python + support - {project: 'cccl_c_parallel', jobs: ['test'], ctk: '13.X', cxx: ['gcc13', 'msvc2022'], gpu: 'rtx2080', sm: 'gpu'} - {project: 'cccl_c_parallel', jobs: ['test'], ctk: '13.X', cxx: 'gcc13', gpu: 'rtxpro6000', sm: 'gpu'} - {project: 'cccl_c_stf', jobs: ['test'], ctk: '13.X', cxx: 'gcc13', gpu: 't4', sm: 'gpu'} - {project: 'python', jobs: ['test'], ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: ['gcc13', 'msvc2022']} - {project: 'python', jobs: ['test_headers'], ctk: '13.X', py_version: '3.14', cxx: ['gcc13', 'msvc2022']} # Packaging / install - {project: 'packaging', jobs: ['test'], ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 'rtx2080', sm: 'gpu'} - {project: 'packaging', jobs: ['test'], args: '-min-cmake', gpu: 't4', sm: 'gpu'} - {project: 'packaging', jobs: ['install']} # NVBench Helper testing: - {project: 'nvbench_helper', jobs: ['test'], ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 'rtx2080'} # c.parallel v2 (HostJIT-based) - {jobs: ['test'], project: 'cccl_c_parallel_v2', ctk: '13.X', cxx: ['gcc13'], gpu: 'rtx2080'} # Python against c.parallel v2 (HostJIT-based) - {jobs: ['test'], project: 'python_v2', ctk: '13.X', py_version: '3.14', gpu: 'l4', cxx: 'gcc13'} nightly: # CTK 12.0 full matrix build: default projects - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10', 'gcc11', 'gcc12']} - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['clang14']} - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['msvc2019', 'msvc14.39']} # CTK 12.X full matrix build: default projects - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10', 'gcc11', 'gcc12', 'gcc13', 'gcc14']} - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['clang14', 'clang15', 'clang16', 'clang17', 'clang18', 'clang19']} - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['msvc2019', 'msvc2022']} # CTK 13.0 full matrix build: default projects - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']} - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20']} - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['msvc2019', 'msvc2022']} # CTK '13.X' full matrix build: default projects - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']} - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21']} - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['msvc2019', 'msvc2022', 'msvc2026']} # CTK 12.0 full matrix build: cudax - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['gcc9', 'gcc10', 'gcc11', 'gcc12']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['clang14']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['msvc14.39']} # CTK 12.X full matrix build: cudax - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['gcc9', 'gcc10', 'gcc11', 'gcc12', 'gcc13', 'gcc14']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['clang14', 'clang15', 'clang16', 'clang17', 'clang18', 'clang19']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['msvc2022']} # CTK 13.0 full matrix build: cudax - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['msvc2022']} # CTK '13.X' full matrix build: cudax - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['msvc2022', 'msvc2026']} # CTK 12.X testing: - {jobs: ['test'], project: 'libcudacxx', ctk: '12.X', std: 'max', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 't4'} - {jobs: ['test'], project: 'cub', ctk: '12.X', std: 'max', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtxa6000'} - {jobs: ['test'], project: 'thrust', ctk: '12.X', std: 'max', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtx4090'} - {jobs: ['test'], project: 'cudax', ctk: '12.X', std: 'max', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtx2080'} - {jobs: ['test'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '12.X', std: 'max', cxx: 'gcc14', gpu: 'h100' } # CTK '13.X' testing: - {jobs: ['test'], project: 'libcudacxx', ctk: '13.X', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx2080'} - {jobs: ['test'], project: 'cub', ctk: '13.X', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtxa6000'} - {jobs: ['test'], project: 'thrust', ctk: '13.X', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx4090'} - {jobs: ['test'], project: 'cudax', ctk: '13.X', std: 'max', cxx: ['gcc', 'clang', 'msvc'], gpu: 't4'} - {jobs: ['test'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: 'max', gpu: 'h100' } # RTX PRO 6000 coverage (limited due to small number of runners): - {jobs: ['test_nolid', 'test_lid0'], project: ['cub', 'thrust'], std: 'max', cxx: 'gcc', gpu: 'rtxpro6000'} # Misc: - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '12.X', std: 'all', cxx: ['gcc14', 'clang19']} - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: 'all', cxx: ['gcc', 'clang']} - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force32bit', gpu: 'rtx4090'} - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force64bit', gpu: 'rtx4090'} - {jobs: ['limited'], project: 'cub', std: 17, gpu: 'rtx2080'} # NVRTC tests don't currently support 12.0: - {jobs: ['nvrtc'], project: 'libcudacxx', ctk: [ '12.X', '13.0', '13.X'], cxx: 'gcc12', std: 'all', gpu: 'rtx2080', sm: 'gpu'} - {jobs: ['verify_codegen'], project: 'libcudacxx'} # c.parallel -- pinned to gcc13 / msvc2022 to match python - {jobs: ['test'], project: ['cccl_c_parallel'], ctk: '12.X', cxx: ['gcc13', 'msvc2022'], gpu: ['t4']} - {jobs: ['test'], project: ['cccl_c_parallel'], ctk: '13.X', cxx: ['gcc13', 'msvc2022'], gpu: ['rtx2080', 'l4', 'h100']} # RTX PRO 6000 coverage (limited due to small number of runners): - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '13.X', cxx: ['gcc13'], gpu: ['rtxpro6000']} # c.experimental.stf -- pinned to gcc13 to match python - {jobs: ['test'], project: ['cccl_c_stf'], ctk: '12.X', cxx: 'gcc13', gpu: ['rtx2080']} - {jobs: ['test'], project: ['cccl_c_stf'], ctk: '13.X', cxx: 'gcc13', gpu: ['t4', 'l4', 'h100']} # Python -- pinned to gcc13 / msvc2022 on Linux for consistency across CTK images - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.11', '3.12', '3.13', '3.14'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'h100', cxx: 'gcc13'} - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: ['t4', 'rtxa6000'], cxx: 'gcc13'} - {jobs: ['test'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: 'rtxpro6000', cxx: 'gcc13'} # Python free-threaded (3.14t) minimal lanes -- mirrors the pull_request rows # so FT regressions (e.g. from dependency bumps) surface between PRs. - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test_py_compute_minimal'], project: 'python_v2', ctk: '13.X', py_version: '3.14t', gpu: 'l4', cxx: 'gcc13'} - {jobs: ['test_py_compute_minimal'], project: 'python_tsan', ctk: '13.X', py_version: '3.14t', gpu: 'l4', cxx: 'gcc13'} - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'} - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'} # cuda.cccl.headers (CPU-only): all CTK x source x OS, py endpoints 3.10 + 3.14 - {jobs: ['test_headers'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.14'], cxx: ['gcc13', 'msvc2022'], py_ctk_mode: ['pinned', 'latest', 'sysctk']} # CCCL packaging: - {jobs: ['test'], project: 'packaging', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 't4', args: '-min-cmake'} - {jobs: ['test'], project: 'packaging', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 'rtx2080'} - {jobs: ['test'], project: 'packaging', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 't4', args: '-min-cmake'} - {jobs: ['test'], project: 'packaging', ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 'rtx2080'} - {jobs: ['install'], project: 'packaging'} # NVBench Helper testing: - {jobs: ['test'], project: 'nvbench_helper', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 'rtx2080'} - {jobs: ['test'], project: 'nvbench_helper', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 't4'} - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 'rtx2080'} - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 't4'} # NVHPC build - {jobs: ['build'], cxx: 'nvhpc-prev', ctk: 'nvhpc-prev', std: 'all', project: ['libcudacxx', 'cub', 'thrust', 'cudax', 'stdpar'], cpu: ['amd64', 'arm64']} - {jobs: ['build'], cxx: 'nvhpc', ctk: 'nvhpc', std: 'all', project: ['libcudacxx', 'cub', 'thrust', 'cudax', 'stdpar'], cpu: ['amd64', 'arm64']} # clang-cuda - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', std: 'all', sm: '75;80;90;100;120'} - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang_preview-cuda', cxx: 'clang_preview-cuda', std: 'all', sm: '75;80;90;100;120'} - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', std: 23, sm: '75;80;90;100;120'} - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang_preview-cuda', cxx: 'clang_preview-cuda', std: 23, sm: '75;80;90;100;120'} # clang-tidy - { jobs: ['build'], project: 'tidy', std: 'min', cxx: ['clang'], cudacxx: ['clang'], ctk: 'clang-cuda', sm: '75' } # arch-specific and family-specific arch builds - {jobs: ['build'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'all', sm: '90a;100a;103a;110a;120a;121a'} - {jobs: ['build'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'all', sm: '100f;103f;110f;120f;121f'} weekly: # CTK 12.0 full matrix build: default projects - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10', 'gcc11', 'gcc12']} - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['clang14']} - {jobs: ['build'], std: 'all', ctk: '12.0', cxx: ['msvc2019', 'msvc14.39']} # CTK 12.X full matrix build: default projects - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10', 'gcc11', 'gcc12', 'gcc13', 'gcc14']} - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['clang14', 'clang15', 'clang16', 'clang17', 'clang18', 'clang19']} - {jobs: ['build'], std: 'all', ctk: '12.X', cxx: ['msvc2019', 'msvc2022']} # CTK 13.0 full matrix build: default projects - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']} - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20']} - {jobs: ['build'], std: 'all', ctk: '13.0', cxx: ['msvc2019', 'msvc2022']} # CTK '13.X' full matrix build: default projects - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']} - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21']} - {jobs: ['build'], std: 'all', ctk: '13.X', cxx: ['msvc2019', 'msvc2022', 'msvc2026']} # CTK 12.0 full matrix build: cudax - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['gcc9', 'gcc10', 'gcc11', 'gcc12']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['clang14']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.0', cxx: ['msvc14.39']} # CTK 12.X full matrix build: cudax - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['gcc9', 'gcc10', 'gcc11', 'gcc12', 'gcc13', 'gcc14']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['clang14', 'clang15', 'clang16', 'clang17', 'clang18', 'clang19']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '12.X', cxx: ['msvc2022']} # CTK 13.0 full matrix build: cudax - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.0', cxx: ['msvc2022']} # CTK '13.X' full matrix build: cudax - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['gcc11', 'gcc12', 'gcc13', 'gcc14', 'gcc15']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19', 'clang20', 'clang21']} - {jobs: ['build'], project: 'cudax', std: 'all', ctk: '13.X', cxx: ['msvc2022', 'msvc2026']} # CTK 12.X testing: - {jobs: ['test'], project: 'libcudacxx', ctk: '12.X', std: 'minmax', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtx2080'} - {jobs: ['test'], project: 'cub', ctk: '12.X', std: 'minmax', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtxa6000'} - {jobs: ['test'], project: 'thrust', ctk: '12.X', std: 'minmax', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 'rtx4090'} - {jobs: ['test'], project: 'cudax', ctk: '12.X', std: 'minmax', cxx: ['gcc14', 'clang19', 'msvc2022'], gpu: 't4'} - {jobs: ['test'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '12.X', std: 'minmax', cxx: 'gcc14', gpu: 'h100' } # CTK '13.X' testing: - {jobs: ['test'], project: 'libcudacxx', ctk: '13.X', std: 'minmax', cxx: ['gcc', 'clang', 'msvc'], gpu: 't4'} - {jobs: ['test'], project: 'cub', ctk: '13.X', std: 'minmax', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtxa6000'} - {jobs: ['test'], project: 'thrust', ctk: '13.X', std: 'minmax', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx4090'} - {jobs: ['test'], project: 'cudax', ctk: '13.X', std: 'minmax', cxx: ['gcc', 'clang', 'msvc'], gpu: 'rtx2080'} - {jobs: ['test'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: 'minmax', gpu: 'h100' } # RTX PRO 6000 coverage (limited due to small number of runners): - {jobs: ['test'], project: ['cub', 'thrust'], std: 'max', cxx: 'gcc', gpu: 'rtxpro6000'} # Misc: - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '12.X', std: 'all', cxx: ['gcc14', 'clang19']} - {jobs: ['build'], cpu: 'arm64', project: ['libcudacxx', 'cub', 'thrust', 'cudax'], ctk: '13.X', std: 'all', cxx: ['gcc', 'clang']} - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force32bit', gpu: 'rtx4090'} - {jobs: ['test_gpu'], project: 'thrust', cmake_options: '-DTHRUST_DISPATCH_TYPE=Force64bit', gpu: 'rtx4090'} - {jobs: ['limited'], project: 'cub', std: 17, gpu: 'rtx2080'} # sm: all-cccl: - {jobs: ['build'], project: ['thrust', 'libcudacxx', 'cudax'], std: 'max', sm: 'all-cccl' } - {jobs: ['build_nolid', 'build_lid0'], project: ['cub'], std: 'max', sm: 'all-cccl'} # NVRTC tests don't currently support 12.0: - {jobs: ['nvrtc'], project: 'libcudacxx', ctk: [ '12.X', '13.0', '13.X'], cxx: 'gcc12', std: 'all', gpu: 'rtx2080', sm: 'gpu'} - {jobs: ['verify_codegen'], project: 'libcudacxx'} # c.parallel -- pinned to gcc13 / msvc2022 to match python - {jobs: ['test'], project: ['cccl_c_parallel'], ctk: '12.X', cxx: ['gcc13', 'msvc2022'], gpu: ['t4']} - {jobs: ['test'], project: ['cccl_c_parallel'], ctk: '13.X', cxx: ['gcc13', 'msvc2022'], gpu: ['rtx2080', 'l4', 'h100']} # RTX PRO 6000 coverage (limited due to small number of runners): - {jobs: ['test'], project: 'cccl_c_parallel', ctk: '13.X', cxx: ['gcc13'], gpu: ['rtxpro6000']} # c.experimental.stf -- pinned to gcc13 to match python - {jobs: ['test'], project: ['cccl_c_stf'], ctk: '12.X', cxx: 'gcc13', gpu: ['rtx2080']} - {jobs: ['test'], project: ['cccl_c_stf'], ctk: '13.X', cxx: 'gcc13', gpu: ['t4', 'l4', 'h100']} # Python -- pinned to gcc13 / msvc2022 for consistency across CTK images - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.11', '3.12', '3.13', '3.14'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'h100', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.14'], gpu: 't4', cxx: 'gcc13'} - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14', gpu: 'rtxa6000', cxx: 'gcc13'} - {jobs: ['test'], project: 'python', ctk: '13.X', py_version: '3.14', gpu: 'rtxpro6000', cxx: 'gcc13'} - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'} - {jobs: ['test_py_compute_minimal'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: '3.14t', gpu: 'l4', cxx: ['gcc13', 'msvc2022'], py_ctk_mode: 'sysctk'} # cuda.cccl.headers (CPU-only): all CTK x source x OS, py endpoints 3.10 + 3.14 - {jobs: ['test_headers'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.14'], cxx: ['gcc13', 'msvc2022'], py_ctk_mode: ['pinned', 'latest', 'sysctk']} # CCCL packaging: - {jobs: ['test'], project: 'packaging', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 't4', args: '-min-cmake'} - {jobs: ['test'], project: 'packaging', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 'rtx2080'} - {jobs: ['test'], project: 'packaging', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 't4', args: '-min-cmake'} - {jobs: ['test'], project: 'packaging', ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 'rtx2080'} - {jobs: ['install'], project: 'packaging'} # NVBench Helper: - {jobs: ['test'], project: 'nvbench_helper', ctk: '12.0', cxx: ['gcc10', 'clang14'], gpu: 'rtx2080'} - {jobs: ['test'], project: 'nvbench_helper', ctk: '12.X', cxx: ['gcc10', 'clang14'], gpu: 't4'} - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.0', cxx: ['gcc15', 'clang20'], gpu: 'rtx2080'} - {jobs: ['test'], project: 'nvbench_helper', ctk: '13.X', cxx: ['gcc', 'clang'], gpu: 't4'} # NVHPC build - {jobs: ['build'], cxx: 'nvhpc-prev', ctk: 'nvhpc-prev', std: 'all', project: ['libcudacxx', 'cub', 'thrust', 'cudax', 'stdpar'], cpu: ['amd64', 'arm64']} - {jobs: ['build'], cxx: 'nvhpc', ctk: 'nvhpc', std: 'all', project: ['libcudacxx', 'cub', 'thrust', 'cudax', 'stdpar'], cpu: ['amd64', 'arm64']} # clang-cuda - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', std: 'all', sm: '75;80;90;100;120'} - {jobs: ['build'], cudacxx: 'clang', ctk: 'clang_preview-cuda', cxx: 'clang_preview-cuda', std: 'all', sm: '75;80;90;100;120'} - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang-cuda', cxx: 'clang-cuda', std: 23, sm: '75;80;90;100;120'} - {jobs: ['build'], project: 'libcudacxx', cudacxx: 'clang', ctk: 'clang_preview-cuda', cxx: 'clang_preview-cuda', std: 23, sm: '75;80;90;100;120'} # compute-sanitizer - {jobs: ['compute_sanitizer'], project: 'cub', std: 'max', gpu: 'rtxa6000', sm: 'gpu', cmake_options: '-DCMAKE_CUDA_FLAGS=-lineinfo'} # clang-tidy - { jobs: ['build'], project: 'tidy', std: 'min', cxx: ['clang'], cudacxx: ['clang'], ctk: 'clang-cuda', sm: '75' } # arch-specific and family-specific arch builds - {jobs: ['build'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'all', sm: '90a;100a;103a;110a;120a;121a'} - {jobs: ['build'], project: ['libcudacxx', 'cub', 'thrust', 'cudax'], std: 'all', sm: '100f;103f;110f;120f;121f'} python-wheels: - {jobs: ['test'], project: 'python', ctk: ['12.0', '12.X', '13.0', '13.X'], py_version: ['3.10', '3.11', '3.12', '3.13', '3.14'], gpu: 'l4', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test'], project: 'python', ctk: ['12.X', '13.X'], py_version: '3.14', gpu: 'h100', cxx: ['gcc13', 'msvc2022']} - {jobs: ['test'], project: 'python', cpu: 'arm64', ctk: ['12.X', '13.X'], py_version: ['3.10', '3.11', '3.12', '3.13', '3.14'], gpu: 'l4', cxx: 'gcc13'} # This is just used to ensure that we generate devcontainers for all images we build. # These do not map to any actual jobs. devcontainers: - {jobs: ['dc'], ctk: ['12.0', '12.X' ], cxx: ['clang14']} - {jobs: ['dc'], ctk: ['12.0', '12.X' ], cxx: ['gcc7', 'gcc8', 'gcc9', 'gcc10']} - {jobs: ['dc'], ctk: ['12.0', '12.X', '13.0', '13.X'], cxx: ['gcc11', 'gcc12']} - {jobs: ['dc'], ctk: [ '12.X', '13.0', '13.X'], cxx: ['gcc13', 'gcc14']} - {jobs: ['dc'], ctk: [ '13.0', '13.X'], cxx: ['gcc15']} - {jobs: ['dc'], ctk: [ '12.X', '13.0', '13.X'], cxx: ['clang15', 'clang16', 'clang17', 'clang18', 'clang19']} - {jobs: ['dc_ext'], ctk: [ '12.X', '13.0', '13.X'], cxx: ['gcc14', 'clang20']} # Clang21+CTK12.9 is currently only used for cuda-clang testing. nvcc 12.9 doesn't support clang21. - {jobs: ['dc_ext'], ctk: [ '12.X', '13.X'], cxx: ['clang21']} - {jobs: ['dc_ext'], ctk: [ '13.X'], cxx: ['gcc15']} # Clang22+CTK12.9 is currently only used for clang-cuda testing. nvcc 12.9 doesn't support clang22. - {jobs: ['dc_ext'], ctk: [ '12.X' ], cxx: ['clang_preview22']} # 12.0 python image, pinned at gcc13 for simplicity. CTK 12.0 doesn't really play nice with gcc13, but # that doesn't matter for running python tests. - {jobs: ['dc'], ctk: ['12.0'], cxx: 'gcc13'} # NVHPC - {jobs: ['dc'], cxx: 'nvhpc-prev', ctk: 'nvhpc-prev'} - {jobs: ['dc'], cxx: 'nvhpc', ctk: 'nvhpc'} # Any generated jobs that match the entries in `exclude` will be removed from the final matrix for all workflows. exclude: # GPU runners are not available on Windows. - {jobs: ['test', 'test_gpu', 'test_nolid', 'test_lid0', 'test_lid1', 'test_lid2'], cxx: ['msvc2019', 'msvc14.39', 'msvc2022', 'msvc2026']} # cudax doesn't support C++17 on msvc: - {project: 'cudax', std: 17, cxx: ['msvc2019', 'msvc14.39', 'msvc2022', 'msvc2026']} ############################################################################################# # The version of the devcontainer images to use from https://hub.docker.com/r/rapidsai/devcontainers devcontainer_version: '26.10' # Compiler versions used for the cuda99.X internal builds: cuda99_gcc_version: 15 cuda99_clang_version: 21 # All supported C++ standards: all_stds: [17, 20] # Aliases: # - 12.X: Newest CTK 12.X version. # - 13.X: Newest CTK 13.X version. # - nvhpc: CTK shipped in newest NVHPC # - nvhpc-prev: CTK shipped in previous NVHPC # - pybuild: Selects image to use for python wheel builds' outer docker instance ctk_versions: 12.0: { stds: [17, 20] } 12.9: { stds: [17, 20], alias: ['12.X', 'pybuild', 'clang-cuda', 'clang_preview-cuda'] } 13.0: { stds: [17, 20] } 13.1: { stds: [17, 20], alias: ['nvhpc-prev']} 13.2: { stds: [17, 20], alias: ['nvhpc']} 13.3: { stds: [17, 20], alias: ['13.X'] } device_compilers: nvcc: # Version / stds are taken from CTK name: 'nvcc' exe: 'nvcc' clang: # Requires cxx=clang. Version / stds are taken from cxx compiler. name: "ClangCUDA" exe: 'clang++' host_compilers: gcc: name: 'GCC' container_tag: 'gcc' exe: 'g++' versions: 7: { stds: [17, ] } 8: { stds: [17, ] } 9: { stds: [17, ] } 10: { stds: [17, 20] } 11: { stds: [17, 20] } 12: { stds: [17, 20] } 13: { stds: [17, 20] } 14: { stds: [17, 20] } 15: { stds: [17, 20] } clang: name: 'Clang' container_tag: 'llvm' exe: 'clang++' versions: 14: { stds: [17, 20] } 15: { stds: [17, 20] } 16: { stds: [17, 20] } 17: { stds: [17, 20] } 18: { stds: [17, 20] } 19: { stds: [17, 20] } 20: { stds: [17, 20] } 21: { stds: [17, 20], alias: 'cuda' } clang_preview: name: 'Clang' container_tag: 'llvm' exe: 'clang++' versions: 22: { stds: [17, 20], alias: 'cuda' } msvc: name: 'MSVC' container_tag: 'cl' exe: cl versions: '14.29': { stds: [17, ], alias: '2019' } '14.39': { stds: [17, 20] } # CTK 12.0 doesn't recognize >14.39 as MSVC 2022. '14.44': { stds: [17, 20], alias: '2022' } '14.50': { stds: [17, 20], alias: '2026' } nvhpc: name: 'NVHPC' container_tag: 'nvhpc' exe: nvc++ versions: # !! Update the ctk_versions 'nvhpc*' aliases when updating NVHPC versions: 26.3: { stds: [17, 20], alias: 'prev' } 26.5: { stds: [17, 20] } # Jobs support the following properties: # # - name: The human-readable name of the job. Default is the capitalized job key. # - needs: # - A list of jobs that must be completed before this job can run. Default is an empty list. # - These jobs are automatically added if needed: # - Eg. "jobs: ['test']" in the workflow def will also create the required 'build' jobs. # - gpu: Whether the job requires a GPU runner. Default is false. # - cuda_ext: Whether the job requires a devcontainer with extra CUDA libraries. Default is false. # - invoke: # - Map the job type to the script invocation spec: # - prefix: The script invocation prefix. Default is the job name. # - args: Additional arguments to pass to the script. Default is no args. # - The script is invoked either: # linux: `ci/windows/_.ps1 ` # windows: `ci/_.sh ` # - force_producer_ctk: # - If set, force the auto-generated producers for this job to use a specific CTK version. # - By default, the autogenerated job's CTK version is determined by the consumer's `ctk` tag. # - This is useful for testing the cross-testing major version compat. # - E.g. "force_producer_ctk: '12.0'" on a test step will force the generated build step to use CTK 12.0. jobs: # General: build: { gpu: false } test: { gpu: true, needs: 'build' } install: { gpu: false } test_nobuild: { gpu: true, name: 'Test', invoke: { prefix: 'test' } } compute_sanitizer: { gpu: true, name: 'ComputeSanitizer', needs: 'build', invoke: { prefix: 'test', args: '-compute-sanitizer' } } # libcudacxx: nvrtc: { gpu: true, name: 'NVRTC' } verify_codegen: { gpu: false, name: 'VerifyCodegen' } # CUB: build_nolid: { name: 'BuildNoLaunch', gpu: false, invoke: { prefix: 'build', args: '-no-lid'} } build_lid0: { name: 'BuildHostLaunch', gpu: false, invoke: { prefix: 'build', args: '-lid0'} } build_lid1: { name: 'BuildDeviceLaunch', gpu: false, invoke: { prefix: 'build', args: '-lid1'} } build_lid2: { name: 'BuildGraphCapture', gpu: false, invoke: { prefix: 'build', args: '-lid2'} } # NoLid -> The string `lid_X` doesn't appear in the test name. Mostly warp/block tests, old device tests, and examples. test_nolid: { name: 'TestNoLaunch', gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-no-lid --test-par 8'} } # CUB uses `lid` to indicate launch strategies: whether CUB algorithms are: # - launched from the host (lid0): test_lid0: { name: 'HostLaunch', gpu: true, needs: 'build_lid0', invoke: { prefix: 'test', args: '-lid0 --test-par 8'} } # - launched from the device (lid1): test_lid1: { name: 'DeviceLaunch', gpu: true, needs: 'build_lid1', invoke: { prefix: 'test', args: '-lid1 --test-par 8'} } # - captured in a CUDA graph for deferred launch (lid2): test_lid2: { name: 'GraphCapture', gpu: true, needs: 'build_lid2', invoke: { prefix: 'test', args: '-lid2 --test-par 8'} } # Limited build reduces the number of runtime test cases, available device memory, etc, and may be used # to reduce test runtime in limited environments. limited: { name: "SmallGMem", gpu: true, needs: 'build', invoke: { prefix: 'test', args: '-limited'} } # Compute sanitizer jobs: compute_mem_nolid: { name: 'CSMem-TestGPU', gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-compute-sanitizer-memcheck -no-lid'} } compute_mem_lid0: { name: 'CSMem-HostLaunch', gpu: true, needs: 'build_lid0', invoke: { prefix: 'test', args: '-compute-sanitizer-memcheck -lid0'} } compute_race_nolid: { name: 'CSRace-TestGPU', gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-compute-sanitizer-racecheck -no-lid'} } compute_race_lid0: { name: 'CSRace-HostLaunch', gpu: true, needs: 'build_lid0', invoke: { prefix: 'test', args: '-compute-sanitizer-racecheck -lid0'} } compute_init_nolid: { name: 'CSInit-TestGPU', gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-compute-sanitizer-initcheck -no-lid'} } compute_init_lid0: { name: 'CSInit-HostLaunch', gpu: true, needs: 'build_lid0', invoke: { prefix: 'test', args: '-compute-sanitizer-initcheck -lid0'} } compute_sync_nolid: { name: 'CSSync-TestGPU', gpu: true, needs: 'build_nolid', invoke: { prefix: 'test', args: '-compute-sanitizer-synccheck -no-lid'} } compute_sync_lid0: { name: 'CSSync-HostLaunch', gpu: true, needs: 'build_lid0', invoke: { prefix: 'test', args: '-compute-sanitizer-synccheck -lid0'} } # Thrust: test_cpu: { name: 'TestCPU', gpu: false, needs: 'build', invoke: { prefix: 'test', args: '-cpu-only'} } test_gpu: { name: 'TestGPU', gpu: true, needs: 'build', invoke: { prefix: 'test', args: '-gpu-only'} } # Python: build_py_wheel: { name: "Build cuda.cccl", gpu: false, invoke: { prefix: 'build_cuda_cccl'} } test_headers: { name: "Test cuda.cccl.headers", gpu: false, needs: 'build_py_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_cccl_headers'} } test_py_par: { name: "Test cuda.compute", gpu: true, needs: 'build_py_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_compute'} } test_py_compute_minimal: { name: "Test cuda.compute minimal", gpu: true, needs: 'build_py_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_compute_minimal'} } test_py_examples: { name: "Test cuda.cccl.examples", gpu: true, needs: 'build_py_wheel', force_producer_ctk: "pybuild", invoke: { prefix: 'test_cuda_cccl_examples'} } # Run jobs for 'target' project (ci/util/build_and_test_targets.sh): run_cpu: { gpu: false } run_gpu: { gpu: true } # Only used for generating devcontainers. No scripts actually exist for these: dc: { gpu: false } dc_ext: { gpu: false, cuda_ext: true } # Projects have the following properties: # # Keys are project subdirectories names. These will also be used in script names. # # - stds: A list of C++ standards to test. Required. # - name: The human-readable name of the project. Default is the project key. # - job_map: Map general jobs to arrays of project-specific jobs. # Useful for things like splitting cpu/gpu testing for a project. # E.g. "job_map: { test: ['test_cpu', 'test_gpu'] }" replaces # the "test" job with distinct "test_cpu" and "test_gpu" jobs. projects: packaging: name: 'CCCL Packaging' stds: [17, 20] job_map: build: [] test: ['test_nobuild'] libcudacxx: name: 'libcu++' stds: [17, 20] cub: name: 'CUB' stds: [17, 20] job_map: build: ['build_nolid', 'build_lid0', 'build_lid1', 'build_lid2'] test: ['test_nolid', 'test_lid0', 'test_lid1', 'test_lid2'] compute_sanitizer: - compute_mem_nolid - compute_mem_lid0 - compute_race_nolid - compute_race_lid0 - compute_init_nolid - compute_init_lid0 - compute_sync_nolid - compute_sync_lid0 thrust: name: 'Thrust' stds: [17, 20] job_map: { test: ['test_cpu', 'test_gpu'] } cudax: stds: [17, 20] stdpar: name: 'NVHPC stdpar' stds: [17, 20] python: name: "Python" job_map: build: ['build_py_wheel'] test: ['test_py_par', 'test_py_examples'] python_v2: name: "Python (cuda.compute on v2/HostJIT)" # Only cuda.compute differs between v1 and v2; cuda.cccl.headers does not # need separate coverage. Run the examples because they exercise # cuda.compute against the v2 backend. job_map: build: ['build_py_wheel'] test: ['test_py_par', 'test_py_examples'] python_tsan: name: "Python (cuda.compute free-threaded ThreadSanitizer)" # Runs per-PR (and nightly). The producer build_py_wheel runs # build_cuda_cccl_python_tsan.sh (c.parallel v1 host code built with # -fsanitize=thread); test_py_compute_minimal runs # test_cuda_compute_minimal_python_tsan.sh (the FT stress + sweep under the # TSan runtime). Deliberately absent from the `python-wheels` publish # workflow, so these instrumented wheels never reach PyPI. job_map: build: ['build_py_wheel'] test: ['test_py_compute_minimal'] cccl_c_parallel: name: 'CCCL C Parallel' stds: [20] cccl_c_parallel_v2: name: 'CCCL C Parallel v2 (HostJIT)' stds: [20] # test_cccl_c_parallel_v2.sh builds inline (no separate build script), # so suppress the default test→build dependency. test_nobuild invokes # test_.sh directly without a producer build job. job_map: build: [] test: ['test_nobuild'] cccl_c_stf: name: 'CCCL C CUDASTF' stds: [20] nvbench_helper: name: 'NVBench Helper' stds: [17] # Only builds on oldest arch for max compat. job_map: build: [] test: ['test_nobuild'] # Run specific build_and_test_targets.sh invocations across the CI matrix. # Use the override workflow and supply arguments via the `args` tag. # Example: # override: # - { jobs: ['run'], project: 'target', ctk: ['12.X', '13.X'], cxx: 'gcc', gpu: 'rtx2080', # args: '--preset cub-cpp20 --build-targets "cub.cpp20.test.iterator" --ctest-targets "cub.cpp20.test.iterator"' } target: name: 'Target' stds: [17, 20] bisect: name: 'Bisect' stds: [17, 20] tidy: name: 'clang-tidy' stds: [17] # name -> Display name for generated job labels. # runner -> GPU/driver/count segment of the GHA runner label. # testing -> Runner with GPU is in a nv-gh-runners testing pool. gpus: t4: { name: 'T4', sm: 75, runner: 't4-latest-1' } # 16 GB, 10 runners rtx2080: { name: 'RTX2080', sm: 75, runner: 'rtx2080-latest-1' } # 8 GB, 12 runners rtxa6000: { name: 'RTXA6000', sm: 86, runner: 'rtxa6000-latest-1' } # 48 GB, 12 runners l4: { name: 'L4', sm: 89, runner: 'l4-latest-1' } # 24 GB, 48 runners rtx4090: { name: 'RTX4090', sm: 89, runner: 'rtx4090-latest-1' } # 24 GB, 10 runners h100: { name: 'H100', sm: 90, runner: 'h100-latest-1' } # 80 GB, 16 runners h100_2gpu: { name: 'H100 2-GPU', sm: 90, runner: 'h100-latest-2' } # 2 x 80 GB # Very small number of runners on loan from cuda-python while we wait for our order to arrive. # Limit jobs on these: rtxpro6000: { name: 'RTXPRO6000', sm: 120, runner: 'rtxpro6000-latest-1' } # Tags are used to define a `matrix job` in the workflow section. # # Tags have the following options: # - required: Whether the tag is required. Default is false. # - default: The default value for the tag. Default is null. tags: # An array of jobs (e.g. 'build', 'test', 'nvrtc', 'infra', 'verify_codegen', ...) # See the `jobs` map. jobs: { required: true } # CUDA ToolKit version # See the `ctks` map. ctk: { default: '13.X' } # CPU architecture cpu: { default: 'amd64' } # GPU model gpu: { default: 'rtx2080' } # Host compiler {name, version, exe} # See the `host_compilers` map. cxx: { default: 'gcc' } # Device compiler. # See the `device_compilers` map. cudacxx: { default: 'nvcc' } # Project name (e.g. libcudacxx, cub, thrust, cccl) # See the `projects` map. project: { default: ['libcudacxx', 'cub', 'thrust'] } # Python version for Python builds/tests py_version: { required: false } # Python CTK-source mode for test lanes (Python-only): # 'pinned' (default) -- pin cuda-toolkit to the container CTK minor # 'latest' -- unpinned; pip resolves the newest minor # 'sysctk' -- use the system toolkit; install the sysctk extras # If set, passed to the script with `-ctk-mode `. Exploded if an array, # e.g. `['pinned','sysctk']`. py_ctk_mode: { required: false } # C++ standard # If set to 'all', all stds supported by the ctk/compilers/project are used. # If set to 'min', 'max', or 'minmax', the minimum, maximum, or both stds are used. # If set, will be passed to script with `-std `. std: { required: false } # GPU architecture # - If set, passed to script with `-arch `. # - Format is the same as `CMAKE_CUDA_ARCHITECTURES`: # - PTX only: 70-virtual # - SASS only: 70-real # - Both: 70 # - Can pass multiple architectures via "60;70-real;80-virtual" # - Defaults to use the settings in the CMakePresets.json file. # - Will be exploded if an array, e.g. `sm: ['60;70;80;90', '90a']` creates two jobs. # - Set to 'gpu' to only target the GPU in the `gpu` tag. sm: { required: false } # Additional CMake options to pass to the build. # If set, passed to script with `-cmake_options ""`. cmake_options: { required: false } # Environment variables to add environment: { required: false, default: [] } # Additional arguments appended to the generated command. # Typically used with the `target` project to forward options to # ci/util/build_and_test_targets.sh, but works with all CI jobs. args: { required: false, default: "" }