Merge ~bullwinkle-team/ubuntu/+source/hipcub:bullwinkle/llvm-21/ubuntu/devel into ubuntu/+source/hipcub:ubuntu/devel

[Bruno Bernardo de Moura]

Update to new upstream version 7.1.0

[Bruno Bernardo de Moura (bruno-bdmoura)]

Build in ppa: https://launchpad.net/~bruno-bdmoura/+archive/ubuntu/lp-2139349-hipcub

(~proposed and target archs)

[Andreas Hasenack (ahasenack)]

Questions inline (I hope LP doesn't crash)

review: Needs Information

[Andreas Hasenack (ahasenack)]

LP crashed:
```
Launchpad encountered an internal error during the following operation: emailing a code review comment. It was logged with id OOPS-54cc5a00e1a774048fc490b8026e60b1. Sorry for the inconvenience.

```

You will have to check the GUI here to see the diff comments.

[Bruno Bernardo de Moura (bruno-bdmoura)]

Related to the first question:

You're right, I initially misunderstood the `all` label on the Architecture field. It is now rolled back.

Now, related to the second question:

As can be seen below, the rdepends of libhipcub-tests results in libraries inside the own ROCm stack. Since it's planned for the ROCm stack to drop ppc64el architectures for packages belonging to dependency layers 1 and 2, this won't interfere with any other packages on the archive.

```
$ apt rdepends libhipcub-tests
libhipcub-tests
Reverse Depends:
  Depends: rocm-tests
```

[Andreas Hasenack (ahasenack)]

+1

review: Approve

[Andreas Hasenack (ahasenack)]

Sponsored:

Uploading hipcub_7.1.0-0ubuntu2.dsc
Uploading hipcub_7.1.0.orig.tar.gz
Uploading hipcub_7.1.0-0ubuntu2.debian.tar.xz
Uploading hipcub_7.1.0-0ubuntu2_source.buildinfo
Uploading hipcub_7.1.0-0ubuntu2_source.changes

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 89abd08..63d89af 100755
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,4 +1,4 @@
-* @stanleytsang-amd @umfranzw @RobsonRLemos @lawruble13
+* @stanleytsang-amd @umfranzw @RobsonRLemos
 # Documentation files
 docs/* @ROCm/rocm-documentation
 *.md @ROCm/rocm-documentation
diff --git a/.gitignore b/.gitignore
index a09b2d6..16d3be3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
 
 ### Build dirs ###
-build/
+build*/
 
 # Created by https://www.gitignore.io/api/c++,cmake
 
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index e8481a9..386ba44 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -30,6 +30,8 @@ include:
         - /deps-format.yaml
         - /deps-rocm.yaml
         - /deps-nvcc.yaml
+        - /deps-vcpkg.yaml
+        - /deps-windows.yaml
         - /deps-compiler-acceleration.yaml
         - /gpus-rocm.yaml
         - /gpus-nvcc.yaml
@@ -41,6 +43,10 @@ stages:
   - test
   - benchmark
 
+workflow:
+  rules:
+    - if: $CI_MERGE_REQUEST_LABELS !~ /CI Skip/
+
 clang-format:
   extends:
     - .lint:clang-format
@@ -88,7 +94,7 @@ copyright-date:
       -D GPU_TARGETS="$GPU_TARGETS"
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
       -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
-      -D CMAKE_CXX_STANDARD=14
+      -D CMAKE_CXX_STANDARD=17
       -B $CI_PROJECT_DIR/rocPRIM/build
       -S $CI_PROJECT_DIR/rocPRIM
     - cd $CI_PROJECT_DIR/rocPRIM/build
@@ -113,7 +119,6 @@ build:rocm:
       -D BUILD_TEST=ON
       -D BUILD_EXAMPLE=ON
       -D GPU_TARGETS="$GPU_TARGETS"
-      -D GPU_TEST_TARGETS="$GPU_TARGETS"
       -D ROCM_SYMLINK_LIBS=OFF
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
       -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
@@ -137,7 +142,7 @@ build:rocm:
     expire_in: 2 weeks
   parallel:
     matrix:
-      - BUILD_VERSION: [14, 17]
+      - BUILD_VERSION: 17
 
 build:rocm-benchmark:
   extends:
@@ -158,7 +163,7 @@ build:rocm-benchmark:
       -D GPU_TARGETS="$GPU_TARGETS"
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
       -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
-      -D CMAKE_CXX_STANDARD=14
+      -D CMAKE_CXX_STANDARD=17
       -B $CI_PROJECT_DIR/build
       -S $CI_PROJECT_DIR
     - cmake --build $CI_PROJECT_DIR/build
@@ -170,19 +175,106 @@ build:rocm-benchmark:
       - $CI_PROJECT_DIR/build/CMakeCache.txt
     expire_in: 2 weeks
 
-test:rocm:
+.rocm-windows-rocprim:
+  variables:
+    ROCPRIM_GIT_BRANCH: "develop_stream"
+  script:
+    # Install rocPRIM from git
+    - $BRANCH_NAME = $env:ROCPRIM_GIT_BRANCH
+    - if ($env:CI_COMMIT_BRANCH -eq "develop" -or $env:CI_COMMIT_BRANCH -eq "master") { $BRANCH_NAME = $env:CI_COMMIT_BRANCH }
+    - git clone -b "$BRANCH_NAME" --depth 1 https://gitlab-ci-token:${CI_JOB_TOKEN}@${ROCPRIM_GIT_URL} $CI_PROJECT_DIR/rocPRIM
+    - cmake
+      -G Ninja
+      -D CMAKE_CXX_COMPILER:PATH="${env:HIP_PATH}\bin\clang++.exe"
+      -D CMAKE_INSTALL_PREFIX=$CI_PROJECT_DIR/rocPRIM_install
+      -D ONLY_INSTALL=ON
+      -B $CI_PROJECT_DIR/rocPRIM/build
+      -S $CI_PROJECT_DIR/rocPRIM
+    - cmake --build $CI_PROJECT_DIR/rocPRIM/build --target install
+
+build:rocm-windows:
+  extends:
+    - .rocm-windows-rocprim
+    - .rules:build
+    - .gpus:rocm-windows
+    - .deps:rocm-windows
+    - .deps:visual-studio-devshell
+  stage: build
+  needs: []
+  script:
+    - !reference [".rocm-windows-rocprim", script]
+    - cmake
+      -G Ninja
+      -D CMAKE_CXX_COMPILER:PATH="${env:HIP_PATH}\bin\clang++.exe"
+      -D CMAKE_CXX_FLAGS="-Wall -Wextra -Werror -Wno-error=pass-failed"
+      -D CMAKE_PREFIX_PATH:PATH="$CI_PROJECT_DIR/rocPRIM_install;${env:HIP_PATH}"
+      -D CMAKE_BUILD_TYPE=Release
+      -D BUILD_TEST=ON
+      -D BUILD_EXAMPLE=ON
+      -D GPU_TARGETS=$GPU_TARGET
+      -D CMAKE_CXX_STANDARD="$BUILD_VERSION"
+      -B $CI_PROJECT_DIR/build
+      -S $CI_PROJECT_DIR
+    - cmake --build $CI_PROJECT_DIR/build
+  artifacts:
+    paths:
+      - $CI_PROJECT_DIR/build/test/hipcub/test_*
+      - $CI_PROJECT_DIR/build/test/CTestTestfile.cmake
+      - $CI_PROJECT_DIR/build/test/hipcub/CTestTestfile.cmake
+      - $CI_PROJECT_DIR/build/gtest/
+      - $CI_PROJECT_DIR/build/CMakeCache.txt
+      - $CI_PROJECT_DIR/build/CTestTestfile.cmake
+      - $CI_PROJECT_DIR/build/.ninja_log
+    expire_in: 1 day
+  parallel:
+    matrix:
+      - BUILD_VERSION: 17
+
+build:rocm-windows-benchmark:
+  extends:
+    - .rocm-windows-rocprim
+    - .rules:build
+    - .gpus:rocm-windows
+    - .deps:rocm-windows
+    - .deps:visual-studio-devshell
+  stage: build
+  needs: []
+  script:
+    - !reference [".rocm-windows-rocprim", script]
+    - cmake
+      -G Ninja
+      -D CMAKE_CXX_COMPILER:PATH="${env:HIP_PATH}\bin\clang++.exe"
+      -D CMAKE_CXX_FLAGS="-Wall -Wextra -Werror"
+      -D CMAKE_PREFIX_PATH:PATH="$CI_PROJECT_DIR/rocPRIM_install;${env:HIP_PATH}"
+      -D CMAKE_BUILD_TYPE=Release
+      -D BUILD_BENCHMARK=ON
+      -D GPU_TARGETS=$GPU_TARGET
+      -D CMAKE_CXX_STANDARD=17
+      -B $CI_PROJECT_DIR/build
+      -S $CI_PROJECT_DIR
+    - cmake --build $CI_PROJECT_DIR/build
+  artifacts:
+    paths:
+      - $CI_PROJECT_DIR/build/benchmark/*
+      - $CI_PROJECT_DIR/build/deps/googlebenchmark/
+      - $CI_PROJECT_DIR/build/.ninja_log
+      - $CI_PROJECT_DIR/build/CMakeCache.txt
+    expire_in: 1 day
+
+.test:rocm:
   stage: test
   needs:
     - build:rocm
+  tags:
+    - rocm
+    - $GPU
   extends:
     - .rocm
-    - .gpus:rocm
-    - .rules:test
   script:
     - cd $CI_PROJECT_DIR/build
     - cmake
       -D CMAKE_PREFIX_PATH=/opt/rocm
-      -D CMAKE_CXX_STANDARD=14
+      -D CMAKE_CXX_STANDARD=17
       -P $CI_PROJECT_DIR/cmake/GenerateResourceSpec.cmake
     - cat ./resources.json
     # Parallel execution (with other AMDGPU processes) can oversubscribe the SDMA queue.
@@ -191,10 +283,45 @@ test:rocm:
     - HSA_ENABLE_SDMA=0 ctest
       --output-on-failure
       --repeat-until-fail 2
-      --tests-regex "$GPU_TARGET"
       --resource-spec-file ./resources.json
       --parallel $PARALLEL_JOBS
 
+test:rocm-any-gpu:
+  variables:
+    GPU: ""
+    PARALLEL_JOBS: 1
+  extends:
+    - .test:rocm
+  rules:
+    - if: $CI_MERGE_REQUEST_TITLE =~ /Draft:/ && $CI_MERGE_REQUEST_LABELS !~ /Arch::/
+
+test:rocm-label-arch:
+  extends:
+    - .gpus:rocm
+    - .test:rocm
+    - .rules:arch-labels
+
+test:rocm-all-gpus:
+  variables:
+    SHOULD_BE_UNDRAFTED: "true"
+  extends:
+    - .gpus:rocm
+    - .test:rocm
+    - .rules:test
+
+test:rocm-windows:
+  stage: test
+  extends:
+    - .deps:rocm-windows
+    - .gpus:rocm-gpus-windows
+    - .deps:visual-studio-devshell
+    - .rules:test
+  needs:
+    - job: build:rocm-windows
+  script:
+    - cd $CI_PROJECT_DIR/build
+    - ctest --output-on-failure
+
 .benchmark:
   stage: benchmark
   variables:
@@ -238,7 +365,7 @@ benchmark:rocm:
       -G Ninja
       -D CMAKE_CXX_FLAGS="-Wall -Wextra -Werror"
       "$GPU_TARGETS_ARG"
-      -D CMAKE_CXX_STANDARD=14
+      -D CMAKE_CXX_STANDARD=17
       -S $CI_PROJECT_DIR/test/extra
       -B $CI_PROJECT_DIR/build/package_test
     - cmake --build $CI_PROJECT_DIR/build/package_test
@@ -259,7 +386,7 @@ benchmark:rocm:
     - cmake
       -G Ninja
       -D BUILD_TEST=OFF
-      -D CMAKE_CXX_STANDARD=14
+      -D CMAKE_CXX_STANDARD=17
       -S $CI_PROJECT_DIR
       -B $CI_PROJECT_DIR/build_only_install
     # Preserve $PATH when sudoing
@@ -322,6 +449,7 @@ build:nvcc:
       -D CMAKE_BUILD_TYPE=Release
       -D BUILD_TEST=ON
       -D BUILD_EXAMPLE=ON
+      "$(if [ "$SCHEDULE" == "nightly" ]; then echo "-D BUILD_COMPUTE_SANITIZER=ON"; fi)"
       -D NVGPU_TARGETS="$GPU_TARGETS"
       -D ROCM_SYMLINK_LIBS=OFF
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
@@ -347,7 +475,7 @@ build:nvcc:
     expire_in: 2 weeks
   parallel:
     matrix:
-      - BUILD_VERSION: [14, 17]
+      - BUILD_VERSION: 17
 
 build:nvcc-benchmark:
   stage: build
@@ -367,7 +495,7 @@ build:nvcc-benchmark:
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
       -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
       -D CMAKE_CUDA_COMPILER_LAUNCHER=phc_sccache_cuda
-      -D CMAKE_CXX_STANDARD=14
+      -D CMAKE_CXX_STANDARD=17
       -B $CI_PROJECT_DIR/build
       -S $CI_PROJECT_DIR
     - cmake --build $CI_PROJECT_DIR/build
@@ -379,14 +507,15 @@ build:nvcc-benchmark:
       - $CI_PROJECT_DIR/build/CMakeCache.txt
     expire_in: 2 weeks
 
-test:nvcc:
+.test:nvcc:
   stage: test
+  tags:
+    - nvcc
+    - $GPU
   needs:
     - build:nvcc
   extends:
     - .nvcc
-    - .gpus:nvcc
-    - .rules:test
   before_script:
     # This is only needed because of the legacy before_script in .gpus:nvcc would otherwise overwrite before_script
     - !reference [.nvcc, before_script]
@@ -394,6 +523,23 @@ test:nvcc:
     - cd $CI_PROJECT_DIR/build
     - ctest --output-on-failure --repeat-until-fail 2
 
+test:nvcc-any-gpu:
+  variables:
+    GPU: ""
+    PARALLEL_JOBS: 1
+  extends:
+    - .test:nvcc
+  rules:
+    - if: $CI_MERGE_REQUEST_TITLE =~ /Draft:/
+
+test:nvcc-all-gpus:
+  variables:
+    SHOULD_BE_UNDRAFTED: "true"
+  extends:
+    - .gpus:nvcc
+    - .test:nvcc
+    - .rules:test
+
 benchmark:nvcc:
   needs:
     - build:nvcc-benchmark
@@ -436,6 +582,10 @@ test:doc:
   extends:
     - .rules:test
     - .build:docs
+  artifacts:
+    paths:
+      - $DOCS_DIR/_build/html/
+    expire_in: 2 weeks
 
 scheduled-check-changes:
   extends: .rules:scheduled-check-changes
diff --git a/.jenkins/common.groovy b/.jenkins/common.groovy
deleted file mode 100644
index 79ebcb6..0000000
--- a/.jenkins/common.groovy
+++ /dev/null
@@ -1,53 +0,0 @@
-// This file is for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-def runCompileCommand(platform, project, jobName, boolean debug=false, boolean sameOrg=true)
-{
-    project.paths.construct_build_prefix()
-
-    String buildTypeArg = debug ? '-DCMAKE_BUILD_TYPE=Debug' : '-DCMAKE_BUILD_TYPE=Release'
-    String buildTypeDir = debug ? 'debug' : 'release'
-    String cmake = platform.jenkinsLabel.contains('centos') ? 'cmake3' : 'cmake'
-    //Set CI node's gfx arch as target if PR, otherwise use default targets of the library
-    String amdgpuTargets = env.BRANCH_NAME.startsWith('PR-') ? '-DAMDGPU_TARGETS=\$gfx_arch' : ''
-
-    def getRocPRIM = auxiliary.getLibrary('rocPRIM', platform.jenkinsLabel, null, sameOrg)
-
-    def command = """#!/usr/bin/env bash
-                set -x
-                ${getRocPRIM}
-                cd ${project.paths.project_build_prefix}
-                mkdir -p build/${buildTypeDir} && cd build/${buildTypeDir}
-                ${auxiliary.gfxTargetParser()}
-                ${cmake} --toolchain=toolchain-linux.cmake ${buildTypeArg} ${amdgpuTargets} -DBUILD_TEST=ON -DBUILD_BENCHMARK=ON ../..
-                make -j\$(nproc)
-                """
-
-    platform.runCommand(this, command)
-}
-
-
-def runTestCommand (platform, project)
-{
-    String sudo = auxiliary.sudo(platform.jenkinsLabel)
-
-    def testCommand = "ctest --output-on-failure --verbose --timeout 900"
-    def command = """#!/usr/bin/env bash
-                set -x
-                cd ${project.paths.project_build_prefix}
-                cd ${project.testDirectory}
-                ${sudo} LD_LIBRARY_PATH=/opt/rocm/lib ${testCommand}
-            """
-
-    platform.runCommand(this, command)
-}
-
-def runPackageCommand(platform, project)
-{
-    def packageHelper = platform.makePackage(platform.jenkinsLabel,"${project.paths.project_build_prefix}/build/release")
-
-    platform.runCommand(this, packageHelper[0])
-        platform.archiveArtifacts(this, packageHelper[1])
-}
-
-return this
diff --git a/.jenkins/precheckin.groovy b/.jenkins/precheckin.groovy
deleted file mode 100644
index 074bc53..0000000
--- a/.jenkins/precheckin.groovy
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCm/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This file is for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path;
-
-def runCI = 
-{
-    nodeDetails, jobName->
-
-    def prj = new rocProject('hipCUB', 'PreCheckin')
-    prj.timeout.compile = 400
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-
-    def commonGroovy
-
-    def compileCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-        commonGroovy.runCompileCommand(platform, project, jobName)
-    }
-
-    def testCommand =
-    {
-        platform, project->
-
-        commonGroovy.runTestCommand(platform, project)
-    }
-
-    def packageCommand =
-    {
-        platform, project->
-        
-        commonGroovy.runPackageCommand(platform, project)
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, packageCommand)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu18:['gfx900'],centos7:['gfx906'],centos8:['gfx906'],sles15sp1:['gfx908']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    auxiliary.registerDependencyBranchParameter(["rocPRIM"])
-    
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    Set seenJobNames = []
-    jobNameList.each 
-    {
-        jobName, nodeDetails->
-        seenJobNames.add(jobName)
-        if (urlJobName == jobName)
-            runCI(nodeDetails, jobName)
-    }
-
-    // For url job names that are outside of the standardJobNameSet i.e. compute-rocm-dkms-no-npi-1901
-    if(!seenJobNames.contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        runCI([ubuntu16:['gfx906']], urlJobName)       
-    }
-}
-
diff --git a/.jenkins/staticanalysis.groovy b/.jenkins/staticanalysis.groovy
deleted file mode 100644
index 5c0b949..0000000
--- a/.jenkins/staticanalysis.groovy
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCm/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runCompileCommand(platform, project, jobName, boolean debug=false)
-{
-    project.paths.construct_build_prefix()
-}
-
-def runCI = 
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('hipCUB', 'StaticAnalysis')
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-    boolean staticAnalysis = true
-
-    def compileCommand =
-    {
-        platform, project->
-
-        runCompileCommand(platform, project, jobName, false)
-    }
-
-    buildProject(prj , formatCheck, nodes.dockerArray, compileCommand, null, null, staticAnalysis)
-}
-
-ci: {
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * 6')])]))
-    stage(urlJobName) {
-        runCI([ubuntu20:['any']], urlJobName)
-    }
-}
diff --git a/.jenkins/staticlibrary.groovy b/.jenkins/staticlibrary.groovy
deleted file mode 100644
index 549913d..0000000
--- a/.jenkins/staticlibrary.groovy
+++ /dev/null
@@ -1,82 +0,0 @@
-#!/usr/bin/env groovy
-@Library('rocJenkins@pong') _
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path;
-
-def runCI =
-{
-    nodeDetails, jobName->
-    
-    def prj = new rocProject('hipCUB', 'Static Library PreCheckin')
-
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    def commonGroovy
-
-    boolean formatCheck = false
-     
-    def compileCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-        commonGroovy.runCompileCommand(platform, project, jobName, false, true)
-    }
-
-    
-    def testCommand =
-    {
-        platform, project->
-
-        commonGroovy.runTestCommand(platform, project)
-    }
-
-    def packageCommand =
-    {
-        platform, project->
-
-        commonGroovy.runPackageCommand(platform, project)
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, packageCommand)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi":[pipelineTriggers([cron('0 1 * * 0')])], 
-                        "compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])],
-                        "rocm-docker":[]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi":([ubuntu16:['gfx900'],centos7:['gfx906'],sles15sp1:['gfx908']]), 
-                       "compute-rocm-dkms-no-npi-hipclang":([ubuntu16:['gfx900'],centos7:['gfx906'],sles15sp1:['gfx908']]), 
-                       "rocm-docker":([ubuntu16:['gfx900'],centos7:['gfx906'],sles15sp1:['gfx908']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu16:['gfx906']], urlJobName)
-        }
-    }
-}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a13e14..a9814bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,107 @@
 
 Full documentation for hipCUB is available at [https://rocm.docs.amd.com/projects/hipCUB/en/latest/](https://rocm.docs.amd.com/projects/hipCUB/en/latest/).
 
+## hipCUB-4.1.0 for ROCm 7.1
+
+### Added
+
+* Exposed Thread-level reduction API `hipcub::ThreadReduce`.
+* Added `::hipcub::extents`, with limited parity to C++23's `std::extents`. Only `static extents` is supported; `dynamic extents` is not. Helper structs have been created to perform computations on `::hipcub::extents` only when the backend is rocPRIM. For the CUDA backend, similar functionality exists.
+* Added `projects/hipcub/hipcub/include/hipcub/backend/rocprim/util_mdspan.hpp` to support `::hipcub::extents`.
+* Added `::hipcub::ForEachInExtents` API.
+* Added `hipcub::DeviceTransform::Transform` and `hipcub::DeviceTransform::TransformStableArgumentAddresses`.
+
+* hipCUB and its dependency rocPRIM have been moved into the new rocm-libraries "monorepo" repository (https://github.com/ROCm/rocm-libraries). This repository contains a number of ROCm libraries that are frequently used together.
+  * The repository migration requires a few changes to the way that hipCUB fetches library dependencies.
+  * CMake build option `ROCPRIM_FETCH_METHOD` may be set to one of the following:
+    * `PACKAGE` - (default) searches for a preinstalled packaged version of the dependency. If it is not found, the build will fall back using option `DOWNLOAD`, below.
+    * `DOWNLOAD` - downloads the dependency from the rocm-libraries repository. If git >= 2.25 is present, this option uses a sparse checkout that avoids downloading more than it needs to. If not, the whole monorepo is downloaded (this may take some time).
+    * `MONOREPO` - this options is intended to be used if you are building hipCUB from within a copy of the rocm-libraries repository that you have cloned (and therefore already contains rocPRIM). When selected, the build will try find the dependency in the local repository tree. If it cannot be found, the build will attempt to use git to perform a sparse-checkout of rocPRIM. If that also fails, it will fall back to using the `DOWNLOAD` option described above.
+
+* Added a new CMake option `-DUSE_SYSTEM_LIB` to allow tests to be built from installed `hipCUB` provided by the system.
+    
+### Removed
+
+* Removed `TexRefInputIterator`, which was removed from CUB after CCCL's 2.6.0 release. This API should have already been removed, but somehow it remained and was not tested.
+* Deprecated `hipcub::ConstantInputIterator`, use `rocprim::constant_iterator` or `rocthrust::constant_iterator` instead.
+* Deprecated `hipcub::CountingInputIterator`, use `rocprim::counting_iterator` or `rocthrust::counting_iterator` instead.
+* Deprecated `hipcub::DiscardOutputIterator`, use `rocprim::discard_iterator` or `rocthrust::discard_iterator` instead.
+* Deprecated `hipcub::TransformInputIterator`, use `rocprim::transform_iterator` or `rocthrust::transform_iterator` instead.
+* Deprecated `hipcub::AliasTemporaries`, which is considered to be internal API. Moved it to detail namespace.
+* Deprecated almost all functions in `projects/hipcub/hipcub/include/hipcub/backend/rocprim/util_ptx.hpp`.
+* Deprecated hipCUB macros: `HIPCUB_MAX`, `HIPCUB_MIN`, `HIPCUB_QUOTIENT_FLOOR`, `HIPCUB_QUOTIENT_CEILING`, `HIPCUB_ROUND_UP_NEAREST` and `HIPCUB_ROUND_DOWN_NEAREST`.
+
+### Changed
+
+* Changed include headers to avoid relative includes that have slipped in.
+* Changed `CUDA_STANDARD` for tests in `test/hipcub`, due to C++17 APIs such as `std::exclusive_scan` is used in some tests. Still use `CUDA_STANDARD 14` for `test/extra`.
+* Changed `CCCL_MINIMUM_VERSION` to `2.8.2` to align with CUB.
+* Changed `cmake_minimum_required` from `3.16` to `3.18`, in order to support `CUDA_STANDARD 17` as a valid value.
+* Add support for large num_items `DeviceScan`, `DevicePartition` and `Reduce::{ArgMin, ArgMax}`.
+* Added tests for large num_items.
+* The previous dependency-related build option `DEPENDENCIES_FORCE_DOWNLOAD` has been renamed `EXTERNAL_DEPS_FORCE_DOWNLOAD` to differentiate it from the new rocPRIM dependency option described above. It's behaviour remains the same - it forces non-ROCm dependencies (Google Benchmark and Google Test) to be downloaded instead of searching for existing installed packages. This option defaults to `OFF`.
+
+### Known issues
+
+* The '__half' template specializations of Simd operators are currently disabled due to possible build issues with PyTorch.
+
+## hipCUB-4.0.0 for ROCm 7.0
+
+### Added
+
+* Added a new cmake option, `BUILD_OFFLOAD_COMPRESS`. When hipCUB is build with this option enabled, the `--offload-compress` switch is passed to the compiler. This causes the compiler to compress the binary that it generates. Compression can be useful in cases where you are compiling for a large number of targets, since this often results in a large binary. Without compression, in some cases, the generated binary may become so large symbols are placed out of range, resulting in linking errors. The new `BUILD_OFFLOAD_COMPRESS` option is set to `ON` by default.
+* Added single pass operators in `agent/single_pass_scan_operators.hpp` which contains the following API:
+  * `BlockScanRunningPrefixOp`
+  * `ScanTileStatus`
+  * `ScanTileState`
+  * `ReduceByKeyScanTileState`
+  * `TilePrefixCallbackOp`
+* Added gfx950 support.
+* Added an overload of `BlockScan::InclusiveScan` that accepts an initial value to seed the scan.
+* Added an overload of `WarpScan::InclusiveScan` that accepts an initial value to seed the scan.
+* `UnrolledThreadLoad`, `UnrolledCopy`, and `ThreadLoadVolatilePointer` were added to align hipCUB with CUB.
+* `ThreadStoreVolatilePtr` and the `IterateThreadStore` struct were added to align hipCUB with CUB.
+* Added `hipcub::InclusiveScanInit` for CUB parity.
+* Additional Unit Tests for:
+  * block_exchange
+  * block_merge_sort
+  * block_radix_rank
+  * block_radix_sort
+  * block_reduce
+  * block_shuffle
+
+### Removed
+
+* The AMD GPU targets `gfx803` and `gfx900` are no longer built by default. If you would like to build for these architectures, please specify them explicitly in the `AMDGPU_TARGETS` cmake option.
+* Deprecated `hipcub::AsmThreadLoad` is removed, use `hipcub::ThreadLoad` instead.
+* Deprecated `hipcub::AsmThreadStore` is removed, use `hipcub::ThreadStore` instead.
+* Deprecated `BlockAdjacentDifference::FlagHeads`, `BlockAdjacentDifference::FlagTails` and `BlockAdjacentDifference::FlagHeadsAndTails` have been removed.
+* This release removes support for custom builds on gfx940 and gfx941.
+* Removed C++14 support, only C++17 is supported.
+
+### Changed
+
+* The NVIDIA backend now requires CUB, Thrust, and libcu++ 2.7.0. If they aren't found, they will be downloaded from the NVIDIA CCCL repository.
+* Updated `thread_load` and `thread_store` to align hipCUB with CUB.
+* All kernels now have hidden symbol visibility. All symbols now have inline namespaces that include the library version, (for example, hipcub::HIPCUB_300400_NS::symbol instead of hipcub::symbol), letting the user link multiple libraries built with different versions of hipCUB.
+* Modified the broadcast kernel in warp scan benchmarks. The reported performance may be different to previous versions.
+* The `hipcub::detail::accumulator_t` in rocPRIM backend has been changed to utilise `rocprim::accumulator_t`.
+* The usage of `rocprim::invoke_result_binary_op_t` has been replaced with `rocprim::accumulator_t`.
+
+### Resolved issues
+* Fixed an issue where `Sort(keys, compare_op, valid_items, oob_default)` in `block_merge_sort.hpp` would not fill in elements that are out of range (items after `valid_items`) with `oob_default`.
+* Fixed an issue where `ScatterToStripedFlagged` in `block_exhange.hpp` was calling the wrong function.
+
+### Known issues
+
+* `BlockAdjacentDifference::FlagHeads`, `BlockAdjacentDifference::FlagTails` and `BlockAdjacentDifference::FlagHeadsAndTails` have been removed from hipCUB's CUB backend. They were already deprecated as of version 2.12.0 of hipCUB and they were removed from CCCL (CUB) as of CCCL's 2.6.0 release.
+* `BlockScan::InclusiveScan` for the NVIDIA backend does not compute the block aggregate correctly when passing an initial value parameter. This behavior is not matched by the AMD backend.
+
+
+### Upcoming Changes
+
+* `BlockAdjacentDifference::FlagHeads`, `BlockAdjacentDifference::FlagTails` and `BlockAdjacentDifference::FlagHeadsAndTails` were deprecated as of version 2.12.0 of hipCUB, and will be removed from the rocPRIM backend in a future release for the next ROCm major version (ROCm 7.0.0).
+
 ## hipCUB-3.4.0 for ROCm 6.4.0
 
 ### Added
diff --git a/CMakeLists.txt b/CMakeLists.txt
index dd9a3e2..fbcecf0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -20,8 +20,19 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
-cmake_policy(VERSION 3.16...3.25)
+cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
+cmake_policy(VERSION 3.18...3.25)
+
+# --------------------------------------
+# Update these variables at release time
+#
+# Set the library version
+set(VERSION_STRING "4.1.0")
+# Set the minimum required rocPRIM version
+set(MIN_ROCPRIM_PACKAGE_VERSION "4.1.0" CACHE STRING "Minimum version of rocPRIM to search for when ROCPRIM_FETCH_METHOD is set to PACKAGE.")
+# Set download branch for dependency rocPRIM
+set(ROCM_DEP_RELEASE_BRANCH "release/rocm-rel-7.1" CACHE STRING "Download branch for ROCm dependencies")
+# --------------------------------------
 
 # Install prefix
 set(CMAKE_INSTALL_PREFIX "/opt/rocm" CACHE PATH "Install path prefix, prepended onto install directories")
@@ -43,7 +54,7 @@ elseif(NOT CMAKE_CXX_STANDARD EQUAL 17)
 endif()
 
 # Set HIP flags
-set(CMAKE_HIP_STANDARD 14)
+set(CMAKE_HIP_STANDARD 17)
 set(CMAKE_HIP_STANDARD_REQUIRED ON)
 set(CMAKE_HIP_EXTENSIONS OFF)
 
@@ -52,15 +63,23 @@ include(CMakeDependentOption)
 
 # Build options
 option(BUILD_TEST "Build tests (requires googletest)" OFF)
-option(DEPENDENCIES_FORCE_DOWNLOAD "Download dependencies and do not search for packages" OFF)
+option(CODE_COVERAGE "Enable code coverage" OFF)
+option(EXTERNAL_DEPS_FORCE_DOWNLOAD "Download non-ROCm dependencies and do not search for packages" OFF)
 option(DOWNLOAD_CUB "Download CUB and thrust. Do not search for CUB package" OFF)
 option(BUILD_BENCHMARK "Build benchmarks" OFF)
 option(BUILD_EXAMPLE "Build Examples" OFF)
 option(BUILD_ADDRESS_SANITIZER "Build with address sanitizer enabled" OFF)
+option(BUILD_OFFLOAD_COMPRESS "Build hipCUB with offload compression" ON)
+option(BUILD_COMPUTE_SANITIZER "Build tests with cuda's compute sanitizer enabled" OFF)
+cmake_dependent_option(USE_SYSTEM_LIB "Use installed hipCUB when building tests" OFF BUILD_TEST OFF)
 
+# Check and test cuda compiler, defines 'CMAKE_HIP_COMPILER'
 check_language(HIP)
 cmake_dependent_option(USE_HIPCXX "Use CMake HIP language support" OFF CMAKE_HIP_COMPILER OFF)
 
+# Check and test cuda compiler, defines 'CMAKE_CUDA_COMPILER'
+check_language(CUDA)
+
 # Set the ROCM install directory.
 if(WIN32)
   set(ROCM_ROOT "$ENV{HIP_PATH}" CACHE PATH "Root directory of the ROCm installation")
@@ -68,15 +87,29 @@ else()
   set(ROCM_ROOT "/opt/rocm" CACHE PATH "Root directory of the ROCm installation")
 endif()
 
+# Set up options for obtaining dependency rocPRIM.
+# PACKAGE: Search for an install package that contains the dependency.
+# MONOREPO: Assume this is a monorepo checkout and search for the dependency in the directory at ../../projects/.
+# DOWNLOAD: Download the dependency from the monorepo.
+set(FETCH_METHOD_OPTIONS "PACKAGE" "MONOREPO" "DOWNLOAD")
 
-# Set the header wrapper ON by default.
-option(BUILD_FILE_REORG_BACKWARD_COMPATIBILITY "Build with file/folder reorg with backward compatibility enabled" OFF)
+set(ROCPRIM_FETCH_METHOD "PACKAGE" CACHE STRING "How to obtain the rocPRIM dependency")
+
+# This function checks to see if the fetch method variable it's passed is defined, and contains a valid value.
+# If it does not contain a valid value, it issues a fatal failure with an error message.
+function(check_fetch_method method)
+  if (DEFINED ${method} AND NOT ${${method}} IN_LIST FETCH_METHOD_OPTIONS)
+    message(FATAL_ERROR "Unrecognized ${method}: \"${${method}}\". Valid options are: ${FETCH_METHOD_OPTIONS}.")
+  endif()
+endfunction()
+
+check_fetch_method(ROCPRIM_FETCH_METHOD)
 
 # Add hipCUB's CMake modules
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 # Set a default build type if none was specified
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES AND NOT CODE_COVERAGE)
   message(STATUS "Setting build type to 'Release' as none was specified.")
   set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "" "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
@@ -88,35 +121,55 @@ set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE CACHE BOOL "Add paths to linker searc
 # If hip is included prior to setting that then it defaults to building only for the current architecture
 include(ROCmCMakeBuildToolsDependency)
 
-# Setup GPU targets for rocm platform
+# Detect compiler through use of result from 'check_language(...)'
 if(USE_HIPCXX)
   enable_language(HIP)
-else()
+elseif(NOT (CMAKE_CXX_COMPILER MATCHES ".*nvcc$" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU"))
+  # Detected HIP through archaic match by checking passed CXX compiler. This can
+  # be removed once we bump minimum CMake version to 3.21 or higher.
+
   # Setup GPU targets for rocm platform
-  if(NOT (CMAKE_CXX_COMPILER MATCHES ".*nvcc$" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU"))
-    if(NOT DEFINED AMDGPU_TARGETS)
-      set(GPU_TARGETS "all" CACHE STRING "GPU architectures to compile for")
+  message(STATUS "CMake could not derive language via 'check_language'. Falling back to legacy compiler checks.")
+  if(NOT DEFINED AMDGPU_TARGETS)
+    set(GPU_TARGETS "all" CACHE STRING "GPU architectures to compile for")
+  else()
+    set(GPU_TARGETS "${AMDGPU_TARGETS}" CACHE STRING "GPU architectures to compile for")
+  endif()
+  set_property(CACHE GPU_TARGETS PROPERTY STRINGS "all")
+
+  if(GPU_TARGETS STREQUAL "all")
+    if(BUILD_ADDRESS_SANITIZER)
+      # ASAN builds require xnack
+      rocm_check_target_ids(DEFAULT_AMDGPU_TARGETS
+        TARGETS "gfx908:xnack+;gfx90a:xnack+;gfx942:xnack+;gfx950:xnack+"
+      )
     else()
-      set(GPU_TARGETS "${AMDGPU_TARGETS}" CACHE STRING "GPU architectures to compile for")
-    endif()
-    set_property(CACHE GPU_TARGETS PROPERTY STRINGS "all")
-
-    if(GPU_TARGETS STREQUAL "all")
-      if(BUILD_ADDRESS_SANITIZER)
-        # ASAN builds require xnack
-        rocm_check_target_ids(DEFAULT_AMDGPU_TARGETS
-          TARGETS "gfx908:xnack+;gfx90a:xnack+;gfx942:xnack+"
-        )
-      else()
-        rocm_check_target_ids(DEFAULT_AMDGPU_TARGETS
-          TARGETS "gfx803;gfx900:xnack-;gfx906:xnack-;gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx942;gfx1030;gfx1100;gfx1101;gfx1102;gfx1151;gfx1200;gfx1201"
-        )
-      endif()
-      set(GPU_TARGETS "${DEFAULT_AMDGPU_TARGETS}" CACHE STRING "GPU architectures to compile for" FORCE)
+      rocm_check_target_ids(DEFAULT_AMDGPU_TARGETS
+        TARGETS "gfx906:xnack-;gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx942;gfx950;gfx1030;gfx1100;gfx1101;gfx1102;gfx1151;gfx1200;gfx1201"
+      )
     endif()
+    set(GPU_TARGETS "${DEFAULT_AMDGPU_TARGETS}" CACHE STRING "GPU architectures to compile for" FORCE)
   endif()
+elseif(CMAKE_CUDA_COMPILER)
+  # We haven't detected HIP, so surely we must be on a CUDA-compatible compiler.
+  # Contrary to HIP, 'enable_language(CUDA)' is supported from CMake 3.8 and higher.
+  enable_language(CUDA)
+
+  # Hack: let CMake think that our 'hip' files are actually CUDA files.
+  set(CMAKE_CUDA_SOURCE_FILE_EXTENSIONS hip;cu)
 endif()
 
+# Compressed offload binaries are currently not working with the SPIR-V target
+if("amdgcnspirv" IN_LIST GPU_TARGETS)
+  if(BUILD_OFFLOAD_COMPRESS)
+    message(FATAL_ERROR "Cannot combine SPIR-V and BUILD_OFFLOAD_COMPRESS")
+  endif()
+endif()
+
+# Setup the library version
+rocm_setup_version(VERSION ${VERSION_STRING})
+math(EXPR hipcub_VERSION_NUMBER "${hipcub_VERSION_MAJOR} * 100000 + ${hipcub_VERSION_MINOR} * 100 + ${hipcub_VERSION_PATCH}")
+
 # Find and verify HIP.
 include(VerifyCompiler)
 
@@ -128,23 +181,45 @@ if(BUILD_ADDRESS_SANITIZER)
   add_link_options(-fuse-ld=lld)
 endif()
 
-# Setup VERSION
-set(VERSION_STRING "3.4.0")
-rocm_setup_version(VERSION ${VERSION_STRING})
+include(CheckCXXCompilerFlag)
 
-# Print configuration summary
-include(cmake/Summary.cmake)
-print_configuration_summary()
+if(BUILD_OFFLOAD_COMPRESS)
+  # We need to pass '-x hip' since check_cxx_compiler_flag assumes c++ and not HIP. 
+  check_cxx_compiler_flag("--offload-compress -x hip" CXX_COMPILER_SUPPORTS_OFFLOAD_COMPRESS)
+  if(CXX_COMPILER_SUPPORTS_OFFLOAD_COMPRESS)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --offload-compress")
+  else()
+    message(STATUS "Warning: BUILD_OFFLOAD_COMPRESS=ON but flag not supported by compiler. Ignoring option.")
+  endif()
+endif()
 
 # hipCUB library
 add_subdirectory(hipcub)
 
+if(CODE_COVERAGE)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -fprofile-instr-generate -fcoverage-mapping")
+endif()
+
 if(BUILD_TEST OR (BUILD_BENCHMARK AND NOT ONLY_INSTALL))
   rocm_package_setup_component(clients)
 endif()
 
 # Tests
 if(BUILD_TEST)
+  if(USE_SYSTEM_LIB)
+    # On ROCm hipCUB requires rocPRIM
+    if(HIP_COMPILER STREQUAL "clang")
+      find_package(rocprim REQUIRED CONFIG PATHS "/opt/rocm/lib/cmake/rocprim")
+      if (${rocprim_VERSION} VERSION_LESS ${MIN_ROCPRIM_PACKAGE_VERSION})
+        message(WARNING "The installed rocprim version, ${rocprim_VERSION}, is less than the minimum required version ${MIN_ROCPRIM_PACKAGE_VERSION}. Building tests with USE_SYSTEM_LIB=ON may not work properly.")
+      endif()
+    endif()
+    find_package(hipcub REQUIRED CONFIG PATHS "/opt/rocm/lib/cmake/hipcub")
+    if (NOT ${hipcub_VERSION} VERSION_EQUAL ${VERSION_STRING})
+      message(WARNING "The installed hipcub version, ${hipcub_VERSION}, does not match project version ${VERSION_STRING}. Building tests with USE_SYSTEM_LIB=ON may not work properly.")
+    endif()
+  endif()
+
   enable_testing()
   rocm_package_setup_client_component(tests)
   add_subdirectory(test)
@@ -161,18 +236,6 @@ if(BUILD_BENCHMARK AND NOT ONLY_INSTALL)
   add_subdirectory(benchmark)
 endif()
 
-# Create header wrapper for backward compatibility
-if(BUILD_FILE_REORG_BACKWARD_COMPATIBILITY AND NOT WIN32)
-  rocm_wrap_header_dir(
-            ${PROJECT_SOURCE_DIR}/hipcub/include/hipcub/
-	    PATTERNS "*.h"
-	    PATTERN "*.hpp"
-	    GUARDS SYMLINK WRAPPER
-	    WRAPPER_LOCATIONS cub/${CMAKE_INSTALL_INCLUDEDIR}/hipcub/
-            OUTPUT_LOCATIONS cub/wrapper/include/hipcub/
-	  )
-endif()
-
 # Package
 if(HIP_COMPILER STREQUAL "clang")
   rocm_package_add_deb_dependencies(DEPENDS "rocprim-dev >= 2.10.1")
@@ -205,3 +268,7 @@ else()
     HEADER_ONLY
   )
 endif()
+
+# Print configuration summary
+include(cmake/Summary.cmake)
+print_configuration_summary()
diff --git a/LICENSE.txt b/LICENSE.txt
index c284d2b..4bbc4ad 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,9 +1,10 @@
 Copyright (c) 2010-2011, Duane Merrill.  All rights reserved.
 Copyright (c) 2011-2018, NVIDIA CORPORATION.  All rights reserved.
-Modifications Copyright (c) 2019-2021, Advanced Micro Devices, Inc.  All rights reserved.
+Modifications Copyright (c) 2019-2025, Advanced Micro Devices, Inc.  All rights reserved.
  
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
+
    *  Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
    *  Redistributions in binary form must reproduce the above copyright
diff --git a/README.md b/README.md
index 6a0ad19..c144d1f 100644
--- a/README.md
+++ b/README.md
@@ -1,56 +1,28 @@
 # hipCUB
 
 > [!NOTE]
-> The published documentation is available at [hipCUB](https://rocm.docs.amd.com/projects/hipCUB/en/latest/index.html) in an organized, easy-to-read format, with search and a table of contents. The documentation source files reside in the `docs` folder of this repository. As with all ROCm projects, the documentation is open source. For more information on contributing to the documentation, see [Contribute to ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html).
+> The published hipCUB documentation is available [here](https://rocm.docs.amd.com/projects/hipCUB/en/latest/) in an organized, easy-to-read format, with search and a table of contents. The documentation source files reside in the `docs` folder of this repository. As with all ROCm projects, the documentation is open source. For more information on contributing to the documentation, see [Contribute to ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html).
 
 hipCUB is a thin wrapper library on top of
-[rocPRIM](https://github.com/ROCm/rocPRIM) or
-[CUB](https://github.com/thrust/cub). You can use it to port a CUB project into
+[rocPRIM](https://github.com/ROCm/rocm-libraries) or
+[CUB](https://github.com/nvidia/cccl). You can use it to port a CUB project into
 [HIP](https://github.com/ROCm/HIP) so you can use AMD hardware (and
 [ROCm](https://rocm.docs.amd.com/en/latest/) software).
 
 In the [ROCm](https://rocm.docs.amd.com/en/latest/)
-environment, hipCUB uses the rocPRIM library as the backend. On CUDA platforms, it uses CUB as the
-backend.
-
-## Documentation
-
-Documentation for hipCUB is available at
-[https://rocm.docs.amd.com/projects/hipCUB/en/latest/](https://rocm.docs.amd.com/projects/hipCUB/en/latest/).
-
-To build our documentation locally, run the following code:
-
-```shell
-# Go to the hipCUB docs directory
-cd hipCUB; cd docs
-
-# Install required pip packages
-python3 -m pip install -r .sphinx/requirements.txt
-
-# Build the documentation
-python3 -m sphinx -T -E -b html -d _build/doctrees -D language=en . _build/html
-
-# For e.g. serve the HTML docs locally
-cd _build/html
-python3 -m http.server
-```
+environment, hipCUB uses the rocPRIM library as the backend.
 
 ## Requirements
 
 * Git
-* CMake (3.16 or later)
+* CMake (3.18 or later)
 * For AMD GPUs:
   * AMD [ROCm](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/how-to/native-install/index.html) software (1.8.0 or later)
     * The [HIP-clang](https://github.com/ROCm/HIP/blob/master/INSTALL.md#hip-clang) compiler (you
       must, set this as the C++ compiler for ROCm)
-  * The [rocPRIM](https://github.com/ROCm/rocPRIM) library
+  * The [rocPRIM](https://github.com/ROCm/rocm-libraries) library
     * Automatically downloaded and built by the CMake script
     * Requires CMake 3.16.9 or later
-* For NVIDIA GPUs:
-  * CUDA Toolkit
-  * CCCL library (>= 2.5.0)
-    * Automatically downloaded and built by the CMake script
-    * Requires CMake 3.15.0 or later
 * Python 3.6 or higher (for HIP on Windows only; this is only required for install scripts)
 * Visual Studio 2019 with Clang support (HIP on Windows only)
 * Strawberry Perl (HIP on Windows only)
@@ -64,31 +36,53 @@ GoogleTest and Google Benchmark are automatically downloaded and built by the CM
 
 ## Build and install
 
-To build and install hipCub, run the following code:
+### Obtaining the source code
+
+hipCUB can be cloned in two ways:
+
+1.  Clone hipCUB along with other ROCm libraries that are frequently used together (note that this may take some time to complete):
+```sh
+git clone https://github.com/ROCm/rocm-libraries.git
+cd rocm-libraries
+```
+
+2. To clone hipCUB individually (faster, but requires git version 2.25+):
+```sh
+git clone --no-checkout --depth=1 --filter=tree:0 https://github.com/ROCm/rocm-libraries.git
+cd rocm-libraries
+git sparse-checkout init --cone
+git sparse-checkout set projects/hipcub
+git checkout develop
+```
+
+### Building the library
 
 ```shell
-git clone https://github.com/ROCm/hipCUB.git
+# Go to the hipCUB directory.
+cd projects/hipcub
 
-# Go to hipCUB directory, create and go to the build directory.
-cd hipCUB; mkdir build; cd build
+# Create a directory for the build and navigate to it.
+mkdir build; cd build
 
 # Configure hipCUB, setup options for your system.
 # Build options:
-#   BUILD_TEST - OFF by default,
-#   BUILD_BENCHMARK - OFF by default.
-#   DEPENDENCIES_FORCE_DOWNLOAD - OFF by default and at ON the dependencies will be downloaded to build folder,
+#   BUILD_TEST                   - OFF by default,
+#   BUILD_BENCHMARK              - OFF by default.
+#   ROCPRIM_FETCH_METHOD         - One of PACKAGE (default), DOWNLOAD, and MONOREPO. See below for a description of each.
+#   EXTERNAL_DEPS_FORCE_DOWNLOAD - OFF by default, forces download for non-ROCm dependencies (eg. Google Test / Benchmark).
+#   DOWNLOAD_CUB                 - OFF by default, (Nvidia CUB backend only) forces download of CUB instead of searching for an installed package.
+#   BUILD_OFFLOAD_COMPRESS       - ON by default, compresses device code to reduce the size of the generated binary.
+#   BUILD_EXAMPLE                - OFF by default, builds examples.
+#   BUILD_ADDRESS_SANITIZER      - OFF by default, builds with clang address sanitizer enabled.
+#   BUILD_COMPUTE_SANITIZER      - OFF by default, (Nvidia CUB backend only) builds tests with CUDA's compute sanitizer enabled.
+#   USE_SYSTEM_LIB               - OFF by default, builds tests using the installed hipCUB provided by the system. This only takes effect when BUILD_TEST is ON.
+#   USE_HIPCXX                   - OFF by default, builds with CMake HIP language support. This eliminates the need to set CXX.
 #
 # ! IMPORTANT !
 # Set C++ compiler to HIP-aware clang. You can do it by adding 'CXX=<path-to-compiler>'
 # before 'cmake' or setting cmake option 'CMAKE_CXX_COMPILER' to path to the compiler.
 #
 [CXX=hipcc] cmake ../. # or cmake-gui ../.
-
-# To configure hipCUB for Nvidia platforms, 'CXX=<path-to-nvcc>', `CXX=nvcc` or omitting the flag
-# entirely before 'cmake' is sufficient
-[CXX=nvcc] cmake -DBUILD_TEST=ON ../. # or cmake-gui ../.
-# or
-cmake -DBUILD_TEST=ON ../. # or cmake-gui ../.
 # or to build benchmarks
 cmake -DBUILD_BENCHMARK=ON ../.
 
@@ -105,20 +99,31 @@ make package
 [sudo] make install
 ```
 
+`ROCPRIM_FETCH_METHOD` can be used to control how hipCUB obtains the rocPRIM dependency. It must be set to one of the following values:
+* `PACKAGE` (default) - Searches for an installed package on the system that meets the minimum version requirement. If it is not found, the build will fall back using option `DOWNLOAD`.
+* `DOWNLOAD` - Clones rocPRIM from the upstream repository. If git >= 2.25 is present, this option uses a sparse checkout that avoids downloading more than it needs to. If not, the whole monorepo is downloaded (this may take some time).
+* `MONOREPO` - This value is intended to be used if you are building hipCUB from within a copy of the rocm-libraries repository that you have cloned (and therefore already contains rocPRIM). When selected, the build will try find the dependency in the local repository tree. If it cannot be found, the build will attempt to use git to perform a sparse-checkout of rocPRIM. If that also fails, it will fall back to using the `DOWNLOAD` option described above.
+
 ### HIP on Windows
 
 Initial support for HIP on Windows is available. You can install it using the provided `rmake.py` Python
-script:
+script. To do this, first, clone rocThrust using the steps described in [obtaining the source code](#obtaining-the-source-code).
+Next:
 
 ```shell
-git clone https://github.com/ROCm/hipCUB.git
-cd hipCUB
+cd projects/hipcub
 
 # the -i option will install rocPRIM to C:\hipSDK by default
 python rmake.py -i
 
 # the -c option will build all clients including unit tests
 python rmake.py -c
+
+# to build for a specific architecture only, use the -a option
+python rmake.py -ci -a gfx1100
+
+# for a full list of available options, please refer to the help documentation
+python rmake.py -h
 ```
 
 ### Using hipCUB
@@ -127,15 +132,13 @@ To use hipCUB in a CMake project, we recommended using the package configuration
 
 ```cmake
 # On ROCm hipCUB requires rocPRIM
-find_package(rocprim REQUIRED CONFIG PATHS "/opt/rocm/rocprim")
+find_package(rocprim REQUIRED CONFIG PATHS "/opt/rocm/lib/cmake/rocprim")
 
 # "/opt/rocm" - default install prefix
-find_package(hipcub REQUIRED CONFIG PATHS "/opt/rocm/hipcub")
+find_package(hipcub REQUIRED CONFIG PATHS "/opt/rocm/lib/cmake/hipcub")
 
 ...
 # On ROCm: includes hipCUB headers and roc::rocprim_hip target
-# On CUDA: includes only hipCUB headers, user has to include CUB directory
-target_link_libraries(<your_target> hip::hipcub)
 ```
 
 Include only the main header file:
@@ -150,7 +153,7 @@ Depending on your current HIP platform, hipCUB includes CUB or rocPRIM headers.
 
 ```shell
 # Go to hipCUB build directory
-cd hipCUB; cd build
+cd projects/hipcub; cd build
 
 # To run all tests
 ctest
@@ -161,7 +164,7 @@ ctest
 
 ### Using custom seeds for the tests
 
-Go to the `hipCUB/test/hipcub/test_seed.hpp` file.
+Go to the `projects/hipcub/test/hipcub/test_seed.hpp` file.
 
 ```cpp
 //(1)
@@ -190,7 +193,7 @@ static constexpr size_t seed_size = sizeof(seeds) / sizeof(seeds[0]);
 
 ```shell
 # Go to hipCUB build directory
-cd hipCUB; cd build
+cd projects/hipcub; cd build
 
 # To run benchmark for warp functions:
 # Further option can be found using --help
@@ -208,10 +211,67 @@ cd hipCUB; cd build
 ./benchmark/benchmark_device_<function_name> [--size <size>] [--trials <trials>]
 ```
 
+## Building the documentation locally
+
+### Requirements
+
+#### Doxygen
+
+The build system uses Doxygen [version 1.9.4](https://github.com/doxygen/doxygen/releases/tag/Release_1_9_4). You can try using a newer version, but that might cause issues.
+
+After you have downloaded Doxygen version 1.9.4:
+
+```shell
+# Add doxygen to your PATH
+echo 'export PATH=<doxygen 1.9.4 path>/bin:$PATH' >> ~/.bashrc
+
+# Apply the updated .bashrc
+source ~/.bashrc
+
+# Confirm that you are using version 1.9.4
+doxygen --version
+```
+
+#### Python
+
+The build system uses Python version 3.10. You can try using a newer version, but that might cause issues.
+
+You can install Python 3.10 alongside your other Python versions using [pyenv](https://github.com/pyenv/pyenv?tab=readme-ov-file#installation):
+
+```shell
+# Install Python 3.10
+pyenv install 3.10
+
+# Create a Python 3.10 virtual environment
+pyenv virtualenv 3.10 venv_hipcub
+
+# Activate the virtual environment
+pyenv activate venv_hipcub
+```
+
+### Building
+
+After cloning this repository (see [obtaining the source code](#obtaining-the-source-code)):
+
+```shell
+cd rocm-libraries/projects/hipcub
+
+# Install Python dependencies
+python3 -m pip install -r docs/sphinx/requirements.txt
+
+# Build the documentation
+python3 -m sphinx -T -E -b html -d docs/_build/doctrees -D language=en docs docs/_build/html
+```
+
+You can then open `docs/_build/html/index.html` in your browser to view the documentation.
+
 ## Support
 
-Bugs and feature requests can be reported through the
-[GitHub issue tracker](https://github.com/ROCm/hipCUB/issues).
+You can report bugs and feature requests through the GitHub
+[issue tracker](https://github.com/ROCm/rocm-libraries/issues).
+To help ensure that your issue is seen by the right team more quickly, when creating your issue, please apply the label `project: hipcub`.
+Similarly, to filter the exising issue list down to only those affecting rocThrust, you can add the filter `label:"project: hipcub"`,
+or follow [this link](https://github.com/ROCm/rocm-libraries/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22project%3A%20hipcub%22).
 
 ## Contributing
 
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 4a38bac..3e8f663 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2020-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (c) 2020-2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -36,7 +36,7 @@ function(add_hipcub_benchmark BENCHMARK_SOURCE)
       hipcub
   )
   if((HIP_COMPILER STREQUAL "nvcc"))
-    set_property(TARGET ${BENCHMARK_TARGET} PROPERTY CUDA_STANDARD 14)
+    set_property(TARGET ${BENCHMARK_TARGET} PROPERTY CUDA_STANDARD 17)
     set_source_files_properties(${BENCHMARK_SOURCE} PROPERTIES LANGUAGE CUDA)
     target_compile_options(${BENCHMARK_TARGET}
       PRIVATE
@@ -88,6 +88,7 @@ add_hipcub_benchmark(benchmark_device_batch_memcpy.cpp)
 add_hipcub_benchmark(benchmark_device_for.cpp)
 add_hipcub_benchmark(benchmark_device_histogram.cpp)
 add_hipcub_benchmark(benchmark_device_memory.cpp)
+add_hipcub_benchmark(benchmark_device_merge.cpp)
 add_hipcub_benchmark(benchmark_device_merge_sort.cpp)
 add_hipcub_benchmark(benchmark_device_partition.cpp)
 add_hipcub_benchmark(benchmark_device_radix_sort.cpp)
diff --git a/benchmark/benchmark_block_adjacent_difference.cpp b/benchmark/benchmark_block_adjacent_difference.cpp
index 1cc7079..7c7ac6b 100644
--- a/benchmark/benchmark_block_adjacent_difference.cpp
+++ b/benchmark/benchmark_block_adjacent_difference.cpp
@@ -23,10 +23,9 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/block/block_adjacent_difference.hpp"
-
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_store.hpp"
+#include <hipcub/block/block_adjacent_difference.hpp>
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_store.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 128;
diff --git a/benchmark/benchmark_block_discontinuity.cpp b/benchmark/benchmark_block_discontinuity.cpp
index 24446c9..5e36160 100644
--- a/benchmark/benchmark_block_discontinuity.cpp
+++ b/benchmark/benchmark_block_discontinuity.cpp
@@ -20,14 +20,13 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#include "common_benchmark_header.hpp"
-
 // HIP API
-#include "hipcub/block/block_discontinuity.hpp"
+#include <hipcub/block/block_discontinuity.hpp>
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_store.hpp>
+#include <hipcub/thread/thread_operators.hpp> //to use hipcub::Equality
 
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_store.hpp"
-#include "hipcub/thread/thread_operators.hpp" //to use hipcub::Equality
+#include "common_benchmark_header.hpp"
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 128;
diff --git a/benchmark/benchmark_block_exchange.cpp b/benchmark/benchmark_block_exchange.cpp
index a36d041..000cd41 100644
--- a/benchmark/benchmark_block_exchange.cpp
+++ b/benchmark/benchmark_block_exchange.cpp
@@ -23,9 +23,9 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/block/block_exchange.hpp"
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_store.hpp"
+#include <hipcub/block/block_exchange.hpp>
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_store.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_block_histogram.cpp b/benchmark/benchmark_block_histogram.cpp
index 122ccc3..1206e04 100644
--- a/benchmark/benchmark_block_histogram.cpp
+++ b/benchmark/benchmark_block_histogram.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/block/block_histogram.hpp"
+#include <hipcub/block/block_histogram.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 128;
diff --git a/benchmark/benchmark_block_merge_sort.cpp b/benchmark/benchmark_block_merge_sort.cpp
index 8316764..c8c7402 100644
--- a/benchmark/benchmark_block_merge_sort.cpp
+++ b/benchmark/benchmark_block_merge_sort.cpp
@@ -24,9 +24,9 @@
 
 #include "../test/hipcub/test_utils_sort_comparator.hpp"
 // HIP API
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_merge_sort.hpp"
-#include "hipcub/block/block_store.hpp"
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_merge_sort.hpp>
+#include <hipcub/block/block_store.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 128;
diff --git a/benchmark/benchmark_block_radix_rank.cpp b/benchmark/benchmark_block_radix_rank.cpp
index 2dac0a5..ffcd1d7 100644
--- a/benchmark/benchmark_block_radix_rank.cpp
+++ b/benchmark/benchmark_block_radix_rank.cpp
@@ -23,11 +23,11 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_radix_rank.hpp"
-#include "hipcub/block/block_store.hpp"
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_radix_rank.hpp>
+#include <hipcub/block/block_store.hpp>
 
-#include "hipcub/block/radix_rank_sort_operations.hpp"
+#include <hipcub/block/radix_rank_sort_operations.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 128;
diff --git a/benchmark/benchmark_block_radix_sort.cpp b/benchmark/benchmark_block_radix_sort.cpp
index 0bae7b8..4b75c26 100644
--- a/benchmark/benchmark_block_radix_sort.cpp
+++ b/benchmark/benchmark_block_radix_sort.cpp
@@ -23,9 +23,9 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_radix_sort.hpp"
-#include "hipcub/block/block_store.hpp"
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_radix_sort.hpp>
+#include <hipcub/block/block_store.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 128;
diff --git a/benchmark/benchmark_block_reduce.cpp b/benchmark/benchmark_block_reduce.cpp
index bdb089e..fe4b815 100644
--- a/benchmark/benchmark_block_reduce.cpp
+++ b/benchmark/benchmark_block_reduce.cpp
@@ -23,8 +23,8 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/block/block_reduce.hpp"
-#include "hipcub/thread/thread_operators.hpp"
+#include <hipcub/block/block_reduce.hpp>
+#include <hipcub/thread/thread_operators.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_block_run_length_decode.cpp b/benchmark/benchmark_block_run_length_decode.cpp
index 6769fd4..a42d3c4 100644
--- a/benchmark/benchmark_block_run_length_decode.cpp
+++ b/benchmark/benchmark_block_run_length_decode.cpp
@@ -22,9 +22,9 @@
 
 #include "common_benchmark_header.hpp"
 
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_run_length_decode.hpp"
-#include "hipcub/block/block_store.hpp"
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_run_length_decode.hpp>
+#include <hipcub/block/block_store.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_block_scan.cpp b/benchmark/benchmark_block_scan.cpp
index 340d3b4..51bf6c6 100644
--- a/benchmark/benchmark_block_scan.cpp
+++ b/benchmark/benchmark_block_scan.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // hipCUB API
-#include "hipcub/block/block_scan.hpp"
+#include <hipcub/block/block_scan.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_block_shuffle.cpp b/benchmark/benchmark_block_shuffle.cpp
index 4ba9fb0..697d381 100644
--- a/benchmark/benchmark_block_shuffle.cpp
+++ b/benchmark/benchmark_block_shuffle.cpp
@@ -22,7 +22,7 @@
 
 #include "common_benchmark_header.hpp"
 
-#include "hipcub/block/block_shuffle.hpp"
+#include <hipcub/block/block_shuffle.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_device_batch_copy.cpp b/benchmark/benchmark_device_batch_copy.cpp
index feca312..909c50b 100644
--- a/benchmark/benchmark_device_batch_copy.cpp
+++ b/benchmark/benchmark_device_batch_copy.cpp
@@ -24,10 +24,10 @@
 #include "cmdparser.hpp"
 #include "common_benchmark_header.hpp"
 
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_store.hpp"
-#include "hipcub/device/device_copy.hpp"
-#include "hipcub/hipcub.hpp"
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_store.hpp>
+#include <hipcub/device/device_copy.hpp>
+#include <hipcub/hipcub.hpp>
 
 #include <hip/hip_runtime.h>
 
diff --git a/benchmark/benchmark_device_batch_memcpy.cpp b/benchmark/benchmark_device_batch_memcpy.cpp
index f0f38be..8de4f8e 100644
--- a/benchmark/benchmark_device_batch_memcpy.cpp
+++ b/benchmark/benchmark_device_batch_memcpy.cpp
@@ -24,10 +24,10 @@
 #include "cmdparser.hpp"
 #include "common_benchmark_header.hpp"
 
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_store.hpp"
-#include "hipcub/device/device_memcpy.hpp"
-#include "hipcub/hipcub.hpp"
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_store.hpp>
+#include <hipcub/device/device_memcpy.hpp>
+#include <hipcub/hipcub.hpp>
 
 #ifdef __HIP_PLATFORM_AMD__
     // Only include this on AMD as it contains specialized config information
@@ -37,6 +37,7 @@
 #include <hip/hip_runtime.h>
 
 #include <iostream>
+#include <memory>
 #include <numeric>
 #include <random>
 #include <utility>
diff --git a/benchmark/benchmark_device_for.cpp b/benchmark/benchmark_device_for.cpp
index a5669ed..4b7a7d7 100644
--- a/benchmark/benchmark_device_for.cpp
+++ b/benchmark/benchmark_device_for.cpp
@@ -1,6 +1,6 @@
 // MIT License
 //
-// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -26,7 +26,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_for.hpp"
+#include <hipcub/device/device_for.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
@@ -71,7 +71,7 @@ void run_benchmark(benchmark::State& state, hipStream_t stream, size_t size)
     // Warm-up
     for(size_t i = 0; i < warmup_size; i++)
     {
-        HIP_CHECK(hipcub::ForEach(d_input, d_input + size, device_op, stream));
+        HIP_CHECK(hipcub::DeviceFor::ForEach(d_input, d_input + size, device_op, stream));
     }
     HIP_CHECK(hipDeviceSynchronize());
 
@@ -81,7 +81,7 @@ void run_benchmark(benchmark::State& state, hipStream_t stream, size_t size)
 
         for(size_t i = 0; i < batch_size; i++)
         {
-            HIP_CHECK(hipcub::ForEach(d_input, d_input + size, device_op, stream));
+            HIP_CHECK(hipcub::DeviceFor::ForEach(d_input, d_input + size, device_op, stream));
         }
         HIP_CHECK(hipStreamSynchronize(stream));
 
diff --git a/benchmark/benchmark_device_histogram.cpp b/benchmark/benchmark_device_histogram.cpp
index a5019e4..ded31e2 100644
--- a/benchmark/benchmark_device_histogram.cpp
+++ b/benchmark/benchmark_device_histogram.cpp
@@ -29,8 +29,8 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_histogram.hpp"
-#include "hipcub/iterator/transform_input_iterator.hpp"
+#include <hipcub/device/device_histogram.hpp>
+#include <hipcub/iterator/transform_input_iterator.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_device_memory.cpp b/benchmark/benchmark_device_memory.cpp
index bb256ac..1e62167 100644
--- a/benchmark/benchmark_device_memory.cpp
+++ b/benchmark/benchmark_device_memory.cpp
@@ -1,6 +1,6 @@
 // MIT License
 //
-// Copyright (c) 2022-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2022-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -22,9 +22,9 @@
 
 #include "common_benchmark_header.hpp"
 
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_scan.hpp"
-#include "hipcub/block/block_store.hpp"
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_scan.hpp>
+#include <hipcub/block/block_store.hpp>
 
 enum memory_operation_method
 {
@@ -58,9 +58,10 @@ struct operation;
 template<typename T, unsigned int ItemsPerThread, unsigned int BlockSize>
 struct operation<no_operation, T, ItemsPerThread, BlockSize>
 {
-    typedef empty_storage_type storage_type;
+    using storage_type = empty_storage_type;
 
-    HIPCUB_DEVICE inline void
+    HIPCUB_DEVICE
+    inline void
         operator()(storage_type& /*storage*/, T (&)[ItemsPerThread], T* = nullptr) const
     {}
 };
@@ -69,11 +70,13 @@ struct operation<no_operation, T, ItemsPerThread, BlockSize>
 template<typename T, unsigned int ItemsPerThread, unsigned int BlockSize>
 struct operation<custom_operation, T, ItemsPerThread, BlockSize>
 {
-    typedef empty_storage_type storage_type;
+    using storage_type = empty_storage_type;
 
-    HIPCUB_DEVICE inline void operator()(storage_type& storage,
-                                         T (&input)[ItemsPerThread],
-                                         T* global_mem_output = nullptr) const
+    HIPCUB_DEVICE
+    inline void
+        operator()(storage_type& storage,
+                   T (&input)[ItemsPerThread],
+                   T* global_mem_output = nullptr) const
     {
         (void)storage;
         (void)global_mem_output;
@@ -96,14 +99,15 @@ struct operation<custom_operation, T, ItemsPerThread, BlockSize>
 template<typename T, unsigned int ItemsPerThread, unsigned int BlockSize>
 struct operation<block_scan, T, ItemsPerThread, BlockSize>
 {
-    typedef
-        typename hipcub::BlockScan<T, BlockSize, hipcub::BlockScanAlgorithm::BLOCK_SCAN_WARP_SCANS>
-                                                  block_scan_type;
-    typedef typename block_scan_type::TempStorage storage_type;
-
-    HIPCUB_DEVICE inline void operator()(storage_type& storage,
-                                         T (&input)[ItemsPerThread],
-                                         T* global_mem_output = nullptr)
+    using block_scan_type =
+        typename hipcub::BlockScan<T, BlockSize, hipcub::BlockScanAlgorithm::BLOCK_SCAN_WARP_SCANS>;
+    using storage_type = typename block_scan_type::TempStorage;
+
+    HIPCUB_DEVICE
+    inline void
+        operator()(storage_type& storage,
+                   T (&input)[ItemsPerThread],
+                   T* global_mem_output = nullptr)
     {
         (void)global_mem_output;
 
@@ -117,11 +121,13 @@ struct operation<block_scan, T, ItemsPerThread, BlockSize>
 template<typename T, unsigned int ItemsPerThread, unsigned int BlockSize>
 struct operation<atomics_no_collision, T, ItemsPerThread, BlockSize>
 {
-    typedef empty_storage_type storage_type;
+    using storage_type = empty_storage_type;
 
-    HIPCUB_DEVICE inline void operator()(storage_type& storage,
-                                         T (&input)[ItemsPerThread],
-                                         T* global_mem_output = nullptr)
+    HIPCUB_DEVICE
+    inline void
+        operator()(storage_type& storage,
+                   T (&input)[ItemsPerThread],
+                   T* global_mem_output = nullptr)
     {
         (void)storage;
         (void)input;
@@ -140,11 +146,13 @@ struct operation<atomics_no_collision, T, ItemsPerThread, BlockSize>
 template<typename T, unsigned int ItemsPerThread, unsigned int BlockSize>
 struct operation<atomics_inter_warp_collision, T, ItemsPerThread, BlockSize>
 {
-    typedef empty_storage_type storage_type;
+    using storage_type = empty_storage_type;
 
-    HIPCUB_DEVICE inline void operator()(storage_type& storage,
-                                         T (&input)[ItemsPerThread],
-                                         T* global_mem_output = nullptr)
+    HIPCUB_DEVICE
+    inline void
+        operator()(storage_type& storage,
+                   T (&input)[ItemsPerThread],
+                   T* global_mem_output = nullptr)
     {
         (void)storage;
         (void)input;
@@ -163,11 +171,13 @@ struct operation<atomics_inter_warp_collision, T, ItemsPerThread, BlockSize>
 template<typename T, unsigned int ItemsPerThread, unsigned int BlockSize>
 struct operation<atomics_inter_block_collision, T, ItemsPerThread, BlockSize>
 {
-    typedef empty_storage_type storage_type;
+    using storage_type = empty_storage_type;
 
-    HIPCUB_DEVICE inline void operator()(storage_type& storage,
-                                         T (&input)[ItemsPerThread],
-                                         T* global_mem_output = nullptr)
+    HIPCUB_DEVICE
+    inline void
+        operator()(storage_type& storage,
+                   T (&input)[ItemsPerThread],
+                   T* global_mem_output = nullptr)
     {
         (void)storage;
         (void)input;
@@ -237,9 +247,9 @@ template<typename T,
          typename CustomOp>
 __global__ __launch_bounds__(BlockSize) void operation_kernel(T* input, T* output, CustomOp op)
 {
-    typedef memory_operation<MemOp>                                              mem_op;
-    typedef hipcub::BlockLoad<T, BlockSize, ItemsPerThread, mem_op::load_type>   load_type;
-    typedef hipcub::BlockStore<T, BlockSize, ItemsPerThread, mem_op::store_type> store_type;
+    using mem_op     = memory_operation<MemOp>;
+    using load_type  = hipcub::BlockLoad<T, BlockSize, ItemsPerThread, mem_op::load_type>;
+    using store_type = hipcub::BlockStore<T, BlockSize, ItemsPerThread, mem_op::store_type>;
 
     __shared__ union
     {
diff --git a/benchmark/benchmark_device_merge.cpp b/benchmark/benchmark_device_merge.cpp
new file mode 100644
index 0000000..e22d6ea
--- /dev/null
+++ b/benchmark/benchmark_device_merge.cpp
@@ -0,0 +1,364 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "common_benchmark_header.hpp"
+
+// HIP API
+#include <hipcub/device/device_merge.hpp>
+
+#ifndef DEFAULT_N
+const size_t DEFAULT_N = 1024 * 1024 * 32;
+#endif
+
+const unsigned int batch_size  = 10;
+const unsigned int warmup_size = 5;
+
+template<class key_type>
+struct CompareFunction
+{
+    HIPCUB_HOST_DEVICE
+    inline constexpr bool
+        operator()(const key_type& a, const key_type& b)
+    {
+        return a < b;
+    }
+};
+
+template<class Key>
+void run_merge_keys_benchmark(benchmark::State& state, hipStream_t stream, size_t size)
+{
+    using key_type = Key;
+
+    CompareFunction<key_type> compare_function;
+
+    const size_t size1 = size / 2;
+    const size_t size2 = size - size1;
+
+    std::vector<key_type> keys_input1 = benchmark_utils::get_random_data<key_type>(
+        size1,
+        benchmark_utils::generate_limits<key_type>::min(),
+        benchmark_utils::generate_limits<key_type>::max());
+
+    std::vector<key_type> keys_input2 = benchmark_utils::get_random_data<key_type>(
+        size2,
+        benchmark_utils::generate_limits<key_type>::min(),
+        benchmark_utils::generate_limits<key_type>::max());
+
+    std::sort(keys_input1.begin(), keys_input1.end(), compare_function);
+    std::sort(keys_input2.begin(), keys_input2.end(), compare_function);
+
+    key_type* d_keys_input1;
+    HIP_CHECK(hipMalloc(&d_keys_input1, size1 * sizeof(key_type)));
+    HIP_CHECK(hipMemcpy(d_keys_input1,
+                        keys_input1.data(),
+                        size1 * sizeof(key_type),
+                        hipMemcpyHostToDevice));
+
+    key_type* d_keys_input2;
+    HIP_CHECK(hipMalloc(&d_keys_input2, size2 * sizeof(key_type)));
+    HIP_CHECK(hipMemcpy(d_keys_input2,
+                        keys_input2.data(),
+                        size2 * sizeof(key_type),
+                        hipMemcpyHostToDevice));
+
+    key_type* d_keys_output;
+    HIP_CHECK(hipMalloc(&d_keys_output, size * sizeof(key_type)));
+
+    void*  d_temporary_storage     = nullptr;
+    size_t temporary_storage_bytes = 0;
+    HIP_CHECK(hipcub::DeviceMerge::MergeKeys(d_temporary_storage,
+                                             temporary_storage_bytes,
+                                             d_keys_input1,
+                                             size1,
+                                             d_keys_input2,
+                                             size2,
+                                             d_keys_output,
+                                             compare_function,
+                                             stream));
+
+    HIP_CHECK(hipMalloc(&d_temporary_storage, temporary_storage_bytes));
+
+    // Warm-up
+    for(size_t i = 0; i < warmup_size; i++)
+    {
+        HIP_CHECK(hipcub::DeviceMerge::MergeKeys(d_temporary_storage,
+                                                 temporary_storage_bytes,
+                                                 d_keys_input1,
+                                                 size1,
+                                                 d_keys_input2,
+                                                 size2,
+                                                 d_keys_output,
+                                                 compare_function,
+                                                 stream));
+    }
+    HIP_CHECK(hipDeviceSynchronize());
+
+    for(auto _ : state)
+    {
+        auto start = std::chrono::high_resolution_clock::now();
+
+        for(size_t i = 0; i < batch_size; i++)
+        {
+            HIP_CHECK(hipcub::DeviceMerge::MergeKeys(d_temporary_storage,
+                                                     temporary_storage_bytes,
+                                                     d_keys_input1,
+                                                     size1,
+                                                     d_keys_input2,
+                                                     size2,
+                                                     d_keys_output,
+                                                     compare_function,
+                                                     stream));
+        }
+        HIP_CHECK(hipDeviceSynchronize());
+
+        auto end = std::chrono::high_resolution_clock::now();
+        auto elapsed_seconds
+            = std::chrono::duration_cast<std::chrono::duration<double>>(end - start);
+        state.SetIterationTime(elapsed_seconds.count());
+    }
+    state.SetBytesProcessed(state.iterations() * batch_size * size * sizeof(key_type));
+    state.SetItemsProcessed(state.iterations() * batch_size * size);
+
+    HIP_CHECK(hipFree(d_temporary_storage));
+    HIP_CHECK(hipFree(d_keys_input1));
+    HIP_CHECK(hipFree(d_keys_input2));
+    HIP_CHECK(hipFree(d_keys_output));
+}
+
+template<class Key, class Value>
+void run_merge_pairs_benchmark(benchmark::State& state, hipStream_t stream, size_t size)
+{
+    using key_type   = Key;
+    using value_type = Value;
+
+    CompareFunction<key_type> compare_function;
+
+    const size_t size1 = size / 2;
+    const size_t size2 = size - size1;
+
+    std::vector<key_type> keys_input1 = benchmark_utils::get_random_data<key_type>(
+        size1,
+        benchmark_utils::generate_limits<key_type>::min(),
+        benchmark_utils::generate_limits<key_type>::max());
+    std::vector<key_type> keys_input2 = benchmark_utils::get_random_data<key_type>(
+        size2,
+        benchmark_utils::generate_limits<key_type>::min(),
+        benchmark_utils::generate_limits<key_type>::max());
+
+    std::sort(keys_input1.begin(), keys_input1.end(), compare_function);
+    std::sort(keys_input2.begin(), keys_input2.end(), compare_function);
+
+    key_type* d_keys_input1;
+    HIP_CHECK(hipMalloc(&d_keys_input1, size1 * sizeof(key_type)));
+    HIP_CHECK(hipMemcpy(d_keys_input1,
+                        keys_input1.data(),
+                        size1 * sizeof(key_type),
+                        hipMemcpyHostToDevice));
+
+    key_type* d_keys_input2;
+    HIP_CHECK(hipMalloc(&d_keys_input2, size2 * sizeof(key_type)));
+    HIP_CHECK(hipMemcpy(d_keys_input2,
+                        keys_input2.data(),
+                        size2 * sizeof(key_type),
+                        hipMemcpyHostToDevice));
+
+    key_type* d_keys_output;
+    HIP_CHECK(hipMalloc(&d_keys_output, size * sizeof(key_type)));
+
+    std::vector<value_type> values_input1(size1);
+    std::iota(values_input1.begin(), values_input1.end(), 0);
+    value_type* d_values_input1;
+    HIP_CHECK(hipMalloc(&d_values_input1, size1 * sizeof(value_type)));
+    HIP_CHECK(hipMemcpy(d_values_input1,
+                        values_input1.data(),
+                        size1 * sizeof(value_type),
+                        hipMemcpyHostToDevice));
+
+    std::vector<value_type> values_input2(size2);
+    std::iota(values_input2.begin(), values_input2.end(), size1);
+    value_type* d_values_input2;
+    HIP_CHECK(hipMalloc(&d_values_input2, size2 * sizeof(value_type)));
+    HIP_CHECK(hipMemcpy(d_values_input2,
+                        values_input2.data(),
+                        size2 * sizeof(value_type),
+                        hipMemcpyHostToDevice));
+
+    value_type* d_values_output;
+    HIP_CHECK(hipMalloc(&d_values_output, size * sizeof(value_type)));
+
+    void*  d_temporary_storage     = nullptr;
+    size_t temporary_storage_bytes = 0;
+    HIP_CHECK(hipcub::DeviceMerge::MergePairs(d_temporary_storage,
+                                              temporary_storage_bytes,
+                                              d_keys_input1,
+                                              d_values_input1,
+                                              size1,
+                                              d_keys_input2,
+                                              d_values_input2,
+                                              size2,
+                                              d_keys_output,
+                                              d_values_output,
+                                              compare_function,
+                                              stream));
+
+    HIP_CHECK(hipMalloc(&d_temporary_storage, temporary_storage_bytes));
+
+    // Warm-up
+    for(size_t i = 0; i < warmup_size; i++)
+    {
+        HIP_CHECK(hipcub::DeviceMerge::MergePairs(d_temporary_storage,
+                                                  temporary_storage_bytes,
+                                                  d_keys_input1,
+                                                  d_values_input1,
+                                                  size1,
+                                                  d_keys_input2,
+                                                  d_values_input2,
+                                                  size2,
+                                                  d_keys_output,
+                                                  d_values_output,
+                                                  compare_function,
+                                                  stream));
+    }
+    HIP_CHECK(hipDeviceSynchronize());
+
+    for(auto _ : state)
+    {
+        auto start = std::chrono::high_resolution_clock::now();
+
+        for(size_t i = 0; i < batch_size; i++)
+        {
+            HIP_CHECK(hipcub::DeviceMerge::MergePairs(d_temporary_storage,
+                                                      temporary_storage_bytes,
+                                                      d_keys_input1,
+                                                      d_values_input1,
+                                                      size1,
+                                                      d_keys_input2,
+                                                      d_values_input2,
+                                                      size2,
+                                                      d_keys_output,
+                                                      d_values_output,
+                                                      compare_function,
+                                                      stream));
+        }
+        HIP_CHECK(hipDeviceSynchronize());
+
+        auto end = std::chrono::high_resolution_clock::now();
+        auto elapsed_seconds
+            = std::chrono::duration_cast<std::chrono::duration<double>>(end - start);
+        state.SetIterationTime(elapsed_seconds.count());
+    }
+    state.SetBytesProcessed(state.iterations() * batch_size * size
+                            * (sizeof(key_type) + sizeof(value_type)));
+    state.SetItemsProcessed(state.iterations() * batch_size * size);
+
+    HIP_CHECK(hipFree(d_temporary_storage));
+    HIP_CHECK(hipFree(d_keys_input1));
+    HIP_CHECK(hipFree(d_keys_input2));
+    HIP_CHECK(hipFree(d_keys_output));
+    HIP_CHECK(hipFree(d_values_input1));
+    HIP_CHECK(hipFree(d_values_input2));
+    HIP_CHECK(hipFree(d_values_output));
+}
+
+#define CREATE_MERGE_KEYS_BENCHMARK(T)                 \
+    benchmarks.push_back(benchmark::RegisterBenchmark( \
+        std::string("device_merge_keys"                \
+                    "<key_data_type:" #T ">.")         \
+            .c_str(),                                  \
+        [=](benchmark::State& state) { run_merge_keys_benchmark<T>(state, stream, size); }));
+
+#define CREATE_MERGE_PAIRS_BENCHMARK(T, V)                            \
+    benchmarks.push_back(benchmark::RegisterBenchmark(                \
+        std::string("device_merge_pairs<"                             \
+                    ",key_data_type:" #T ",value_data_type:" #V ">.") \
+            .c_str(),                                                 \
+        [=](benchmark::State& state) { run_merge_pairs_benchmark<T, V>(state, stream, size); }));
+
+int main(int argc, char* argv[])
+{
+    cli::Parser parser(argc, argv);
+    parser.set_optional<size_t>("size", "size", DEFAULT_N, "number of values");
+    parser.set_optional<int>("trials", "trials", -1, "number of iterations");
+    parser.run_and_exit_if_error();
+
+    // Parse argv
+    benchmark::Initialize(&argc, argv);
+    const size_t size   = parser.get<size_t>("size");
+    const int    trials = parser.get<int>("trials");
+
+    // HIP
+    hipStream_t     stream = 0; // default
+    hipDeviceProp_t devProp;
+    int             device_id = 0;
+    HIP_CHECK(hipGetDevice(&device_id));
+    HIP_CHECK(hipGetDeviceProperties(&devProp, device_id));
+
+    std::cout << "benchmark_device_merge" << std::endl;
+    std::cout << "[HIP] Device name: " << devProp.name << std::endl;
+
+    // Add benchmarks
+    std::vector<benchmark::internal::Benchmark*> benchmarks;
+
+    using custom_float2      = benchmark_utils::custom_type<float, float>;
+    using custom_double2     = benchmark_utils::custom_type<double, double>;
+    using custom_char_double = benchmark_utils::custom_type<char, double>;
+    using custom_double_char = benchmark_utils::custom_type<double, char>;
+
+    CREATE_MERGE_KEYS_BENCHMARK(int)
+    CREATE_MERGE_KEYS_BENCHMARK(long long)
+    CREATE_MERGE_KEYS_BENCHMARK(int8_t)
+    CREATE_MERGE_KEYS_BENCHMARK(uint8_t)
+    CREATE_MERGE_KEYS_BENCHMARK(short)
+    CREATE_MERGE_KEYS_BENCHMARK(double)
+    CREATE_MERGE_KEYS_BENCHMARK(float)
+    CREATE_MERGE_KEYS_BENCHMARK(custom_float2)
+    CREATE_MERGE_KEYS_BENCHMARK(custom_double2)
+
+    CREATE_MERGE_PAIRS_BENCHMARK(int, int)
+    CREATE_MERGE_PAIRS_BENCHMARK(long long, long long)
+    CREATE_MERGE_PAIRS_BENCHMARK(int8_t, int8_t)
+    CREATE_MERGE_PAIRS_BENCHMARK(uint8_t, uint8_t)
+    CREATE_MERGE_PAIRS_BENCHMARK(short, short)
+    CREATE_MERGE_PAIRS_BENCHMARK(custom_char_double, custom_char_double)
+    CREATE_MERGE_PAIRS_BENCHMARK(int, custom_double_char)
+    CREATE_MERGE_PAIRS_BENCHMARK(custom_double2, custom_double2)
+
+    // Use manual timing
+    for(auto& b : benchmarks)
+    {
+        b->UseManualTime();
+        b->Unit(benchmark::kMillisecond);
+    }
+
+    // Force number of iterations
+    if(trials > 0)
+    {
+        for(auto& b : benchmarks)
+        {
+            b->Iterations(trials);
+        }
+    }
+
+    // Run benchmarks
+    benchmark::RunSpecifiedBenchmarks();
+    return 0;
+}
diff --git a/benchmark/benchmark_device_merge_sort.cpp b/benchmark/benchmark_device_merge_sort.cpp
index fc64fc0..284892c 100644
--- a/benchmark/benchmark_device_merge_sort.cpp
+++ b/benchmark/benchmark_device_merge_sort.cpp
@@ -23,8 +23,8 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_merge_sort.hpp"
-#include "hipcub/hipcub.hpp"
+#include <hipcub/device/device_merge_sort.hpp>
+#include <hipcub/hipcub.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 32 << 20;
diff --git a/benchmark/benchmark_device_partition.cpp b/benchmark/benchmark_device_partition.cpp
index 786fe13..f925e42 100644
--- a/benchmark/benchmark_device_partition.cpp
+++ b/benchmark/benchmark_device_partition.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_partition.hpp"
+#include <hipcub/device/device_partition.hpp>
 
 #include <chrono>
 #include <vector>
diff --git a/benchmark/benchmark_device_radix_sort.cpp b/benchmark/benchmark_device_radix_sort.cpp
index c65abd8..2e40b3b 100644
--- a/benchmark/benchmark_device_radix_sort.cpp
+++ b/benchmark/benchmark_device_radix_sort.cpp
@@ -26,7 +26,7 @@
 #include <type_traits>
 
 // HIP API
-#include "hipcub/device/device_radix_sort.hpp"
+#include <hipcub/device/device_radix_sort.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_device_reduce.cpp b/benchmark/benchmark_device_reduce.cpp
index 2a4d9df..8dcd968 100644
--- a/benchmark/benchmark_device_reduce.cpp
+++ b/benchmark/benchmark_device_reduce.cpp
@@ -21,9 +21,10 @@
 // SOFTWARE.
 
 #include "common_benchmark_header.hpp"
+#include "hipcub/config.hpp"
 
 // HIP API
-#include "hipcub/device/device_reduce.hpp"
+#include <hipcub/device/device_reduce.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 128;
@@ -118,8 +119,10 @@ struct Benchmark<T, hipcub::ArgMin>
 
     static void run(benchmark::State& state, size_t size, const hipStream_t stream)
     {
+        HIPCUB_CLANG_SUPPRESS_DEPRECATED_PUSH
         hipError_t (*ptr_to_argmin)(void*, size_t&, T*, KeyValue*, int, hipStream_t)
-            = &hipcub::DeviceReduce::ArgMin;
+        = &hipcub::DeviceReduce::ArgMin;
+        HIPCUB_CLANG_SUPPRESS_DEPRECATED_POP
         run_benchmark<T, KeyValue>(state, size, stream, ptr_to_argmin);
     }
 };
diff --git a/benchmark/benchmark_device_reduce_by_key.cpp b/benchmark/benchmark_device_reduce_by_key.cpp
index 54209e6..0d9160f 100644
--- a/benchmark/benchmark_device_reduce_by_key.cpp
+++ b/benchmark/benchmark_device_reduce_by_key.cpp
@@ -29,7 +29,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_reduce.hpp"
+#include <hipcub/device/device_reduce.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_device_run_length_encode.cpp b/benchmark/benchmark_device_run_length_encode.cpp
index b7ef64b..f0c8585 100644
--- a/benchmark/benchmark_device_run_length_encode.cpp
+++ b/benchmark/benchmark_device_run_length_encode.cpp
@@ -29,7 +29,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_run_length_encode.hpp"
+#include <hipcub/device/device_run_length_encode.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_device_scan.cpp b/benchmark/benchmark_device_scan.cpp
index dbfdda6..5d38b96 100644
--- a/benchmark/benchmark_device_scan.cpp
+++ b/benchmark/benchmark_device_scan.cpp
@@ -29,7 +29,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_scan.hpp"
+#include <hipcub/device/device_scan.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_device_segmented_radix_sort.cpp b/benchmark/benchmark_device_segmented_radix_sort.cpp
index 05566d6..252e8ff 100644
--- a/benchmark/benchmark_device_segmented_radix_sort.cpp
+++ b/benchmark/benchmark_device_segmented_radix_sort.cpp
@@ -1,6 +1,6 @@
 // MIT License
 //
-// Copyright (c) 2020-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2020-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/hipcub.hpp"
+#include <hipcub/hipcub.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
@@ -44,17 +44,17 @@ void run_sort_keys_benchmark(benchmark::State& state,
 {
     using offset_type = int;
     using key_type    = Key;
-    typedef hipError_t (*sort_func)(void*,
-                                    size_t&,
-                                    const key_type*,
-                                    key_type*,
-                                    int,
-                                    int,
-                                    offset_type*,
-                                    offset_type*,
-                                    int,
-                                    int,
-                                    hipStream_t);
+    using sort_func   = hipError_t (*)(void*,
+                                     size_t&,
+                                     const key_type*,
+                                     key_type*,
+                                     int,
+                                     int,
+                                     offset_type*,
+                                     offset_type*,
+                                     int,
+                                     int,
+                                     hipStream_t);
 
     sort_func func_ascending = &hipcub::DeviceSegmentedRadixSort::SortKeys<key_type, offset_type*>;
     sort_func func_descending
@@ -180,19 +180,19 @@ void run_sort_pairs_benchmark(benchmark::State& state,
     using offset_type = int;
     using key_type    = Key;
     using value_type  = Value;
-    typedef hipError_t (*sort_func)(void*,
-                                    size_t&,
-                                    const key_type*,
-                                    key_type*,
-                                    const value_type*,
-                                    value_type*,
-                                    int,
-                                    int,
-                                    offset_type*,
-                                    offset_type*,
-                                    int,
-                                    int,
-                                    hipStream_t);
+    using sort_func   = hipError_t (*)(void*,
+                                     size_t&,
+                                     const key_type*,
+                                     key_type*,
+                                     const value_type*,
+                                     value_type*,
+                                     int,
+                                     int,
+                                     offset_type*,
+                                     offset_type*,
+                                     int,
+                                     int,
+                                     hipStream_t);
 
     sort_func func_ascending
         = &hipcub::DeviceSegmentedRadixSort::SortPairs<key_type, value_type, offset_type*>;
diff --git a/benchmark/benchmark_device_segmented_reduce.cpp b/benchmark/benchmark_device_segmented_reduce.cpp
index d1e40c6..1bf1316 100644
--- a/benchmark/benchmark_device_segmented_reduce.cpp
+++ b/benchmark/benchmark_device_segmented_reduce.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_segmented_reduce.hpp"
+#include <hipcub/device/device_segmented_reduce.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_device_segmented_sort.cpp b/benchmark/benchmark_device_segmented_sort.cpp
index e9bbaf3..db69075 100644
--- a/benchmark/benchmark_device_segmented_sort.cpp
+++ b/benchmark/benchmark_device_segmented_sort.cpp
@@ -1,6 +1,6 @@
 // MIT License
 //
-// Copyright (c) 2020-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2020-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/hipcub.hpp"
+#include <hipcub/hipcub.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
@@ -42,15 +42,15 @@ void run_sort_keys_benchmark(benchmark::State& state,
 {
     using offset_type = int;
     using key_type    = Key;
-    typedef hipError_t (*sort_func)(void*,
-                                    size_t&,
-                                    const key_type*,
-                                    key_type*,
-                                    int,
-                                    int,
-                                    offset_type*,
-                                    offset_type*,
-                                    hipStream_t);
+    using sort_func   = hipError_t (*)(void*,
+                                     size_t&,
+                                     const key_type*,
+                                     key_type*,
+                                     int,
+                                     int,
+                                     offset_type*,
+                                     offset_type*,
+                                     hipStream_t);
 
     sort_func func_ascending = &hipcub::DeviceSegmentedSort::SortKeys<key_type, offset_type*>;
     sort_func func_descending
@@ -175,17 +175,17 @@ void run_sort_pairs_benchmark(benchmark::State& state,
     using offset_type = int;
     using key_type    = Key;
     using value_type  = Value;
-    typedef hipError_t (*sort_func)(void*,
-                                    size_t&,
-                                    const key_type*,
-                                    key_type*,
-                                    const value_type*,
-                                    value_type*,
-                                    int,
-                                    int,
-                                    offset_type*,
-                                    offset_type*,
-                                    hipStream_t);
+    using sort_func   = hipError_t (*)(void*,
+                                     size_t&,
+                                     const key_type*,
+                                     key_type*,
+                                     const value_type*,
+                                     value_type*,
+                                     int,
+                                     int,
+                                     offset_type*,
+                                     offset_type*,
+                                     hipStream_t);
 
     sort_func func_ascending
         = &hipcub::DeviceSegmentedSort::SortPairs<key_type, value_type, offset_type*>;
diff --git a/benchmark/benchmark_device_select.cpp b/benchmark/benchmark_device_select.cpp
index a14cbdd..04097ec 100644
--- a/benchmark/benchmark_device_select.cpp
+++ b/benchmark/benchmark_device_select.cpp
@@ -1,6 +1,6 @@
 // MIT License
 //
-// Copyright (c) 2020-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2020-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_select.hpp"
+#include <hipcub/device/device_select.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
@@ -307,12 +307,11 @@ void run_flagged_if_benchmark(benchmark::State& state,
     state.SetBytesProcessed(state.iterations() * batch_size * size * sizeof(T));
     state.SetItemsProcessed(state.iterations() * batch_size * size);
 
-    hipFree(d_input);
-    hipFree(d_flags);
-    hipFree(d_output);
-    hipFree(d_selected_count_output);
-    hipFree(d_temp_storage);
-    HIP_CHECK(hipDeviceSynchronize());
+    HIP_CHECK(hipFree(d_input));
+    HIP_CHECK(hipFree(d_flags));
+    HIP_CHECK(hipFree(d_output));
+    HIP_CHECK(hipFree(d_selected_count_output));
+    HIP_CHECK(hipFree(d_temp_storage));
 }
 
 template<class T>
diff --git a/benchmark/benchmark_device_spmv.cpp b/benchmark/benchmark_device_spmv.cpp
index f98f1c1..fcdb1ab 100644
--- a/benchmark/benchmark_device_spmv.cpp
+++ b/benchmark/benchmark_device_spmv.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/device/device_spmv.hpp"
+#include <hipcub/device/device_spmv.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 32;
@@ -126,6 +126,7 @@ void run_benchmark(benchmark::State& state,
     size_t temp_storage_size_bytes;
 
     // Get size of d_temp_storage
+    HIPCUB_CLANG_SUPPRESS_DEPRECATED_PUSH
     HIP_CHECK(hipcub::DeviceSpmv::CsrMV(nullptr,
                                         temp_storage_size_bytes,
                                         d_values,
@@ -137,6 +138,7 @@ void run_benchmark(benchmark::State& state,
                                         size,
                                         num_nonzeroes,
                                         stream));
+    HIPCUB_CLANG_SUPPRESS_DEPRECATED_POP
     HIP_CHECK(hipDeviceSynchronize());
 
     // allocate temporary storage
@@ -147,6 +149,7 @@ void run_benchmark(benchmark::State& state,
     // Warm-up
     for(size_t i = 0; i < warmup_size; i++)
     {
+        HIPCUB_CLANG_SUPPRESS_DEPRECATED_PUSH
         HIP_CHECK(hipcub::DeviceSpmv::CsrMV(d_temp_storage,
                                             temp_storage_size_bytes,
                                             d_values,
@@ -158,6 +161,7 @@ void run_benchmark(benchmark::State& state,
                                             size,
                                             num_nonzeroes,
                                             stream));
+        HIPCUB_CLANG_SUPPRESS_DEPRECATED_PUSH
     }
     HIP_CHECK(hipDeviceSynchronize());
 
@@ -166,6 +170,7 @@ void run_benchmark(benchmark::State& state,
         auto start = std::chrono::high_resolution_clock::now();
         for(size_t i = 0; i < batch_size; i++)
         {
+            HIPCUB_CLANG_SUPPRESS_DEPRECATED_PUSH
             HIP_CHECK(hipcub::DeviceSpmv::CsrMV(d_temp_storage,
                                                 temp_storage_size_bytes,
                                                 d_values,
@@ -177,6 +182,7 @@ void run_benchmark(benchmark::State& state,
                                                 size,
                                                 num_nonzeroes,
                                                 stream));
+            HIPCUB_CLANG_SUPPRESS_DEPRECATED_POP
         }
         HIP_CHECK(hipDeviceSynchronize());
 
diff --git a/benchmark/benchmark_utils.hpp b/benchmark/benchmark_utils.hpp
index 48a46b8..489cf8d 100644
--- a/benchmark/benchmark_utils.hpp
+++ b/benchmark/benchmark_utils.hpp
@@ -1,6 +1,6 @@
 // MIT License
 //
-// Copyright (c) 2020-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2020-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -29,13 +29,13 @@
 
 // hipCUB API
 #ifdef __HIP_PLATFORM_AMD__
-    #include "hipcub/backend/rocprim/util_ptx.hpp"
+    #include <hipcub/backend/rocprim/util_ptx.hpp>
 #elif defined(__HIP_PLATFORM_NVIDIA__)
-    #include "hipcub/config.hpp"
     #include <cub/util_ptx.cuh>
+    #include <hipcub/config.hpp>
 #endif
 
-#include "hipcub/tuple.hpp"
+#include <hipcub/tuple.hpp>
 
 #ifndef HIPCUB_CUB_API
     #define HIPCUB_WARP_THREADS_MACRO warpSize
@@ -409,6 +409,14 @@ template<unsigned int LogicalWarpSize>
 __device__ constexpr bool device_test_enabled_for_warp_size_v
     = HIPCUB_DEVICE_WARP_THREADS >= LogicalWarpSize;
 
+template<class T>
+__device__
+inline constexpr bool is_power_of_two(const T x)
+{
+    static_assert(std::is_integral<T>::value, "T must be integer type");
+    return (x > 0) && ((x & (x - 1)) == 0);
+}
+
 template<typename Iterator>
 using it_value_t = typename std::iterator_traits<Iterator>::value_type;
 
diff --git a/benchmark/benchmark_warp_exchange.cpp b/benchmark/benchmark_warp_exchange.cpp
index 598df95..0c41be0 100644
--- a/benchmark/benchmark_warp_exchange.cpp
+++ b/benchmark/benchmark_warp_exchange.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/warp/warp_exchange.hpp"
+#include <hipcub/warp/warp_exchange.hpp>
 
 #include <type_traits>
 
diff --git a/benchmark/benchmark_warp_load.cpp b/benchmark/benchmark_warp_load.cpp
index 4298db6..2c74609 100644
--- a/benchmark/benchmark_warp_load.cpp
+++ b/benchmark/benchmark_warp_load.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/warp/warp_load.hpp"
+#include <hipcub/warp/warp_load.hpp>
 
 #include <type_traits>
 
diff --git a/benchmark/benchmark_warp_merge_sort.cpp b/benchmark/benchmark_warp_merge_sort.cpp
index 5b2d87c..f6d91fe 100644
--- a/benchmark/benchmark_warp_merge_sort.cpp
+++ b/benchmark/benchmark_warp_merge_sort.cpp
@@ -24,10 +24,10 @@
 
 #include "../test/hipcub/test_utils_sort_comparator.hpp"
 // HIP API
-#include "hipcub/block/block_load.hpp"
-#include "hipcub/block/block_store.hpp"
-#include "hipcub/util_ptx.hpp"
-#include "hipcub/warp/warp_merge_sort.hpp"
+#include <hipcub/block/block_load.hpp>
+#include <hipcub/block/block_store.hpp>
+#include <hipcub/util_ptx.hpp>
+#include <hipcub/warp/warp_merge_sort.hpp>
 
 #include <type_traits>
 
diff --git a/benchmark/benchmark_warp_reduce.cpp b/benchmark/benchmark_warp_reduce.cpp
index 1a20d71..f8d08f6 100644
--- a/benchmark/benchmark_warp_reduce.cpp
+++ b/benchmark/benchmark_warp_reduce.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/warp/warp_reduce.hpp"
+#include <hipcub/warp/warp_reduce.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
diff --git a/benchmark/benchmark_warp_scan.cpp b/benchmark/benchmark_warp_scan.cpp
index ddd499c..db3fe94 100644
--- a/benchmark/benchmark_warp_scan.cpp
+++ b/benchmark/benchmark_warp_scan.cpp
@@ -1,6 +1,6 @@
 // MIT License
 //
-// Copyright (c) 2020-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2020-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/warp/warp_scan.hpp"
+#include <hipcub/warp/warp_scan.hpp>
 
 #ifndef DEFAULT_N
 const size_t DEFAULT_N = 1024 * 1024 * 32;
@@ -106,19 +106,22 @@ struct broadcast
     template<class T, unsigned int WarpSize, unsigned int Trials>
     __device__
     static auto run(const T* input, T* output, const T init)
-        -> std::enable_if_t<benchmark_utils::device_test_enabled_for_warp_size_v<WarpSize>>
+        -> std::enable_if_t<(benchmark_utils::device_test_enabled_for_warp_size_v<WarpSize>
+                             && benchmark_utils::is_power_of_two(WarpSize))>
     {
         (void)init;
 
-        const unsigned int i     = hipBlockIdx_x * hipBlockDim_x + hipThreadIdx_x;
-        auto               value = input[i];
+        const unsigned int i        = hipBlockIdx_x * hipBlockDim_x + hipThreadIdx_x;
+        const unsigned int warp_id  = i / WarpSize;
+        const unsigned int src_lane = warp_id % WarpSize;
+        auto               value    = input[i];
 
         using wscan_t = hipcub::WarpScan<T, WarpSize>;
         __shared__ typename wscan_t::TempStorage storage;
 #pragma nounroll
         for(unsigned int trial = 0; trial < Trials; trial++)
         {
-            value = wscan_t(storage).Broadcast(value, 0);
+            value = wscan_t(storage).Broadcast(value, src_lane);
         }
 
         output[i] = value;
@@ -127,7 +130,8 @@ struct broadcast
     template<class T, unsigned int WarpSize, unsigned int Trials>
     __device__
     static auto run(const T* /*input*/, T* /*output*/, const T /*init*/)
-        -> std::enable_if_t<!benchmark_utils::device_test_enabled_for_warp_size_v<WarpSize>>
+        -> std::enable_if_t<!(benchmark_utils::device_test_enabled_for_warp_size_v<WarpSize>
+                              && benchmark_utils::is_power_of_two(WarpSize))>
     {}
 };
 
@@ -188,61 +192,75 @@ void run_benchmark(benchmark::State& state, hipStream_t stream, size_t size)
 #define CREATE_BENCHMARK(T, BS, WS) CREATE_BENCHMARK_IMPL(T, BS, WS, Benchmark)
 
 // clang-format off
-// If warp size limit is 16
-#define BENCHMARK_TYPE_WS16(type)   \
-    CREATE_BENCHMARK(type, 60, 15), \
-    CREATE_BENCHMARK(type, 256, 16)
-
-
-// If warp size limit is 32
-#define BENCHMARK_TYPE_WS32(type)   \
-    BENCHMARK_TYPE_WS16(type),      \
-    CREATE_BENCHMARK(type, 62, 31), \
-    CREATE_BENCHMARK(type, 256, 32)
-
-
-// If warp size limit is 64
-#define BENCHMARK_TYPE_WS64(type)    \
-    BENCHMARK_TYPE_WS32(type),       \
-    CREATE_BENCHMARK(type, 63, 63),  \
-    CREATE_BENCHMARK(type, 64, 64),  \
-    CREATE_BENCHMARK(type, 128, 64), \
-    CREATE_BENCHMARK(type, 256, 64)
+#if HIPCUB_WARP_THREADS_MACRO == 32
+    #define BENCHMARK_TYPE(type)         \
+        CREATE_BENCHMARK(type, 60, 15),  \
+        CREATE_BENCHMARK(type, 256, 16), \
+        CREATE_BENCHMARK(type, 62, 31),  \
+        CREATE_BENCHMARK(type, 256, 32)
+#else
+    #define BENCHMARK_TYPE(type)         \
+        CREATE_BENCHMARK(type, 60, 15),  \
+        CREATE_BENCHMARK(type, 256, 16), \
+        CREATE_BENCHMARK(type, 62, 31),  \
+        CREATE_BENCHMARK(type, 256, 32), \
+        CREATE_BENCHMARK(type, 63, 63),  \
+        CREATE_BENCHMARK(type, 64, 64),  \
+        CREATE_BENCHMARK(type, 128, 64), \
+        CREATE_BENCHMARK(type, 256, 64)
+#endif
+
+#if HIPCUB_WARP_THREADS_MACRO == 32
+    #define BENCHMARK_TYPE_P2(type)      \
+        CREATE_BENCHMARK(type, 256, 16), \
+        CREATE_BENCHMARK(type, 256, 32)
+#else
+    #define BENCHMARK_TYPE_P2(type)      \
+        CREATE_BENCHMARK(type, 256, 16), \
+        CREATE_BENCHMARK(type, 256, 32), \
+        CREATE_BENCHMARK(type, 64, 64),  \
+        CREATE_BENCHMARK(type, 128, 64), \
+        CREATE_BENCHMARK(type, 256, 64)
+#endif
 // clang-format on
 
 template<typename Benchmark>
-void add_benchmarks(std::vector<benchmark::internal::Benchmark*>& benchmarks,
+auto add_benchmarks(std::vector<benchmark::internal::Benchmark*>& benchmarks,
                     const std::string&                            method_name,
                     hipStream_t                                   stream,
                     size_t                                        size)
+    -> std::enable_if_t<std::is_same<Benchmark, inclusive_scan>::value
+                        || std::is_same<Benchmark, exclusive_scan>::value>
 {
     using custom_double2    = benchmark_utils::custom_type<double, double>;
     using custom_int_double = benchmark_utils::custom_type<int, double>;
 
-    std::vector<benchmark::internal::Benchmark*> new_benchmarks = {
-#if HIPCUB_WARP_THREADS_MACRO == 16
-        BENCHMARK_TYPE_WS16(int),
-        BENCHMARK_TYPE_WS16(float),
-        BENCHMARK_TYPE_WS16(double),
-        BENCHMARK_TYPE_WS16(int8_t),
-        BENCHMARK_TYPE_WS16(custom_double2),
-        BENCHMARK_TYPE_WS16(custom_int_double)
-#elif HIPCUB_WARP_THREADS_MACRO == 32
-        BENCHMARK_TYPE_WS32(int),
-        BENCHMARK_TYPE_WS32(float),
-        BENCHMARK_TYPE_WS32(double),
-        BENCHMARK_TYPE_WS32(int8_t),
-        BENCHMARK_TYPE_WS32(custom_double2),
-        BENCHMARK_TYPE_WS32(custom_int_double)
-#else
-        BENCHMARK_TYPE_WS64(int),
-        BENCHMARK_TYPE_WS64(float),
-        BENCHMARK_TYPE_WS64(double),
-        BENCHMARK_TYPE_WS64(int8_t),
-        BENCHMARK_TYPE_WS64(custom_double2),
-        BENCHMARK_TYPE_WS64(custom_int_double)
-#endif
-    };
+    std::vector<benchmark::internal::Benchmark*> new_benchmarks
+        = {BENCHMARK_TYPE(int),
+           BENCHMARK_TYPE(float),
+           BENCHMARK_TYPE(double),
+           BENCHMARK_TYPE(int8_t),
+           BENCHMARK_TYPE(custom_double2),
+           BENCHMARK_TYPE(custom_int_double)};
+    benchmarks.insert(benchmarks.end(), new_benchmarks.begin(), new_benchmarks.end());
+}
+
+template<typename Benchmark>
+auto add_benchmarks(std::vector<benchmark::internal::Benchmark*>& benchmarks,
+                    const std::string&                            method_name,
+                    hipStream_t                                   stream,
+                    size_t size) -> std::enable_if_t<std::is_same<Benchmark, broadcast>::value>
+{
+    using custom_double2    = benchmark_utils::custom_type<double, double>;
+    using custom_int_double = benchmark_utils::custom_type<int, double>;
+
+    std::vector<benchmark::internal::Benchmark*> new_benchmarks
+        = {BENCHMARK_TYPE_P2(int),
+           BENCHMARK_TYPE_P2(float),
+           BENCHMARK_TYPE_P2(double),
+           BENCHMARK_TYPE_P2(int8_t),
+           BENCHMARK_TYPE_P2(custom_double2),
+           BENCHMARK_TYPE_P2(custom_int_double)};
     benchmarks.insert(benchmarks.end(), new_benchmarks.begin(), new_benchmarks.end());
 }
 
diff --git a/benchmark/benchmark_warp_store.cpp b/benchmark/benchmark_warp_store.cpp
index 8e88661..6632faf 100644
--- a/benchmark/benchmark_warp_store.cpp
+++ b/benchmark/benchmark_warp_store.cpp
@@ -23,7 +23,7 @@
 #include "common_benchmark_header.hpp"
 
 // HIP API
-#include "hipcub/warp/warp_store.hpp"
+#include <hipcub/warp/warp_store.hpp>
 
 #include <type_traits>
 
diff --git a/benchmark/common_benchmark_header.hpp b/benchmark/common_benchmark_header.hpp
index eab3048..a632840 100644
--- a/benchmark/common_benchmark_header.hpp
+++ b/benchmark/common_benchmark_header.hpp
@@ -1,6 +1,6 @@
 // MIT License
 //
-// Copyright (c) 2020 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2020-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -21,18 +21,18 @@
 // SOFTWARE.
 
 #include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdlib>
 #include <functional>
 #include <iostream>
+#include <limits>
+#include <numeric>
+#include <random>
+#include <tuple>
 #include <type_traits>
-#include <vector>
 #include <utility>
-#include <tuple>
-#include <random>
-#include <limits> 
-#include <cmath>
-#include <cstdlib>
-#include <numeric>
-#include <chrono>
+#include <vector>
 
 // Google Benchmark
 #include "benchmark/benchmark.h"
diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake
index 22d2a4a..36a5310 100644
--- a/cmake/Dependencies.cmake
+++ b/cmake/Dependencies.cmake
@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -66,6 +66,226 @@ endforeach()
 
 include(FetchContent)
 
+# This function checks to see if the download branch given by "branch" exists in the repository.
+# It does so using the git ls-remote command.
+# If the branch cannot be found, the variable described by "branch" is changed to "develop" in the host scope.
+function(find_download_branch git_path branch)
+  set(branch_value ${${branch}})
+  execute_process(COMMAND ${git_path} "ls-remote" "https://github.com/ROCm/rocm-libraries.git" "refs/heads/${branch_value}" RESULT_VARIABLE ret_code OUTPUT_VARIABLE output)
+
+  if(NOT ${ret_code} STREQUAL "0")
+    message(WARNING "Unable to check if release branch exists, defaulting to the develop branch.")
+    set(${branch} "develop" PARENT_SCOPE)
+  else()
+    if(${output})
+      string(STRIP ${output} output)
+    endif()
+
+    if(NOT (${output} MATCHES "[\t ]+refs/heads/${branch_value}(\n)?$"))
+      message(WARNING "Unable to locate requested release branch \"${branch_value}\" in repository. Defaulting to the develop branch.")
+      set(${branch} "develop" PARENT_SCOPE)
+    else()
+      message(STATUS "Found release branch \"${branch_value}\" in repository.")
+    endif()
+  endif()
+endfunction()
+
+function(check_git_version git_path)
+  execute_process(COMMAND ${git_path} "--version" OUTPUT_VARIABLE git_version_output)
+  string(REGEX MATCH "([0-9]+\.[0-9]+\.[0-9]+)" GIT_VERSION_STRING ${git_version_output})
+  if(DEFINED CMAKE_MATCH_0)
+    set(GIT_VERSION ${CMAKE_MATCH_0} PARENT_SCOPE)
+  else()
+    set(GIT_VERSION "" PARENT_SCOPE)
+  endif()
+endfunction()
+
+# This function fetches repository "repo_name" using the method specified by "method".
+# The result is stored in the parent scope version of "repo_path".
+# It does not build the repo.
+function(fetch_dep method repo_name repo_path download_branch)
+  set(method_value ${${method}})
+
+  # Since the monorepo is large, we want to avoid downloading the whole thing if possible.
+  # We can do this if we have access to git's sparse-checkout functionality, which was added in git 2.25.
+  # On some Linux systems (eg. Ubuntu), the git in /usr/bin tends to be newer than the git in /usr/local/bin,
+  # and the latter is what gets picked up by find_package(Git), since it's what's in PATH.
+  # Check for a git binary in /usr/bin first, then if git < 2.25 is not found, use find_package(Git) to search
+  # other locations.
+  if (NOT(GIT_PATH))
+    message(STATUS "Checking git version")
+    set(GIT_MIN_VERSION_FOR_SPARSE_CHECKOUT 2.25)
+
+    find_program(find_result git PATHS /usr/bin NO_DEFAULT_PATH)
+    if(NOT (${find_result} STREQUAL "find_result-NOTFOUND"))
+      set(GIT_PATH ${find_result} CACHE INTERNAL "Path to the git executable")
+      check_git_version(${GIT_PATH})
+    endif()
+
+    if(NOT GIT_VERSION OR "${GIT_VERSION}" LESS ${GIT_MIN_VERSION_FOR_SPARSE_CHECKOUT})
+      find_package(Git QUIET)
+      if(GIT_FOUND)
+        set(GIT_PATH ${GIT_EXECUTABLE} CACHE INTERNAL "Path to the git executable")
+        check_git_version(${GIT_PATH})
+      endif()
+    endif()
+
+    if(NOT GIT_VERSION OR "${GIT_VERSION}" LESS ${GIT_MIN_VERSION_FOR_SPARSE_CHECKOUT})
+      set(USE_SPARSE_CHECKOUT "OFF" CACHE INTERNAL "Records whether git supports sparse checkout functionality")
+    else()
+      set(USE_SPARSE_CHECKOUT "ON" CACHE INTERNAL "Records whether git supports sparse checkout functionality")
+    endif()
+
+    if(NOT GIT_VERSION)
+      # Warn the user that we were unable to find git. This will only actually be a problem if we use one of the
+      # fetch methods (download, or monorepo with dependency not present) that requires it. If we end up running
+      # into one of those scenarios, a fatal error will be issued at that point.
+      message(WARNING "Unable to find git.")
+    else()
+      message(STATUS "Found git at: ${GIT_PATH}, version: ${GIT_VERSION}")
+    endif()
+  endif()
+
+  if(${method_value} STREQUAL "PACKAGE")
+    message(STATUS "Searching for ${repo_name} package")
+
+    # Add default install location for WIN32 and non-WIN32 as hint
+    find_package(${repo_name} ${MIN_ROCPRIM_PACKAGE_VERSION} CONFIG QUIET PATHS "${ROCM_ROOT}/lib/cmake/rocprim")
+
+    if(NOT ${${repo_name}_FOUND})
+      message(STATUS "No existing ${repo_name} package meeting the minimum version requirement (${MIN_ROCPRIM_PACKAGE_VERSION}) was found. Falling back to downloading it.")
+      # update local and parent variable values
+      set(${method} "DOWNLOAD" PARENT_SCOPE)
+      set(method_value "DOWNLOAD")
+    else()
+      message(STATUS "Package found (${${repo_name}_DIR})")
+    endif()
+
+  elseif(${method_value} STREQUAL "MONOREPO")
+    message(STATUS "Searching for ${repo_name} in the parent monorepo directory")
+
+    # Check if this looks like a monorepo checkout
+    find_path(found_path NAMES "." PATHS "${CMAKE_CURRENT_SOURCE_DIR}/../../projects/${repo_name}/" NO_CACHE NO_DEFAULT_PATH)
+
+    # If not, see if the local monorepo is a sparse-checkout.
+    # If it is a sparse-checkout, try to add the dependency to the sparse-checkout list.
+    # If it's not a sparse-checkout (or adding to the sparse-checkout list fails), fallback to downloading the dependency.
+    if(${found_path} STREQUAL "found_path-NOTFOUND")
+      set(FALLBACK_TO_DOWNLOAD ON)
+      message(WARNING "Unable to locate ${repo_name} in parent monorepo (it's not at \"${CMAKE_CURRENT_SOURCE_DIR}/../../projects/${repo_name}/\").")
+      message(STATUS "Checking if local monorepo is a sparse-checkout that we can add ${repo_name} to.")
+      if(NOT(GIT_PATH))
+        message(FATAL_ERROR "Git could not be found on the system. Since ${repo_name} could not be found in the local monorepo, git is required to download it.")
+      endif()
+
+      if(USE_SPARSE_CHECKOUT)
+        execute_process(COMMAND ${GIT_PATH} "sparse-checkout" "list" OUTPUT_VARIABLE sparse_list ERROR_VARIABLE git_error RESULT_VARIABLE git_result
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../)
+
+        if(NOT(git_result EQUAL 0) OR git_error)
+          message(STATUS "The local monorepo does not appear to be a sparse-checkout.")
+        else()
+          message(STATUS "The local monorepo appears to be a sparse checkout. Attempting to add \"projects/${repo_name}\" to the checkout list.")
+          # Check if the dependency is already present in the checkout list.
+          # Git lists sparse checkout directories each on a separate line.
+          # Take care not to match something in the middle of a path, eg. "other_dir/projects/${repo_name}/sub_dir".
+          string(REGEX MATCH "(^|\n)projects/${repo_name}($|\n)" find_result ${sparse_list})
+          if(find_result)
+            message(STATUS "Found existing entry for \"projects/${repo_name}\" in sparse-checkout list - has the directory structure been modified?")
+          else()
+            # Add project/${repo_name} to the sparse checkout
+            execute_process(COMMAND ${GIT_PATH} "sparse-checkout" "add" "projects/${repo_name}" RESULT_VARIABLE sparse_checkout_result
+                            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../)
+            # Note that in this case, we are forced to checkout the same branch that the sparse-checkout was created with.
+            execute_process(COMMAND ${GIT_PATH} "checkout" RESULT_VARIABLE checkout_result
+                            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../)
+
+            if(sparse_checkout_result EQUAL 0 AND checkout_result EQUAL 0)
+              message(STATUS "Added new checkout list entry.")
+              set(FALLBACK_TO_DOWNLOAD OFF)
+            else()
+              message(STATUS "Unable to add new checkout list entry.")
+            endif()
+            # Save the monorepo path in the parent scope
+            set(${repo_path} "${CMAKE_CURRENT_SOURCE_DIR}/../../projects/${repo_name}" PARENT_SCOPE)
+          endif()
+        endif()
+      else()
+        message(STATUS "The version of git installed on the system (${GIT_VERSION}) does not support sparse-checkout.")
+      endif()
+
+      if (FALLBACK_TO_DOWNLOAD)
+        message(WARNING "Unable to locate/fetch dependency ${repo_name} from monorepo. Falling back to downloading it.")
+        # update local and parent variable values
+        set(${method} "DOWNLOAD" PARENT_SCOPE)
+        set(method_value "DOWNLOAD")
+      endif()
+
+    else()
+      message(STATUS "Found ${repo_name} at ${found_path}")
+
+      # Save the monorepo path in the parent scope
+      set(${repo_path} ${found_path} PARENT_SCOPE)
+    endif()
+  endif()
+
+  if(${method_value} STREQUAL "DOWNLOAD")
+    if(NOT DEFINED GIT_PATH)
+      message(FATAL_ERROR "Git could not be found on the system. Git is required for downloading ${repo_name}.")
+    endif()
+
+    message(STATUS "Checking if repository contains requested branch ${${download_branch}}")
+    find_download_branch(${GIT_PATH} ${download_branch})
+    set(download_branch_value ${${download_branch}})
+
+    message(STATUS "Downloading ${repo_name} from https://github.com/ROCm/rocm-libraries.git")
+    if(${USE_SPARSE_CHECKOUT})
+      # In this case, we have access to git sparse-checkout.
+      # Check if the dependency has already been downloaded in the past:
+      find_path(found_path NAMES "." PATHS "${CMAKE_CURRENT_BINARY_DIR}/${repo_name}-src/" NO_CACHE NO_DEFAULT_PATH)
+      if(${found_path} STREQUAL "found_path-NOTFOUND")
+        # First, git clone with options "--no-checkout" and "--filter=tree:0" to prevent files from being pulled immediately.
+        # Use option "--depth=1" to avoid downloading past commit history.
+        execute_process(COMMAND ${GIT_PATH} clone --branch ${download_branch_value} --no-checkout --depth=1 --filter=tree:0 https://github.com/ROCm/rocm-libraries.git ${CMAKE_CURRENT_BINARY_DIR}/${repo_name}-src)
+
+        # Next, use git sparse-checkout to ensure we only pull the directory containing the desired repo.
+        execute_process(COMMAND ${GIT_PATH} sparse-checkout init --cone
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${repo_name}-src)
+
+        execute_process(COMMAND ${GIT_PATH} sparse-checkout set projects/${repo_name}
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${repo_name}-src)
+
+        # Finally, download the files using git checkout.
+        execute_process(COMMAND ${GIT_PATH} checkout ${download_branch_value}
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${repo_name}-src)
+
+        message(STATUS "${repo_name} download complete")
+      else()
+        message("Found previously downloaded directory, skipping download step.")
+      endif()
+
+      # Save the downloaded path in the parent scope
+      set(${repo_path} "${CMAKE_CURRENT_BINARY_DIR}/${repo_name}-src/projects/${repo_name}" PARENT_SCOPE)
+    else()
+      # In this case, we do not have access to sparse-checkout, so we need to download the whole monorepo.
+      # Check if the monorepo has already been downloaded to satisfy a previous dependency
+      find_path(found_path NAMES "." PATHS "${CMAKE_CURRENT_BINARY_DIR}/monorepo-src/" NO_CACHE NO_DEFAULT_PATH)
+      if(${found_path} STREQUAL "found_path-NOTFOUND")
+        # Warn the user that this will take some time.
+        message(WARNING "The detected version of git (${GIT_VERSION}) is older than 2.25 and does not provide sparse-checkout functionality. Falling back to checking out the whole rocm-libraries repository (this may take a long time).")
+        # Avoid downloading anything related to branches other than the target branch (--single-branch), and avoid any past commit history information (--depth=1)
+        execute_process(COMMAND ${GIT_PATH} clone --single-branch --branch=${download_branch_value} --depth=1 https://github.com/ROCm/rocm-libraries.git ${CMAKE_CURRENT_BINARY_DIR}/monorepo-src)
+        message(STATUS "rocm-libraries download complete")
+      else()
+        message("Found previously downloaded directory, skipping download step.")
+      endif()
+
+      # Save the downloaded path in the parent scope
+      set(${repo_path} "${CMAKE_CURRENT_BINARY_DIR}/monorepo-src/projects/${repo_name}" PARENT_SCOPE)
+    endif()
+  endif()
+endfunction()
+
 # Test dependencies
 if(USER_BUILD_TEST)
   # NOTE1: Google Test has created a mess with legacy FindGTest.cmake and newer GTestConfig.cmake
@@ -83,14 +303,14 @@ if(USER_BUILD_TEST)
   #        mode targets. Otherwise if MODULE or CONFIG succeeded, then it prints the result to the
   #        console via a non-QUIET find_package call and if CONFIG succeeded, creates ALIAS targets
   #        with the MODULE IMPORTED names.
-  if(NOT DEPENDENCIES_FORCE_DOWNLOAD)
+  if(NOT EXTERNAL_DEPS_FORCE_DOWNLOAD)
     find_package(GTest QUIET)
   endif()
   if(NOT TARGET GTest::GTest AND NOT TARGET GTest::gtest)
     option(BUILD_GTEST "Builds the googletest subproject" ON)
     option(BUILD_GMOCK "Builds the googlemock subproject" OFF)
     option(INSTALL_GTEST "Enable installation of googletest." OFF)
-    if(EXISTS /usr/src/googletest AND NOT DEPENDENCIES_FORCE_DOWNLOAD)
+    if(EXISTS /usr/src/googletest AND NOT EXTERNAL_DEPS_FORCE_DOWNLOAD)
       FetchContent_Declare(
         googletest
         SOURCE_DIR /usr/src/googletest
@@ -116,7 +336,7 @@ if(USER_BUILD_TEST)
 endif(USER_BUILD_TEST)
 
 if(USER_BUILD_BENCHMARK)
-  if(NOT DEPENDENCIES_FORCE_DOWNLOAD)
+  if(NOT EXTERNAL_DEPS_FORCE_DOWNLOAD)
     find_package(benchmark CONFIG QUIET)
   endif()
   if(NOT TARGET benchmark::benchmark)
@@ -139,20 +359,13 @@ endif(USER_BUILD_BENCHMARK)
 
 # CUB (only for CUDA platform)
 if(HIP_COMPILER STREQUAL "nvcc")
-  set(CCCL_MINIMUM_VERSION 2.5.0)
+  set(CCCL_MINIMUM_VERSION 2.8.2)
   if(NOT DOWNLOAD_CUB)
-    find_package(CUB ${CCCL_MINIMUM_VERSION} CONFIG)
-    find_package(Thrust ${CCCL_MINIMUM_VERSION} CONFIG)
-    find_package(libcudacxx ${CCCL_MINIMUM_VERSION} CONFIG)
+    find_package(CCCL ${CCCL_MINIMUM_VERSION} CONFIG)
   endif()
 
-  if (NOT CUB_FOUND OR NOT Thrust_FOUND OR NOT libcudacxx_FOUND)
-    if(CUB_FOUND OR Thrust_FOUND OR libcudacxx_FOUND)
-      message(WARNING "Found one of CUB, Thrust or libcu++, but not all of them.
-                       This can lead to mixing different potentially incompatible versions.")
-    endif()
-
-    message(STATUS "CUB, Thrust or libcu++ not found, downloading and extracting CCCL ${CCCL_MINIMUM_VERSION}")
+  if (NOT CCCL_FOUND)
+    message(STATUS "CCCL not found, downloading and extracting CCCL ${CCCL_MINIMUM_VERSION}")
     file(DOWNLOAD https://github.com/NVIDIA/cccl/archive/refs/tags/v${CCCL_MINIMUM_VERSION}.zip
                   ${CMAKE_CURRENT_BINARY_DIR}/cccl-${CCCL_MINIMUM_VERSION}.zip
          STATUS cccl_download_status LOG cccl_download_log)
@@ -176,25 +389,24 @@ if(HIP_COMPILER STREQUAL "nvcc")
       endif()
     endif()
 
-    find_package(CUB ${CCCL_MINIMUM_VERSION} CONFIG REQUIRED NO_DEFAULT_PATH
-                 PATHS ${CMAKE_CURRENT_BINARY_DIR}/cccl-${CCCL_MINIMUM_VERSION}/cub)
-    find_package(Thrust ${CCCL_MINIMUM_VERSION} CONFIG REQUIRED NO_DEFAULT_PATH
-                 PATHS ${CMAKE_CURRENT_BINARY_DIR}/cccl-${CCCL_MINIMUM_VERSION}/thrust)
-    find_package(libcudacxx ${CCCL_MINIMUM_VERSION} CONFIG REQUIRED NO_DEFAULT_PATH
-                 PATHS ${CMAKE_CURRENT_BINARY_DIR}/cccl-${CCCL_MINIMUM_VERSION}/libcudacxx)
+    find_package(CCCL ${CCCL_MINIMUM_VERSION} CONFIG REQUIRED NO_DEFAULT_PATH
+                 PATHS ${CMAKE_CURRENT_BINARY_DIR}/cccl-${CCCL_MINIMUM_VERSION})
   endif()
 else()
   # rocPRIM (only for ROCm platform)
-  if(NOT DEPENDENCIES_FORCE_DOWNLOAD)
-    # Add default install location for WIN32 and non-WIN32 as hint
-    find_package(rocprim CONFIG QUIET PATHS "${ROCM_ROOT}/lib/cmake/rocprim")
-  endif()
-  if(NOT TARGET roc::rocprim)
-    message(STATUS "rocPRIM not found. Fetching...")
+  fetch_dep(ROCPRIM_FETCH_METHOD rocprim ROCPRIM_PATH ROCM_DEP_RELEASE_BRANCH)
+
+  if(${ROCPRIM_FETCH_METHOD} STREQUAL "DOWNLOAD" OR ${ROCPRIM_FETCH_METHOD} STREQUAL "MONOREPO")
+    # The fetch_dep call above should have downloaded/located the source. We just need to make it available.
+    message(STATUS "Configuring rocPRIM")
     FetchContent_Declare(
-            prim
-            GIT_REPOSITORY https://github.com/ROCm/rocPRIM.git
-            GIT_TAG        develop
+      prim
+      SOURCE_DIR    ${ROCPRIM_PATH}
+      INSTALL_DIR   ${CMAKE_CURRENT_BINARY_DIR}/deps/rocprim
+      CMAKE_ARGS    -DBUILD_TEST=OFF -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> -DCMAKE_PREFIX_PATH=/opt/rocm
+      LOG_CONFIGURE TRUE
+      LOG_BUILD     TRUE
+      LOG_INSTALL   TRUE
     )
     FetchContent_MakeAvailable(prim)
     if(NOT TARGET roc::rocprim)
@@ -203,8 +415,6 @@ else()
     if(NOT TARGET roc::rocprim_hip)
       add_library(roc::rocprim_hip ALIAS rocprim_hip)
     endif()
-  else()
-    find_package(rocprim CONFIG REQUIRED)
   endif()
 endif()
 
diff --git a/cmake/GenerateResourceSpec.cmake b/cmake/GenerateResourceSpec.cmake
index 7810a20..d485ca4 100644
--- a/cmake/GenerateResourceSpec.cmake
+++ b/cmake/GenerateResourceSpec.cmake
@@ -17,10 +17,11 @@ execute_process(
 
 if(ROCMINFO_EXIT_CODE)
   message(SEND_ERROR "rocminfo exited with ${ROCMINFO_EXIT_CODE}")
+  message(SEND_ERROR ${ROCMINFO_STDOUT})
   message(FATAL_ERROR ${ROCMINFO_STDERR})
 endif()
 
-string(REGEX MATCHALL [[--(gfx[0-9]+)]]
+string(REGEX MATCHALL [[--(gfx[0-9a-f]+)]]
   ROCMINFO_MATCHES
   ${ROCMINFO_STDOUT}
 )
@@ -37,7 +38,7 @@ string(REGEX MATCHALL [[--(gfx[0-9]+)]]
 #   std::string ip;
 #   int id;
 # };
-# 
+#
 # std::vector<device> GFXIP_AND_ID{ {"gfx900",0},{"gfx803",1},{"gfx900",2} };
 # std::sort(GFXIP_AND_ID.begin(), GFXIP_AND_ID.end(),
 #           [](const device& lhs, const device& rhs)
@@ -85,14 +86,14 @@ list(SORT GFXIP_AND_ID)
 set(JSON_PAYLOAD)
 set(IT1 0)
 list(GET GFXIP_AND_ID ${IT1} I1)
-string(REGEX REPLACE ":[0-9]+" "" IP1 ${I1})
+string(REGEX REPLACE ":[0-9a-f]+" "" IP1 ${I1})
 list(LENGTH GFXIP_AND_ID COUNT)
 while(IT1 LESS COUNT)
   string(APPEND JSON_PAYLOAD "\n      \"${IP1}\": [")
   set(IT2 ${IT1})
   list(GET GFXIP_AND_ID ${IT2} I2)
-  string(REGEX REPLACE [[:[0-9]+$]] "" IP2 ${I2})
-  string(REGEX REPLACE [[^gfx[0-9]+:]] "" ID2 ${I2})
+  string(REGEX REPLACE [[:[0-9a-f]+$]] "" IP2 ${I2})
+  string(REGEX REPLACE [[^gfx[0-9a-f]+:]] "" ID2 ${I2})
   while(${IP2} STREQUAL ${IP1} AND IT2 LESS COUNT)
     string(APPEND JSON_PAYLOAD
              "\n        {\n"
@@ -102,8 +103,8 @@ while(IT1 LESS COUNT)
     math(EXPR IT2 "${IT2} + 1")
     if(IT2 LESS COUNT)
       list(GET GFXIP_AND_ID ${IT2} I2)
-      string(REGEX REPLACE [[:[0-9]+$]] "" IP2 ${I2})
-      string(REGEX REPLACE [[^gfx[0-9]+:]] "" ID2 ${I2})
+      string(REGEX REPLACE [[:[0-9a-f]+$]] "" IP2 ${I2})
+      string(REGEX REPLACE [[^gfx[0-9a-f]+:]] "" ID2 ${I2})
     endif()
   endwhile()
   string(REGEX REPLACE [[,$]] "" JSON_PAYLOAD ${JSON_PAYLOAD})
diff --git a/cmake/ROCmCMakeBuildToolsDependency.cmake b/cmake/ROCmCMakeBuildToolsDependency.cmake
index 3f8e1fc..8c913b5 100644
--- a/cmake/ROCmCMakeBuildToolsDependency.cmake
+++ b/cmake/ROCmCMakeBuildToolsDependency.cmake
@@ -49,6 +49,5 @@ include(ROCMCreatePackage)
 include(ROCMInstallTargets)
 include(ROCMPackageConfigHelpers)
 include(ROCMInstallSymlinks)
-include(ROCMHeaderWrapper)
 include(ROCMCheckTargetIds)
 include(ROCMClients)
diff --git a/cmake/SetupNVCC.cmake b/cmake/SetupNVCC.cmake
index 5ec377d..46b88d2 100644
--- a/cmake/SetupNVCC.cmake
+++ b/cmake/SetupNVCC.cmake
@@ -81,7 +81,7 @@ endif()
 
 # Get CUDA
 enable_language("CUDA")
-set(CMAKE_CUDA_STANDARD 14)
+set(CMAKE_CUDA_STANDARD 17)
 
 # Suppressing warnings
 set(HIP_NVCC_FLAGS " ${HIP_NVCC_FLAGS} -Wno-deprecated-gpu-targets -Xcompiler -Wno-return-type -Wno-deprecated-declarations ")
diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake
index 7a9af98..9dd5035 100644
--- a/cmake/Summary.cmake
+++ b/cmake/Summary.cmake
@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2017-2023 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -21,6 +21,39 @@
 # SOFTWARE.
 
 function(print_configuration_summary)
+    find_package(Git)
+    if(GIT_FOUND)
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} show --format=%H --no-patch
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+        OUTPUT_VARIABLE COMMIT_HASH
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} show --format=%s --no-patch
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+        OUTPUT_VARIABLE COMMIT_SUBJECT
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    endif()
+
+    execute_process(
+    COMMAND ${CMAKE_CXX_COMPILER} --version
+    WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+    OUTPUT_VARIABLE CMAKE_CXX_COMPILER_VERBOSE_DETAILS
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    find_program(UNAME_EXECUTABLE uname)
+    if(UNAME_EXECUTABLE)
+    execute_process(
+        COMMAND ${UNAME_EXECUTABLE} -a
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+        OUTPUT_VARIABLE LINUX_KERNEL_DETAILS
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    endif()
+
     message(STATUS "")
     message(STATUS "******** Summary ********")
     message(STATUS "General:")
@@ -55,8 +88,24 @@ else()
     message(STATUS "  Device targets        : ${NVGPU_TARGETS}")
 endif()
     message(STATUS "")
-    message(STATUS "  DEPENDENCIES_FORCE_DOWNLOAD : ${DEPENDENCIES_FORCE_DOWNLOAD}")
+    message(STATUS "  EXTERNAL_DEPS_FORCE_DOWNLOAD: ${EXTERNAL_DEPS_FORCE_DOWNLOAD}")
+    message(STATUS "  ROCPRIM_FETCH_METHOD        : ${ROCPRIM_FETCH_METHOD}")
     message(STATUS "  BUILD_TEST                  : ${BUILD_TEST}")
+if(BUILD_TEST)
+    message(STATUS "  CODE_COVERAGE               : ${CODE_COVERAGE}")
+endif()
     message(STATUS "  BUILD_BENCHMARK             : ${BUILD_BENCHMARK}")
     message(STATUS "  BUILD_ADDRESS_SANITIZER     : ${BUILD_ADDRESS_SANITIZER}")
+    message(STATUS "  BUILD_OFFLOAD_COMPRESS      : ${BUILD_OFFLOAD_COMPRESS}")
+    message(STATUS "  USE_SYSTEM_LIB              : ${USE_SYSTEM_LIB}")     
+    message(STATUS "")
+    message(STATUS "Detailed:")
+    message(STATUS "  C++ compiler details  : \n${CMAKE_CXX_COMPILER_VERBOSE_DETAILS}")
+if(GIT_FOUND)
+    message(STATUS "  Commit                : ${COMMIT_HASH}")
+    message(STATUS "                          ${COMMIT_SUBJECT}")
+endif()
+if(UNAME_EXECUTABLE)
+    message(STATUS "  Unix name             : ${LINUX_KERNEL_DETAILS}")
+endif()
 endfunction()
diff --git a/debian/changelog b/debian/changelog
index a096666..2dc9fc0 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,28 @@
+hipcub (7.1.0-0ubuntu2) resolute; urgency=medium
+
+  * Revert to upstream toolchain (from ROCm LLVM fork)
+    - d/control: update dependencies and rollback from ROCm fork
+    - d/{control, tests/control}: drop ppc64el architecture from tests
+
+ -- Bruno Bernardo de Moura <[e-mail]>  Fri, 23 Jan 2026 10:36:40 -0300
+
+hipcub (7.1.0-0ubuntu1) resolute; urgency=medium
+
+  * New upstream version 7.1.0
+  * d/p/0001-install-cmake-config-to-share.patch: refresh patch
+  * d/p/0002-default-thread-load-store-cache-modifiers-to-off.patch:
+    remove patch as suggested on patch description
+
+ -- Bruno Bernardo de Moura <[e-mail]>  Wed, 07 Jan 2026 13:45:35 -0300
+
+hipcub (6.4.3-2ubuntu1) questing; urgency=medium
+
+  * d/control: update maintainer field
+  * d/rules: fix FTBFS by adding -Wl,--gc-sections to flags
+  * d/control: update build-depends
+
+ -- Igor Luppi <[e-mail]>  Tue, 28 Oct 2025 12:39:22 -0300
+
 hipcub (6.4.3-2) unstable; urgency=medium
 
   * Add d/p/0002-default-thread-load-store-cache-modifiers-to-off.patch
diff --git a/debian/control b/debian/control
index ced5ff6..33f2971 100644
--- a/debian/control
+++ b/debian/control
@@ -5,17 +5,18 @@ Priority: optional
 Standards-Version: 4.7.2
 Vcs-Git: https://salsa.debian.org/rocm-team/hipcub.git
 Vcs-Browser: https://salsa.debian.org/rocm-team/hipcub
-Maintainer: Debian ROCm Team <[e-mail]>
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Debian ROCm Team <[e-mail]>
 Uploaders: Cordell Bloor <[e-mail]>,
            Christian Kastner <[e-mail]>,
            Kari Pahula <[e-mail]>
 Build-Depends: debhelper-compat (= 13),
                cmake,
-               hipcc (>= 7.0.1~),
-               libamd-comgr-dev (>= 6.4~),
+               hipcc (>= 7.1~),
+               libamd-comgr-dev (>= 7.1~),
                libgtest-dev <!nocheck>,
-               libhsa-runtime-dev (>= 6.4~),
-               librocprim-dev (>= 6.4.1~),
+               libhsa-runtime-dev (>= 7.1~),
+               librocprim-dev (>= 7.1~),
                pkg-rocm-tools (>= 0.9.3~),
                rocm-cmake
 Rules-Requires-Root: no
@@ -33,7 +34,7 @@ Description: portable interface for GPU parallel primitives - headers
 
 Package: libhipcub-tests
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 XB-X-ROCm-GPU-Architecture: ${rocm:GPU-Architecture}
 Build-Profiles: <!nocheck>
 Depends: ${misc:Depends}, ${shlibs:Depends}
diff --git a/debian/patches/0001-install-cmake-config-to-share.patch b/debian/patches/0001-install-cmake-config-to-share.patch
index 2dafdc1..78551be 100644
--- a/debian/patches/0001-install-cmake-config-to-share.patch
+++ b/debian/patches/0001-install-cmake-config-to-share.patch
@@ -10,10 +10,10 @@ libraries, such as libcub-dev.
  cmake/ROCMExportTargetsHeaderOnly.cmake | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
 
-diff --git a/cmake/ROCMExportTargetsHeaderOnly.cmake b/cmake/ROCMExportTargetsHeaderOnly.cmake
-index 3f7d814..2c8088d 100644
---- a/cmake/ROCMExportTargetsHeaderOnly.cmake
-+++ b/cmake/ROCMExportTargetsHeaderOnly.cmake
+Index: hipcub/cmake/ROCMExportTargetsHeaderOnly.cmake
+===================================================================
+--- hipcub.orig/cmake/ROCMExportTargetsHeaderOnly.cmake
++++ hipcub/cmake/ROCMExportTargetsHeaderOnly.cmake
 @@ -29,7 +29,7 @@ include(GNUInstallDirs)
  include(ROCMPackageConfigHelpers)
  include(ROCMInstallTargets)
diff --git a/debian/patches/0002-default-thread-load-store-cache-modifiers-to-off.patch b/debian/patches/0002-default-thread-load-store-cache-modifiers-to-off.patch
deleted file mode 100644
index 7cb5d48..0000000
--- a/debian/patches/0002-default-thread-load-store-cache-modifiers-to-off.patch
+++ /dev/null
@@ -1,41 +0,0 @@
-From: Cordell Bloor <[e-mail]>
-Date: Fri, 7 Nov 2025 11:40:56 -0700
-Subject: default thread load-store cache modifiers to off
-
-The assembly code used for this is invalid on RDNA 3, but it wasn't
-noticed with older compilers. The broken code was entirely removed
-by ROCm 7.1, so this patch can be dropped after updating hipcub
-to that release.
-
-Forwarded: not-needed
----
- hipcub/include/hipcub/thread/thread_load.hpp  | 2 +-
- hipcub/include/hipcub/thread/thread_store.hpp | 2 +-
- 2 files changed, 2 insertions(+), 2 deletions(-)
-
-diff --git a/hipcub/include/hipcub/thread/thread_load.hpp b/hipcub/include/hipcub/thread/thread_load.hpp
-index 89b4b8b..f50239e 100644
---- a/hipcub/include/hipcub/thread/thread_load.hpp
-+++ b/hipcub/include/hipcub/thread/thread_load.hpp
-@@ -33,7 +33,7 @@
- #ifdef __HIP_PLATFORM_AMD__
- 
-     #ifndef HIPCUB_THREAD_LOAD_USE_CACHE_MODIFIERS
--        #define HIPCUB_THREAD_LOAD_USE_CACHE_MODIFIERS 1
-+        #define HIPCUB_THREAD_LOAD_USE_CACHE_MODIFIERS 0
-     #endif
- 
-     #include "../backend/rocprim/thread/thread_load.hpp"
-diff --git a/hipcub/include/hipcub/thread/thread_store.hpp b/hipcub/include/hipcub/thread/thread_store.hpp
-index df61aaa..9af0535 100644
---- a/hipcub/include/hipcub/thread/thread_store.hpp
-+++ b/hipcub/include/hipcub/thread/thread_store.hpp
-@@ -33,7 +33,7 @@
- #ifdef __HIP_PLATFORM_AMD__
- 
-     #ifndef HIPCUB_THREAD_STORE_USE_CACHE_MODIFIERS
--        #define HIPCUB_THREAD_STORE_USE_CACHE_MODIFIERS 1
-+        #define HIPCUB_THREAD_STORE_USE_CACHE_MODIFIERS 0
-     #endif
- 
-     #include "../backend/rocprim/thread/thread_store.hpp"
diff --git a/debian/patches/series b/debian/patches/series
index 4315635..6d27231 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,2 +1 @@
 0001-install-cmake-config-to-share.patch
-0002-default-thread-load-store-cache-modifiers-to-off.patch
diff --git a/debian/rules b/debian/rules
index 643b44e..6ff7d6b 100755
--- a/debian/rules
+++ b/debian/rules
@@ -2,6 +2,12 @@
 export CXX=hipcc
 export DEB_BUILD_MAINT_OPTIONS = hardening=+all optimize=-lto
 export DEB_CXXFLAGS_MAINT_PREPEND = -gz -DROCPRIM_NO_DEPRECATION_WARNINGS
+# -Wl,--gc-sections:
+# Fixes linker errors ("relocation refers to a discarded section") when using gtest.
+# The linker's section garbage collection incorrectly discards needed code due to
+# a toolchain mismatch (ROCm's clang vs. the system's GCC). This flag forces the
+# linker to correctly re-evaluate dependencies, keeping the required sections.
+export DEB_LDFLAGS_MAINT_PREPEND = -Wl,--gc-sections
 export VERBOSE=1
 #export AMD_LOG_LEVEL=4
 
diff --git a/debian/tests/control b/debian/tests/control
index 820f22f..ede74de 100644
--- a/debian/tests/control
+++ b/debian/tests/control
@@ -1,4 +1,4 @@
 Test-Command: /bin/sh debian/tests/upstream-binaries libhipcub-tests
 Depends: libhipcub-tests
 Restrictions: allow-stderr, skippable
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
diff --git a/docs/conf.py b/docs/conf.py
index 133736c..0cf04f8 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -18,7 +18,7 @@ left_nav_title = f"hipCUB {version_number} Documentation"
 # for PDF output on Read the Docs
 project = "hipCUB Documentation"
 author = "Advanced Micro Devices, Inc."
-copyright = "Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved."
+copyright = "Copyright (c) 2024-2025 Advanced Micro Devices, Inc. All rights reserved."
 version = version_number
 release = version_number
 
@@ -33,3 +33,7 @@ external_projects_current_project = "hipcub"
 
 for sphinx_var in ROCmDocs.SPHINX_VARS:
     globals()[sphinx_var] = getattr(docs_core, sphinx_var)
+
+# Suppresses "WARNING: toctree directive not expected with external-toc"
+# Ideally suppression wouldn't be needed; see sphinx-external-toc#36
+suppress_warnings = ["etoc.toctree"]
diff --git a/docs/doxygen/Doxyfile b/docs/doxygen/Doxyfile
index 1f4b7b7..16f2d40 100644
--- a/docs/doxygen/Doxyfile
+++ b/docs/doxygen/Doxyfile
@@ -1,4 +1,4 @@
-# Doxyfile 1.8.11
+# Doxyfile 1.9.4
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -12,16 +12,25 @@
 # For lists, items can also be appended using:
 # TAG += value [value, ...]
 # Values that contain spaces should be placed between quotes (\" \").
+#
+# Note:
+#
+# Use doxygen to compare the used configuration file with the template
+# configuration file:
+# doxygen -x [configFile]
+# Use doxygen to compare the used configuration file with the template
+# configuration file without replacing the environment variables:
+# doxygen -x_noenv [configFile]
 
 #---------------------------------------------------------------------------
 # Project related configuration options
 #---------------------------------------------------------------------------
 
-# This tag specifies the encoding used for all characters in the config file
-# that follow. The default is UTF-8 which is also the encoding used for all text
-# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
-# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
-# for the list of possible encodings.
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
 # The default value is: UTF-8.
 
 DOXYFILE_ENCODING      = UTF-8
@@ -60,16 +69,28 @@ PROJECT_LOGO           =
 
 OUTPUT_DIRECTORY       = .
 
-# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create up to 4096
+# sub-directories (in 2 levels) under the output directory of each output format
+# and will distribute the generated files over these directories. Enabling this
 # option can be useful when feeding doxygen a huge amount of source files, where
 # putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
+# performance problems for the file system. Adapt CREATE_SUBDIRS_LEVEL to
+# control the number of sub-directories.
 # The default value is: NO.
 
 CREATE_SUBDIRS         = NO
 
+# Controls the number of sub-directories that will be created when
+# CREATE_SUBDIRS tag is set to YES. Level 0 represents 16 directories, and every
+# level increment doubles the number of directories, resulting in 4096
+# directories at level 8 which is the default and also the maximum value. The
+# sub-directories are organized in 2 levels, the first level always has a fixed
+# numer of 16 directories.
+# Minimum value: 0, maximum value: 8, default value: 8.
+# This tag requires that the tag CREATE_SUBDIRS is set to YES.
+
+CREATE_SUBDIRS_LEVEL   = 8
+
 # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
 # characters to appear in the names of generated files. If set to NO, non-ASCII
 # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
@@ -81,14 +102,14 @@ ALLOW_UNICODE_NAMES    = NO
 # The OUTPUT_LANGUAGE tag is used to specify the language in which all
 # documentation generated by doxygen is written. Doxygen will use this
 # information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
-# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
-# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
-# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
-# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
-# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
-# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
-# Ukrainian and Vietnamese.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Bulgarian,
+# Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch, English
+# (United States), Esperanto, Farsi (Persian), Finnish, French, German, Greek,
+# Hindi, Hungarian, Indonesian, Italian, Japanese, Japanese-en (Japanese with
+# English messages), Korean, Korean-en (Korean with English messages), Latvian,
+# Lithuanian, Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese,
+# Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish,
+# Swedish, Turkish, Ukrainian and Vietnamese.
 # The default value is: English.
 
 OUTPUT_LANGUAGE        = English
@@ -118,7 +139,6 @@ REPEAT_BRIEF           = YES
 # the entity):The $name class, The $name widget, The $name file, is, provides,
 # specifies, contains, represents, a, an and the.
 
-
 ABBREVIATE_BRIEF       = "The $name class" \
                          "The $name widget" \
                          "The $name file" \
@@ -190,6 +210,16 @@ SHORT_NAMES            = NO
 
 JAVADOC_AUTOBRIEF      = NO
 
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
 # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
 # line (until the first dot) of a Qt-style comment as the brief description. If
 # set to NO, the Qt-style will behave just like regular Qt-style comments (thus
@@ -210,6 +240,14 @@ QT_AUTOBRIEF           = NO
 
 MULTILINE_CPP_IS_BRIEF = NO
 
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
 # documentation from any documented member that it re-implements.
 # The default value is: YES.
@@ -233,20 +271,19 @@ TAB_SIZE               = 4
 # the documentation. An alias has the form:
 # name=value
 # For example adding
-# "sideeffect=@par Side Effects:\n"
+# "sideeffect=@par Side Effects:^^"
 # will allow you to put the command \sideeffect (or @sideeffect) in the
 # documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines.
+# "Side Effects:". Note that you cannot put \n's in the value part of an alias
+# to insert newlines (in the resulting output). You can put ^^ in the value part
+# of an alias to insert a newline as if a physical newline was in the original
+# file. When you need a literal { or } or , in the value part of an alias you
+# have to escape them by means of a backslash (\), this can lead to conflicts
+# with the commands \{ and \} for these it is advised to use the version @{ and
+# @} or use a double escape (\\{ and \\})
 
 ALIASES                =
 
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              =
-
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For
 # instance, some of the names that are used will be different. The list of all
@@ -275,28 +312,40 @@ OPTIMIZE_FOR_FORTRAN   = NO
 
 OPTIMIZE_OUTPUT_VHDL   = NO
 
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
 # Doxygen selects the parser to use depending on the extension of the files it
 # parses. With this tag you can assign which parser to use for a given
 # extension. Doxygen has a built-in mapping, but you can override or extend it
 # using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
-# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
-# Fortran. In the later case the parser tries to guess whether the code is fixed
-# or free formatted code, this is the default for Fortran type files), VHDL. For
-# instance to make doxygen treat .inc files as Fortran files (default is PHP),
-# and .f files as C (default is Fortran), use: inc=Fortran f=C.
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, Lex, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# VHDL, Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
 #
 # Note: For files without extension you can use no_extension as a placeholder.
 #
 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
 
 EXTENSION_MAPPING      =
 
 # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
 # according to the Markdown format, which allows for more readable
-# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
 # The output of markdown processing is further processed by doxygen, so you can
 # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
 # case of backward compatibilities issues.
@@ -304,6 +353,15 @@ EXTENSION_MAPPING      =
 
 MARKDOWN_SUPPORT       = YES
 
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 5.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 5
+
 # When enabled doxygen tries to link words that correspond to documented
 # classes, or namespaces to their corresponding documentation. Such a link can
 # be prevented in individual cases by putting a % sign in front of the word or
@@ -329,7 +387,7 @@ BUILTIN_STL_SUPPORT    = NO
 CPP_CLI_SUPPORT        = NO
 
 # Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
 # will parse them like normal C++ but will assume all classes use public instead
 # of private inheritance when no explicit protection keyword is present.
 # The default value is: NO.
@@ -415,6 +473,19 @@ TYPEDEF_HIDES_STRUCT   = NO
 
 LOOKUP_CACHE_SIZE      = 0
 
+# The NUM_PROC_THREADS specifies the number of threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which effectively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
@@ -435,6 +506,12 @@ EXTRACT_ALL            = NO
 
 EXTRACT_PRIVATE        = NO
 
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
 # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
 # scope will be included in the documentation.
 # The default value is: NO.
@@ -472,6 +549,13 @@ EXTRACT_LOCAL_METHODS  = NO
 
 EXTRACT_ANON_NSPACES   = NO
 
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
 # undocumented members inside documented classes or files. If set to NO these
 # members will be included in the various overviews, but no documentation
@@ -489,8 +573,8 @@ HIDE_UNDOC_MEMBERS     = NO
 HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO, these declarations will be
-# included in the documentation.
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
 # The default value is: NO.
 
 HIDE_FRIEND_COMPOUNDS  = NO
@@ -509,11 +593,18 @@ HIDE_IN_BODY_DOCS      = NO
 
 INTERNAL_DOCS          = NO
 
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES, upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
 # The default value is: system dependent.
 
 CASE_SENSE_NAMES       = YES
@@ -532,6 +623,12 @@ HIDE_SCOPE_NAMES       = NO
 
 HIDE_COMPOUND_REFERENCE= NO
 
+# If the SHOW_HEADERFILE tag is set to YES then the documentation for a class
+# will show which file needs to be included to use the class.
+# The default value is: YES.
+
+SHOW_HEADERFILE        = YES
+
 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
 # the files that are included by a file in the documentation of that file.
 # The default value is: YES.
@@ -689,7 +786,8 @@ FILE_VERSION_FILTER    =
 # output files in an output format independent way. To create the layout file
 # that represents doxygen's defaults, run doxygen with the -l option. You can
 # optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
+# will be used as the name of the layout file. See also section "Changing the
+# layout of pages" for information.
 #
 # Note that if you run doxygen from a directory containing a file called
 # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
@@ -700,7 +798,7 @@ LAYOUT_FILE            =
 # The CITE_BIB_FILES tag can be used to specify one or more bib files containing
 # the reference definitions. This must be a list of .bib files. The .bib
 # extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
 # For LaTeX the style of the bibliography can be controlled using
 # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
 # search path. See also \cite for info how to create references.
@@ -735,23 +833,35 @@ WARNINGS               = YES
 WARN_IF_UNDOCUMENTED   = YES
 
 # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
+# potential errors in the documentation, such as documenting some parameters in
+# a documented function twice, or documenting parameters that don't exist or
+# using markup commands wrongly.
 # The default value is: YES.
 
 WARN_IF_DOC_ERROR      = YES
 
+# If WARN_IF_INCOMPLETE_DOC is set to YES, doxygen will warn about incomplete
+# function parameter documentation. If set to NO, doxygen will accept that some
+# parameters have no documentation without warning.
+# The default value is: YES.
+
+WARN_IF_INCOMPLETE_DOC = YES
+
 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
 # are documented, but have no documentation for their parameters or return
-# value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation.
+# value. If set to NO, doxygen will only warn about wrong parameter
+# documentation, but not about the absence of documentation. If EXTRACT_ALL is
+# set to YES then this flag will automatically be disabled. See also
+# WARN_IF_INCOMPLETE_DOC
 # The default value is: NO.
 
 WARN_NO_PARAMDOC       = NO
 
 # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered.
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
 # The default value is: NO.
 
 WARN_AS_ERROR          = YES
@@ -762,13 +872,27 @@ WARN_AS_ERROR          = YES
 # and the warning text. Optionally the format may contain $version, which will
 # be replaced by the version of the file (if it could be obtained via
 # FILE_VERSION_FILTER)
+# See also: WARN_LINE_FORMAT
 # The default value is: $file:$line: $text.
 
 WARN_FORMAT            = "$file:$line: $text"
 
+# In the $text part of the WARN_FORMAT command it is possible that a reference
+# to a more specific place is given. To make it easier to jump to this place
+# (outside of doxygen) the user can define a custom "cut" / "paste" string.
+# Example:
+# WARN_LINE_FORMAT = "'vi $file +$line'"
+# See also: WARN_FORMAT
+# The default value is: at line $line of file $file.
+
+WARN_LINE_FORMAT       = "at line $line of file $file"
+
 # The WARN_LOGFILE tag can be used to specify a file to which warning and error
 # messages should be written. If left blank the output is written to standard
-# error (stderr).
+# error (stderr). In case the file specified cannot be opened for writing the
+# warning and error messages are written to standard error. When as file - is
+# specified the warning and error messages are written to standard output
+# (stdout).
 
 WARN_LOGFILE           =
 
@@ -787,8 +911,8 @@ INPUT                  = ../../hipcub/include/hipcub
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: http://www.gnu.org/software/libiconv) for the list of
-# possible encodings.
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
 # The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
@@ -801,11 +925,15 @@ INPUT_ENCODING         = UTF-8
 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
 # read by doxygen.
 #
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
-# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f, *.for, *.tcl,
-# *.vhd, *.vhdl, *.ucf, *.qsf, *.as and *.js.
+# *.hh, *.hxx, *.hpp, *.h++, *.l, *.cs, *.d, *.php, *.php4, *.php5, *.phtml,
+# *.inc, *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C
+# comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd,
+# *.vhdl, *.ucf, *.qsf and *.ice.
 
 FILE_PATTERNS          =
 
@@ -838,13 +966,14 @@ EXCLUDE_SYMLINKS       = NO
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories for example use the pattern */test/*
 
-EXCLUDE_PATTERNS       = */detail/*,*/backend/*
+EXCLUDE_PATTERNS       = */detail/* \
+                         */backend/*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
+# ANamespace::AClass, ANamespace::*Test
 #
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
@@ -960,7 +1089,7 @@ INLINE_SOURCES         = NO
 STRIP_CODE_COMMENTS    = YES
 
 # If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# function all documented functions referencing it will be listed.
+# entity all documented functions referencing it will be listed.
 # The default value is: NO.
 
 REFERENCED_BY_RELATION = NO
@@ -992,12 +1121,12 @@ SOURCE_TOOLTIPS        = YES
 # If the USE_HTAGS tag is set to YES then the references to source code will
 # point to the HTML generated by the htags(1) tool instead of doxygen built-in
 # source browser. The htags tool is part of GNU's global source tagging system
-# (see http://www.gnu.org/software/global/global.html). You will need version
+# (see https://www.gnu.org/software/global/global.html). You will need version
 # 4.8.6 or higher.
 #
 # To use it do the following:
 # - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
 # - Make sure the INPUT points to the root of the source tree
 # - Run doxygen as normal
 #
@@ -1020,16 +1149,24 @@ USE_HTAGS              = NO
 VERBATIM_HEADERS       = YES
 
 # If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
 # Note: The availability of this option depends on whether or not doxygen was
-# generated with the -Duse-libclang=ON option for CMake.
+# generated with the -Duse_libclang=ON option for CMake.
 # The default value is: NO.
 
 CLANG_ASSISTED_PARSING = NO
 
+# If the CLANG_ASSISTED_PARSING tag is set to YES and the CLANG_ADD_INC_PATHS
+# tag is set to YES then doxygen will add the directory of each input to the
+# include path.
+# The default value is: YES.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
 # If clang assisted parsing is enabled you can provide the compiler with command
 # line options that you would normally use when invoking the compiler. Note that
 # the include paths will already be set by doxygen for the files and directories
@@ -1038,6 +1175,19 @@ CLANG_ASSISTED_PARSING = NO
 
 CLANG_OPTIONS          =
 
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
 #---------------------------------------------------------------------------
 # Configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
@@ -1049,13 +1199,6 @@ CLANG_OPTIONS          =
 
 ALPHABETICAL_INDEX     = NO
 
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
 # In case all classes in a project start with a common prefix, all classes will
 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
 # can be used to specify a prefix (or a list of prefixes) that should be ignored
@@ -1155,8 +1298,8 @@ HTML_EXTRA_FILES       =
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the style sheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# this color. Hue is specified as an angle on a color-wheel, see
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
 # purple, and 360 is red again.
 # Minimum value: 0, maximum value: 359, default value: 220.
@@ -1165,7 +1308,7 @@ HTML_EXTRA_FILES       =
 HTML_COLORSTYLE_HUE    = 220
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
+# in the HTML output. For a value of 0 the output will use gray-scales only. A
 # value of 255 will produce the most vivid colors.
 # Minimum value: 0, maximum value: 255, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
@@ -1192,6 +1335,17 @@ HTML_COLORSTYLE_GAMMA  = 80
 
 HTML_TIMESTAMP         = NO
 
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via JavaScript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have JavaScript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
 # page has loaded.
@@ -1215,13 +1369,14 @@ HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
 # generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: http://developer.apple.com/tools/xcode/), introduced with
-# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
-# for more information.
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
@@ -1235,6 +1390,13 @@ GENERATE_DOCSET        = NO
 
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 
+# This tag determines the URL of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDURL         =
+
 # This tag specifies a string that should uniquely identify the documentation
 # set bundle. This should be a reverse domain-name style string, e.g.
 # com.mycompany.MyDocSet. Doxygen will append .docset to the name.
@@ -1260,8 +1422,12 @@ DOCSET_PUBLISHER_NAME  = Publisher
 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
+# on Windows. In the beginning of 2021 Microsoft took the original page, with
+# a.o. the download links, offline the HTML help workshop was already many years
+# in maintenance mode). You can download the HTML help workshop from the web
+# archives at Installation executable (see:
+# http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo
+# ad/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe).
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output
 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
@@ -1291,7 +1457,7 @@ CHM_FILE               =
 HHC_LOCATION           =
 
 # The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
+# (YES) or that it should be included in the main .chm file (NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
@@ -1336,7 +1502,8 @@ QCH_FILE               =
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
 # Project output. For more information please see Qt Help Project / Namespace
-# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1344,8 +1511,8 @@ QHP_NAMESPACE          =
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
 # Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
-# folders).
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
 # The default value is: doc.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1353,30 +1520,30 @@ QHP_VIRTUAL_FOLDER     = doc
 
 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
 # filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
 # project's filter section matches. Qt Help Project / Filter Attributes (see:
-# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_SECT_FILTER_ATTRS  =
 
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHG_LOCATION           =
@@ -1419,16 +1586,28 @@ DISABLE_INDEX          = NO
 # to work a browser that supports JavaScript, DHTML, CSS and frames is required
 # (i.e. any modern browser). Windows users are probably better off using the
 # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
+# further fine tune the look of the index (see "Fine-tuning the output"). As an
+# example, the default style sheet generated by doxygen has an example that
+# shows how to put an image at the root of the tree instead of the PROJECT_NAME.
+# Since the tree basically has the same information as the tab index, you could
+# consider setting DISABLE_INDEX to YES when enabling this option.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_TREEVIEW      = NO
 
+# When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
+# FULL_SIDEBAR option determines if the side bar is limited to only the treeview
+# area (value NO) or if it should extend to the full height of the window (value
+# YES). Setting this to YES gives a layout similar to
+# https://docs.readthedocs.io with more room for contents, but less room for the
+# project logo, title, and description. If either GENERATE_TREEVIEW or
+# DISABLE_INDEX is set to NO, this option has no effect.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FULL_SIDEBAR           = NO
+
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
 # doxygen will group on one line in the generated HTML documentation.
 #
@@ -1453,6 +1632,24 @@ TREEVIEW_WIDTH         = 250
 
 EXT_LINKS_IN_WINDOW    = NO
 
+# If the OBFUSCATE_EMAILS tag is set to YES, doxygen will obfuscate email
+# addresses.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+OBFUSCATE_EMAILS       = YES
+
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
 # Use this tag to change the font size of LaTeX formulas included as images in
 # the HTML documentation. When you change the font size after a successful
 # doxygen run you need to manually remove any form_*.png images from the HTML
@@ -1462,7 +1659,7 @@ EXT_LINKS_IN_WINDOW    = NO
 
 FORMULA_FONTSIZE       = 10
 
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
 # generated for formulas are transparent PNGs. Transparent PNGs are not
 # supported properly for IE 6.0, but are supported on all modern browsers.
 #
@@ -1473,8 +1670,14 @@ FORMULA_FONTSIZE       = 10
 
 FORMULA_TRANSPARENT    = YES
 
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# http://www.mathjax.org) which uses client side Javascript for the rendering
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
 # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
 # installed or if you want to formulas look prettier in the HTML output. When
 # enabled you may also need to install MathJax separately and configure the path
@@ -1484,11 +1687,29 @@ FORMULA_TRANSPARENT    = YES
 
 USE_MATHJAX            = YES
 
+# With MATHJAX_VERSION it is possible to specify the MathJax version to be used.
+# Note that the different versions of MathJax have different requirements with
+# regards to the different settings, so it is possible that also other MathJax
+# settings have to be changed when switching between the different MathJax
+# versions.
+# Possible values are: MathJax_2 and MathJax_3.
+# The default value is: MathJax_2.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_VERSION        = MathJax_2
+
 # When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
+# the MathJax output. For more details about the output format see MathJax
+# version 2 (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) and MathJax version 3
+# (see:
+# http://docs.mathjax.org/en/latest/web/components/output.html).
 # Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
+# compatibility. This is the name for Mathjax version 2, for MathJax version 3
+# this will be translated into chtml), NativeMML (i.e. MathML. Only supported
+# for NathJax 2. For MathJax version 3 chtml will be used instead.), chtml (This
+# is the name for Mathjax version 3, for MathJax version 2 this will be
+# translated into HTML-CSS) and SVG.
 # The default value is: HTML-CSS.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1501,22 +1722,29 @@ MATHJAX_FORMAT         = HTML-CSS
 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
 # Content Delivery Network so you can quickly see the result without installing
 # MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from http://www.mathjax.org before deployment.
-# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# MathJax from https://www.mathjax.org before deployment. The default value is:
+# - in case of MathJax version 2: https://cdn.jsdelivr.net/npm/mathjax@2
+# - in case of MathJax version 3: https://cdn.jsdelivr.net/npm/mathjax@3
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
 # extension names that should be enabled during MathJax rendering. For example
+# for MathJax version 2 (see https://docs.mathjax.org/en/v2.7-latest/tex.html
+# #tex-and-latex-extensions):
 # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# For example for MathJax version 3 (see
+# http://docs.mathjax.org/en/latest/input/tex/extensions/index.html):
+# MATHJAX_EXTENSIONS = ams
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_EXTENSIONS     =
 
 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
 # of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
 # example see the documentation.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1544,7 +1772,7 @@ MATHJAX_CODEFILE       =
 SEARCHENGINE           = NO
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
+# implemented using a web server instead of a web client using JavaScript. There
 # are two flavors of web server based searching depending on the EXTERNAL_SEARCH
 # setting. When disabled, doxygen will generate a PHP script for searching and
 # an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
@@ -1563,7 +1791,8 @@ SERVER_BASED_SEARCH    = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/).
+# Xapian (see:
+# https://xapian.org/).
 #
 # See the section "External Indexing and Searching" for details.
 # The default value is: NO.
@@ -1576,8 +1805,9 @@ EXTERNAL_SEARCH        = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/). See the section "External Indexing and
-# Searching" for details.
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHENGINE_URL       =
@@ -1628,21 +1858,35 @@ LATEX_OUTPUT           = latex
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
 # invoked.
 #
-# Note that when enabling USE_PDFLATEX this option is only used for generating
-# bitmaps for formulas in the HTML output, but not in the Makefile that is
-# written to the output directory.
-# The default file is: latex.
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_CMD_NAME         = latex
 
 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
 # index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
 # The default file is: makeindex.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 MAKEINDEX_CMD_NAME     = makeindex
 
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = makeindex
+
 # If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
 # documents. This may be useful for small projects and may help to save some
 # trees in general.
@@ -1672,29 +1916,31 @@ PAPER_TYPE             = a4
 
 EXTRA_PACKAGES         =
 
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
+# The LATEX_HEADER tag can be used to specify a user-defined LaTeX header for
+# the generated LaTeX document. The header should contain everything until the
+# first chapter. If it is left blank doxygen will generate a standard header. It
+# is highly recommended to start with a default header using
+# doxygen -w latex new_header.tex new_footer.tex new_stylesheet.sty
+# and then modify the file new_header.tex. See also section "Doxygen usage" for
+# information on how to generate the default header that doxygen normally uses.
 #
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
-# string, for the replacement values of the other commands the user is referred
-# to HTML_HEADER.
+# Note: Only use a user-defined header if you know what you are doing!
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. The following
+# commands have a special meaning inside the header (and footer): For a
+# description of the possible markers and block names see the documentation.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_HEADER           =
 
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
+# The LATEX_FOOTER tag can be used to specify a user-defined LaTeX footer for
+# the generated LaTeX document. The footer should contain everything after the
+# last chapter. If it is left blank doxygen will generate a standard footer. See
 # LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
+# special commands can be used inside the footer. See also section "Doxygen
+# usage" for information on how to generate the default footer that doxygen
+# normally uses. Note: Only use a user-defined footer if you know what you are
+# doing!
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_FOOTER           =
@@ -1727,9 +1973,11 @@ LATEX_EXTRA_FILES      =
 
 PDF_HYPERLINKS         = YES
 
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES, to get a
-# higher quality PDF documentation.
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1737,8 +1985,7 @@ USE_PDFLATEX           = YES
 
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
 # command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
+# if errors occur, instead of asking the user for help.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1751,19 +1998,9 @@ LATEX_BATCHMODE        = NO
 
 LATEX_HIDE_INDICES     = NO
 
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. See
-# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
 # The default value is: plain.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1777,6 +2014,14 @@ LATEX_BIB_STYLE        = plain
 
 LATEX_TIMESTAMP        = NO
 
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
 #---------------------------------------------------------------------------
 # Configuration options related to the RTF output
 #---------------------------------------------------------------------------
@@ -1816,9 +2061,9 @@ COMPACT_RTF            = NO
 
 RTF_HYPERLINKS         = NO
 
-# Load stylesheet definitions from file. Syntax is similar to doxygen's config
-# file, i.e. a series of assignments. You only have to provide replacements,
-# missing definitions are set to their default value.
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
 #
 # See also section "Doxygen usage" for information on how to generate the
 # default style sheet that doxygen normally uses.
@@ -1827,22 +2072,12 @@ RTF_HYPERLINKS         = NO
 RTF_STYLESHEET_FILE    =
 
 # Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's config file. A template extensions file can be generated
-# using doxygen -e rtf extensionFile.
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_EXTENSIONS_FILE    =
 
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
-
 #---------------------------------------------------------------------------
 # Configuration options related to the man page output
 #---------------------------------------------------------------------------
@@ -1914,6 +2149,13 @@ XML_OUTPUT             = xml
 
 XML_PROGRAMLISTING     = YES
 
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
 #---------------------------------------------------------------------------
 # Configuration options related to the DOCBOOK output
 #---------------------------------------------------------------------------
@@ -1932,23 +2174,14 @@ GENERATE_DOCBOOK       = NO
 
 DOCBOOK_OUTPUT         = docbook
 
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
 #---------------------------------------------------------------------------
 # Configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
-# AutoGen Definitions (see http://autogen.sf.net) file that captures the
-# structure of the code including all documentation. Note that this feature is
-# still experimental and incomplete at the moment.
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
 # The default value is: NO.
 
 GENERATE_AUTOGEN_DEF   = NO
@@ -2027,7 +2260,8 @@ SEARCH_INCLUDES        = YES
 
 # The INCLUDE_PATH tag can be used to specify one or more directories that
 # contain include files that are not input files but should be processed by the
-# preprocessor.
+# preprocessor. Note that the INCLUDE_PATH is not recursive, so the setting of
+# RECURSIVE has no effect here.
 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
 
 INCLUDE_PATH           = ../../hipcub/include/hipcub/
@@ -2121,15 +2355,6 @@ EXTERNAL_PAGES         = YES
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = YES
-
 # You can include diagrams made with dia in doxygen documentation. Doxygen will
 # then run dia to produce the diagram and insert it in the documentation. The
 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
@@ -2148,7 +2373,7 @@ HIDE_UNDOC_RELATIONS   = YES
 # http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
 # Bell Labs. The other options in this section have no effect if this option is
 # set to NO
-# The default value is: YES.
+# The default value is: NO.
 
 HAVE_DOT               = NO
 
@@ -2186,11 +2411,14 @@ DOT_FONTSIZE           = 10
 
 DOT_FONTPATH           =
 
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# If the CLASS_GRAPH tag is set to YES (or GRAPH) then doxygen will generate a
+# graph for each documented class showing the direct and indirect inheritance
+# relations. In case HAVE_DOT is set as well dot will be used to draw the graph,
+# otherwise the built-in generator will be used. If the CLASS_GRAPH tag is set
+# to TEXT the direct and indirect inheritance relations will be shown as texts /
+# links.
+# Possible values are: NO, YES, TEXT and GRAPH.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
 CLASS_GRAPH            = YES
 
@@ -2204,7 +2432,8 @@ CLASS_GRAPH            = YES
 COLLABORATION_GRAPH    = YES
 
 # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
+# groups, showing the direct groups dependencies. See also the chapter Grouping
+# in the manual.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2227,10 +2456,32 @@ UML_LOOK               = NO
 # but if the number exceeds 15, the total amount of fields shown is limited to
 # 10.
 # Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
+# This tag requires that the tag UML_LOOK is set to YES.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
 # collaboration graphs will show the relations between templates and their
 # instances.
@@ -2297,6 +2548,13 @@ GRAPHICAL_HIERARCHY    = YES
 
 DIRECTORY_GRAPH        = YES
 
+# The DIR_GRAPH_MAX_DEPTH tag can be used to limit the maximum number of levels
+# of child directories generated in directory dependency graphs by dot.
+# Minimum value: 1, maximum value: 25, default value: 1.
+# This tag requires that the tag DIRECTORY_GRAPH is set to YES.
+
+DIR_GRAPH_MAX_DEPTH    = 1
+
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot. For an explanation of the image formats see the section
 # output formats in the documentation of the dot tool (Graphviz (see:
@@ -2304,9 +2562,7 @@ DIRECTORY_GRAPH        = YES
 # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
 # to make the SVG files visible in IE 9+ (other browsers do not have this
 # requirement).
-# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
-# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
-# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
+# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
 # png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
 # png:gdiplus:gdiplus.
 # The default value is: png.
@@ -2352,13 +2608,18 @@ MSCFILE_DIRS           =
 DIAFILE_DIRS           =
 
 # When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
+# path where java can find the plantuml.jar file or to the filename of jar file
+# to be used. If left blank, it is assumed PlantUML is not used or called during
+# a preprocessing step. Doxygen will generate a warning when it encounters a
+# \startuml command in this case and will not generate output for the diagram.
 
 PLANTUML_JAR_PATH      =
 
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
+
 # When using plantuml, the specified paths are searched for files specified by
 # the !include statement in a plantuml block.
 
@@ -2412,14 +2673,18 @@ DOT_MULTI_TARGETS      = NO
 # If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
 # explaining the meaning of the various boxes and arrows in the dot generated
 # graphs.
+# Note: This tag requires that UML_LOOK isn't set, i.e. the doxygen internal
+# graphical representation for inheritance and collaboration diagrams is used.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 GENERATE_LEGEND        = YES
 
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
 # files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc temporary
+# files.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_CLEANUP            = YES
diff --git a/docs/index.rst b/docs/index.rst
index 8e4f96e..14af493 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -12,7 +12,7 @@ hipCUB documentation
 hipCUB is a thin, header-only wrapper library for `rocPRIM <https://rocm.docs.amd.com/projects/rocPRIM/en/latest/index.html>`_ and `CUB <https://docs.nvidia.com/cuda/cub/index.html>`_. It enables developers to port projects
 using the CUB library to the `HIP <https://rocm.docs.amd.com/projects/HIP/en/latest/index.html>`_ layer and run on AMD hardware. To learn more, see :ref:`what-is-hipcub`
 
-The hipCUB repository is located at `https://github.com/ROCm/hipCUB <https://github.com/ROCm/hipCUB>`_.
+The hipCUB project is located in https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipcub.
 
 .. grid:: 2
 
diff --git a/docs/install/hipCUB-install-on-Windows.rst b/docs/install/hipCUB-install-on-Windows.rst
index 76375ab..fc73fd9 100644
--- a/docs/install/hipCUB-install-on-Windows.rst
+++ b/docs/install/hipCUB-install-on-Windows.rst
@@ -8,8 +8,9 @@ Building and installing hipCUB on Windows
 
 You can use ``rmake.py`` to build and install hipCUB on Microsoft Windows. You can also use `CMake <./hipCUB-install-with-cmake.html>`_ if you want more build and installation options. 
 
+:doc:`Clone the hipCUB project <./hipCUB-install-overview>`. ``rmake.py`` will be located in the ``hipcub`` root directory. 
 
-``rmake.py`` is located in the ``hipCUB`` root directory. To build and install hipCUB with ``rmake.py``, run:
+To build and install hipCUB with ``rmake.py``, run:
 
 .. code:: shell
 
diff --git a/docs/install/hipCUB-install-overview.rst b/docs/install/hipCUB-install-overview.rst
index 772e53d..ff123ef 100644
--- a/docs/install/hipCUB-install-overview.rst
+++ b/docs/install/hipCUB-install-overview.rst
@@ -6,7 +6,16 @@
 hipCUB installation overview 
 *********************************
 
-The hipCUB source code is available from the `hipCUB GitHub Repository <https://github.com/ROCmSoftwarePlatform/hipCUB>`_. 
+The hipCUB source code is available from the `ROCm libraries GitHub Repository <https://github.com/ROCm/rocm-libraries/tree/develop/projects/hipcub>`_. Use sparse checkout when cloning the hipCUB project:
+
+.. code::
+
+  git clone --no-checkout --filter=blob:none https://github.com/ROCm/rocm-libraries.git
+  cd rocm-libraries
+  git sparse-checkout init --cone
+  git sparse-checkout set projects/hipcub
+
+Then use ``git checkout`` to check out the branch you need.
 
 The develop branch is the default branch. The develop branch is intended for users who want to preview new features or contribute to the hipCUB code base.
 
diff --git a/docs/install/hipCUB-install-with-cmake.rst b/docs/install/hipCUB-install-with-cmake.rst
index f21bf0d..0fcb91c 100644
--- a/docs/install/hipCUB-install-with-cmake.rst
+++ b/docs/install/hipCUB-install-with-cmake.rst
@@ -17,7 +17,7 @@ Before you begin, set ``CXX`` to ``amdclang++`` or ``hipcc`` if you're building 
     CXX=amdclang++
     CMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++
 
-Create the ``build`` directory inside the ``hipCUB`` directory, then change directory to the ``build`` directory:
+After :doc:`cloning the project <./hipCUB-install-overview>`, create the ``build`` directory under the ``hipcub`` root directory, then change directory to the ``build`` directory:
 
 .. code:: shell
 
@@ -35,6 +35,7 @@ The available build options are:
 
 * ``BUILD_BENCHMARK``. Set this to ``ON`` to build benchmark tests. Off by default.
 * ``BUILD_TEST``. Set this to ``ON`` to build tests. Off by default. 
+* ``USE_SYSTEM_LIB``: Set to ``ON`` to use the installed ``hipCUB`` from the system when building the tests. Off by default. For this option to take effect, ``BUILD_TEST`` must be ``ON`` and the ``hipCUB`` install (with its dependencies) must be compatible with the version of the tests.
 * ``DEPENDENCIES_FORCE_DOWNLOAD``. Set this to ``ON`` to download the dependencies regardless of whether or not they are already installed. Off by default.
 
 Build hipCUB using the generated make file:
diff --git a/docs/install/hipCUB-prerequisites.rst b/docs/install/hipCUB-prerequisites.rst
index 881cef3..d4352f5 100644
--- a/docs/install/hipCUB-prerequisites.rst
+++ b/docs/install/hipCUB-prerequisites.rst
@@ -8,7 +8,7 @@ hipCUB prerequisites
 
 hipCUB has the following prerequisites on all platforms:
 
-* `CMake <https://cmake.org/>`_ version 3.16 or higher
+* `CMake <https://cmake.org/>`_ version 3.18 or higher
 
 On AMD GPUs:
 
@@ -21,9 +21,9 @@ amdclang++ is installed with ROCm. rocPRIM is automatically downloaded and insta
 On NVIDIA GPUs:
 
 * The CUDA Toolkit
-* CCCL library version 2.3.2 or later
+* CCCL library version 2.8.2 or later
 * CUB and Thrust
-* libcu++ version 2.2.0
+* libcu++ version 2.8.2
 
 The CCCL library is automatically downloaded and built by the CMake script. If libcu++ isn't found on the system, it will be downloaded from the CCCL repository.
 
diff --git a/docs/sphinx/requirements.in b/docs/sphinx/requirements.in
index ad94caa..73a3602 100644
--- a/docs/sphinx/requirements.in
+++ b/docs/sphinx/requirements.in
@@ -1 +1 @@
-rocm-docs-core[api_reference]==1.8.3
+rocm-docs-core[api_reference]==1.20.1
diff --git a/docs/sphinx/requirements.txt b/docs/sphinx/requirements.txt
index 6dd77b1..e7818b8 100644
--- a/docs/sphinx/requirements.txt
+++ b/docs/sphinx/requirements.txt
@@ -8,6 +8,13 @@ accessible-pygments==0.0.4
     # via pydata-sphinx-theme
 alabaster==0.7.16
     # via sphinx
+asttokens==3.0.0
+    # via stack-data
+attrs==25.1.0
+    # via
+    #   jsonschema
+    #   jupyter-cache
+    #   referencing
 babel==2.14.0
     # via
     #   pydata-sphinx-theme
@@ -25,9 +32,21 @@ cffi==1.16.0
 charset-normalizer==3.3.2
     # via requests
 click==8.1.7
-    # via sphinx-external-toc
-cryptography==43.0.1
+    # via
+    #   click-log
+    #   doxysphinx
+    #   jupyter-cache
+    #   sphinx-external-toc
+click-log==0.4.0
+    # via doxysphinx
+comm==0.2.2
+    # via ipykernel
+cryptography==44.0.1
     # via pyjwt
+debugpy==1.8.12
+    # via ipykernel
+decorator==5.1.1
+    # via ipython
 deprecated==1.2.14
     # via pygithub
 docutils==0.21.2
@@ -38,39 +57,115 @@ docutils==0.21.2
     #   sphinx
 doxysphinx==3.3.8
     # via rocm-docs-core
+exceptiongroup==1.2.2
+    # via ipython
+executing==2.2.0
+    # via stack-data
 fastjsonschema==2.19.1
-    # via rocm-docs-core
+    # via
+    #   nbformat
+    #   rocm-docs-core
 gitdb==4.0.11
     # via gitpython
 gitpython==3.1.43
     # via rocm-docs-core
+greenlet==3.1.1
+    # via sqlalchemy
 idna==3.7
     # via requests
 imagesize==1.4.1
     # via sphinx
-jinja2==3.1.4
+importlib-metadata==8.6.1
+    # via
+    #   jupyter-cache
+    #   myst-nb