diff --git a/.devcontainer/cuda12.8-gcc12/devcontainer.json b/.devcontainer/cuda12.0-gcc11/devcontainer.json similarity index 86% rename from .devcontainer/cuda12.8-gcc12/devcontainer.json rename to .devcontainer/cuda12.0-gcc11/devcontainer.json index 451c04631..7a0074c48 100644 --- a/.devcontainer/cuda12.8-gcc12/devcontainer.json +++ b/.devcontainer/cuda12.0-gcc11/devcontainer.json @@ -1,6 +1,6 @@ { "shutdownAction": "stopContainer", - "image": "rapidsai/devcontainers:25.08-cpp-gcc12-cuda12.8-ubuntu22.04", + "image": "rapidsai/devcontainers:25.10-cpp-gcc11-cuda12.0-ubuntu22.04", "hostRequirements": { "gpu": true }, @@ -14,10 +14,10 @@ "SCCACHE_BUCKET": "rapids-sccache-devs", "AWS_ROLE_ARN": "arn:aws:iam::279114543810:role/nv-gha-token-sccache-devs", "HISTFILE": "${containerWorkspaceFolder}/.cache/._bash_history", - "DEVCONTAINER_NAME": "cuda12.8-gcc12", - "CUCO_CUDA_VERSION": "12.8", + "DEVCONTAINER_NAME": "cuda12.0-gcc11", + "CUCO_CUDA_VERSION": "12.0", "CUCO_HOST_COMPILER": "gcc", - "CUCO_HOST_COMPILER_VERSION": "12" + "CUCO_HOST_COMPILER_VERSION": "11" }, "workspaceFolder": "/home/coder/${localWorkspaceFolderBasename}", "workspaceMount": "source=${localWorkspaceFolder},target=/home/coder/${localWorkspaceFolderBasename},type=bind,consistency=consistent", @@ -38,5 +38,5 @@ } } }, - "name": "cuda12.8-gcc12" + "name": "cuda12.0-gcc11" } diff --git a/.devcontainer/cuda12.0-llvm14/devcontainer.json b/.devcontainer/cuda12.0-llvm14/devcontainer.json new file mode 100644 index 000000000..121285736 --- /dev/null +++ b/.devcontainer/cuda12.0-llvm14/devcontainer.json @@ -0,0 +1,42 @@ +{ + "shutdownAction": "stopContainer", + "image": "rapidsai/devcontainers:25.10-cpp-llvm14-cuda12.0-ubuntu20.04", + "hostRequirements": { + "gpu": true + }, + "initializeCommand": [ + "/bin/bash", + "-c", + "mkdir -m 0755 -p ${localWorkspaceFolder}/.{aws,cache,config}" + ], + "containerEnv": { + "SCCACHE_REGION": "us-east-2", + "SCCACHE_BUCKET": "rapids-sccache-devs", + "AWS_ROLE_ARN": "arn:aws:iam::279114543810:role/nv-gha-token-sccache-devs", + "HISTFILE": "${containerWorkspaceFolder}/.cache/._bash_history", + "DEVCONTAINER_NAME": "cuda12.0-llvm14", + "CUCO_CUDA_VERSION": "12.0", + "CUCO_HOST_COMPILER": "llvm", + "CUCO_HOST_COMPILER_VERSION": "14" + }, + "workspaceFolder": "/home/coder/${localWorkspaceFolderBasename}", + "workspaceMount": "source=${localWorkspaceFolder},target=/home/coder/${localWorkspaceFolderBasename},type=bind,consistency=consistent", + "mounts": [ + "source=${localWorkspaceFolder}/.aws,target=/home/coder/.aws,type=bind,consistency=consistent", + "source=${localWorkspaceFolder}/.cache,target=/home/coder/.cache,type=bind,consistency=consistent", + "source=${localWorkspaceFolder}/.config,target=/home/coder/.config,type=bind,consistency=consistent" + ], + "customizations": { + "vscode": { + "extensions": [ + "llvm-vs-code-extensions.vscode-clangd" + ], + "settings": { + "clangd.arguments": [ + "--compile-commands-dir=${workspaceFolder}/build/latest" + ] + } + } + }, + "name": "cuda12.0-llvm14" +} diff --git a/.devcontainer/cuda12.8-gcc13/devcontainer.json b/.devcontainer/cuda12.9-gcc13/devcontainer.json similarity index 88% rename from .devcontainer/cuda12.8-gcc13/devcontainer.json rename to .devcontainer/cuda12.9-gcc13/devcontainer.json index e555751f0..e55eea294 100644 --- a/.devcontainer/cuda12.8-gcc13/devcontainer.json +++ b/.devcontainer/cuda12.9-gcc13/devcontainer.json @@ -1,6 +1,6 @@ { "shutdownAction": "stopContainer", - "image": "rapidsai/devcontainers:25.08-cpp-gcc13-cuda12.8-ubuntu22.04", + "image": "rapidsai/devcontainers:25.10-cpp-gcc13-cuda12.9-ubuntu22.04", "hostRequirements": { "gpu": true }, @@ -14,8 +14,8 @@ "SCCACHE_BUCKET": "rapids-sccache-devs", "AWS_ROLE_ARN": "arn:aws:iam::279114543810:role/nv-gha-token-sccache-devs", "HISTFILE": "${containerWorkspaceFolder}/.cache/._bash_history", - "DEVCONTAINER_NAME": "cuda12.8-gcc13", - "CUCO_CUDA_VERSION": "12.8", + "DEVCONTAINER_NAME": "cuda12.9-gcc13", + "CUCO_CUDA_VERSION": "12.9", "CUCO_HOST_COMPILER": "gcc", "CUCO_HOST_COMPILER_VERSION": "13" }, @@ -38,5 +38,5 @@ } } }, - "name": "cuda12.8-gcc13" + "name": "cuda12.9-gcc13" } diff --git a/.devcontainer/cuda12.9-llvm18/devcontainer.json b/.devcontainer/cuda12.9-llvm18/devcontainer.json new file mode 100644 index 000000000..d0dfaf881 --- /dev/null +++ b/.devcontainer/cuda12.9-llvm18/devcontainer.json @@ -0,0 +1,42 @@ +{ + "shutdownAction": "stopContainer", + "image": "rapidsai/devcontainers:25.10-cpp-llvm18-cuda12.9-ubuntu22.04", + "hostRequirements": { + "gpu": true + }, + "initializeCommand": [ + "/bin/bash", + "-c", + "mkdir -m 0755 -p ${localWorkspaceFolder}/.{aws,cache,config}" + ], + "containerEnv": { + "SCCACHE_REGION": "us-east-2", + "SCCACHE_BUCKET": "rapids-sccache-devs", + "AWS_ROLE_ARN": "arn:aws:iam::279114543810:role/nv-gha-token-sccache-devs", + "HISTFILE": "${containerWorkspaceFolder}/.cache/._bash_history", + "DEVCONTAINER_NAME": "cuda12.9-llvm18", + "CUCO_CUDA_VERSION": "12.9", + "CUCO_HOST_COMPILER": "llvm", + "CUCO_HOST_COMPILER_VERSION": "18" + }, + "workspaceFolder": "/home/coder/${localWorkspaceFolderBasename}", + "workspaceMount": "source=${localWorkspaceFolder},target=/home/coder/${localWorkspaceFolderBasename},type=bind,consistency=consistent", + "mounts": [ + "source=${localWorkspaceFolder}/.aws,target=/home/coder/.aws,type=bind,consistency=consistent", + "source=${localWorkspaceFolder}/.cache,target=/home/coder/.cache,type=bind,consistency=consistent", + "source=${localWorkspaceFolder}/.config,target=/home/coder/.config,type=bind,consistency=consistent" + ], + "customizations": { + "vscode": { + "extensions": [ + "llvm-vs-code-extensions.vscode-clangd" + ], + "settings": { + "clangd.arguments": [ + "--compile-commands-dir=${workspaceFolder}/build/latest" + ] + } + } + }, + "name": "cuda12.9-llvm18" +} diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index e555751f0..e55eea294 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -1,6 +1,6 @@ { "shutdownAction": "stopContainer", - "image": "rapidsai/devcontainers:25.08-cpp-gcc13-cuda12.8-ubuntu22.04", + "image": "rapidsai/devcontainers:25.10-cpp-gcc13-cuda12.9-ubuntu22.04", "hostRequirements": { "gpu": true }, @@ -14,8 +14,8 @@ "SCCACHE_BUCKET": "rapids-sccache-devs", "AWS_ROLE_ARN": "arn:aws:iam::279114543810:role/nv-gha-token-sccache-devs", "HISTFILE": "${containerWorkspaceFolder}/.cache/._bash_history", - "DEVCONTAINER_NAME": "cuda12.8-gcc13", - "CUCO_CUDA_VERSION": "12.8", + "DEVCONTAINER_NAME": "cuda12.9-gcc13", + "CUCO_CUDA_VERSION": "12.9", "CUCO_HOST_COMPILER": "gcc", "CUCO_HOST_COMPILER_VERSION": "13" }, @@ -38,5 +38,5 @@ } } }, - "name": "cuda12.8-gcc13" + "name": "cuda12.9-gcc13" } diff --git a/.github/workflows/dispatch-build-and-test.yml b/.github/workflows/dispatch-build-and-test.yml index ab7d73619..b37da8ec7 100644 --- a/.github/workflows/dispatch-build-and-test.yml +++ b/.github/workflows/dispatch-build-and-test.yml @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -23,8 +23,7 @@ on: jobs: # Using a matrix to dispatch to the build-and-test reusable workflow for each build configuration - # ensures that the build/test steps can overlap across different configurations. For example, - # the build step for CUDA 12.1 + gcc 9.3 can run at the same time as the test step for CUDA 11.0 + clang 11. + # ensures that the build/test steps can overlap across different configurations. build_and_test: name: ${{matrix.cpu}} uses: ./.github/workflows/build-and-test.yml diff --git a/CMakeLists.txt b/CMakeLists.txt index 05c4a9777..a00476b4e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -15,7 +15,7 @@ #============================================================================= cmake_minimum_required(VERSION 3.23.1 FATAL_ERROR) -set(rapids-cmake-version 25.08) +set(rapids-cmake-version 25.10) if(NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/CUCO_RAPIDS.cmake) file(DOWNLOAD https://raw.githubusercontent.com/rapidsai/rapids-cmake/branch-${rapids-cmake-version}/RAPIDS.cmake diff --git a/README.md b/README.md index 444113097..85441728b 100644 --- a/README.md +++ b/README.md @@ -222,7 +222,7 @@ We plan to add many GPU-accelerated, concurrent data structures to `cuCollection - [Host-bulk APIs](https://github.com/NVIDIA/cuCollections/blob/dev/examples/static_map/host_bulk_example.cu) (see [live example in godbolt](https://godbolt.org/clientstate/eJyNVw1v2zYQ_Ss3DcOcVv4KEBRw4mBe0mJGC6eI0xZFXSg0RcdEJFEjKaee4f--O5Ky5cRA2wKxTd7H47t3R2kTGWGMVIWJBt82kUyjQT-OMlY8VOxBRIOIVymL4sioSnP63X01K-AVXKlyreXD0kKLn8Bp77TXxj9nMUw-j6_HI7i6uf14czu6G99MOuTgnD5ILgojUqiKVGiwSwGjknH8CDsxfBaa0MBppwctMphFYW8WnZy7KGtVQc7WUCgLlREYRhpYyEyA-MFFaUEWwFVeZpIVXMCTtEuXKsRxcOBrCKLmlqE9Q48Sfy2alsDsDjr9W1pbDrrdp6enDnOwO0o_dDNvbLofxldvJ9O3bYS-c_tUZEgvaPFvJTUefL4GViIyzuaIN2NPoDSwBy1wzypC_qSllcVDDEYt7BPTwsVJpbFazit7QF6NE8_fNED6WIHEjaYwns4i-Hs0HU9jF-fL-O6fm0938GV0ezua3I3fTuHmFos1uR5TqfDXOxhNvsL78eQ6BoHUYSrxo9R0CoQqiVaReg6nQhzAWCgPy5SCy4XkUMsIHtRK6AKPBaXQufSCQ5Cpi5PJXFpm3dqLw7lU3VkxK36XBc-qVMAFr7jqGnLhSc7KDq-Wl4cWdqkrY7upWGGUZCW4VbpDRi9MsDIsO74lrdAMHbtcVQUVJalXfmJvNSsMspH_xMFgcoEaPb67i9J5fjqeM3vowo1NU7E4WJMKJSFYfrDouDYuXveV1-hfrneWaJ3Mq-wxET8YVlkgq357rqVYwLXIsT6IyQqskqGqhm7ZFwI1RxFQchQNRh_HZt_8d2hKu24ZUNio02yNkl8p3w0LrXIX0DmjOJxRRfOClJUq0o8qiVAnlUw-ovRRItqiNF2OhSy8_MEIS_gexXoPwalIFhYbXxatlZLpyazY4A4modjvxRq7fIgx7fl-9TPLKrFbpfVuF97mpV2DyZT1R9GCWkQU1vc4fdcr_D6LaFEWIkNSVhTJdIgJ7Bb_C8xSVRk6IY8iQ52ik6n4MuSxS2aJE5x2AlsIFOeVpjGBQ5A-y8pCyiyjMzr8nIpEDQuCICZIQFJDcENsCO2-O50_13N7h2rvEawDmkmVzwmE47XrTKFkUhuaXfO6GIK6GlWRDgZG_icS20hSVDlBMhj4rPdnr9fbB7_CkY3jCzjNVonszpkJwwxt_4BMMRQCo04mD1Zhzn1g2k38Lsbudc7Oj4LYRx_6TS5k1tqh6jbjnDSxkfQrTtUGErq7VGZRHQ2L67XgJdPuO_nSh3GKdtw2SKv5ddr0R6GoQ6DJhoh3HeXUCTvUcTDY1XbzssrbQyOXcHOsuNtt44A4KJB76hs_kurmcQfxUiVTP5oGg4PBeoHCuwzFdzzuCHU39s6pjt1qmHbm4gGb8SRu-ndEkdJS79D_MKnT7y6th_iLiUMjPk8dlg-Te2XOkbDnfNBEUEH_m00v7iHzm37cx49OpwMbGcvtdldfbzfcYcrZI6ryxUXR8gWvrV7cPBcNSV9uMGUQCD6lDQalVjxjMk-0sJUuErsuxYUXA6WnOsW-7y8vQyKAb6EfjxYlnHQIR5n7DkkSipK03CnlCWzqwAAeBhxHsKFM3-T3Ogl-3Z7XvtuTRveNXW6kPssCjY55aixsETKihwCPsOUM4mD3GpqCCOGmSCNdX3SpLJDfn-s7SM0ZH1NaCPwObx-P0lGKkoB-DKdODlsnHIPRkE5mjOKS0axvSum-meC-PvwCuxLjwT0FTaxK6JJDsu7xRhSm-NPi8xk-_MWH7mgAw-HRoX5fM0aBfrkXm8Frw8bZ8bldLtb-viIGqDhNcjGh5f45vL4lGrTPlcrCgEbnkCXxLsPDjnDPa61jaJ5hDLiPCrcGLhfQep4QFRyuBoWX68UFjvlpxTk-AP8G79yJ6Hwh3gzjROew9eGC3ulSwxV8a6LXEHy40vuXq6hYcd4_Pav6uK1K69-8ojZmHPLXr_tvoM00Xw5NnrzpQbuNl5vFPxZPI9J2xvK5ex3L5LwRk3Oe4eLKvzvhAt5VxWO0jet9bMCDfZR3tP3u_v8PKKbiNA==)) - [Device-ref APIs for individual operations](https://github.com/NVIDIA/cuCollections/blob/dev/examples/static_map/device_ref_example.cu) (see [live example in godbolt](https://godbolt.org/clientstate/eJzNWWtvG8cV_SsTFmkpa8WHUTcAJQpRbaclksqBpCQILGM93B2SA-8ru7OkGEL_vefemX1RdEylXyoDJrkzc5_nvmZ3vUIVhU6Tojd5v-vpsDcZe71IJstSLlVv0gvKUPa8XpGWeUC_hy_uE_FCvE6zba6XKyP6wYl4OXo5OsN_f_fE9c-zN7Mr8frdzY_vbq7uZu-uB3SAD_2gA5UUKhRlEqpcmJUSV5kM8OFWPPGzykka8XIwEn3acN9za_e9k3Omsk1LEcutSFIjykKBjC7EQkdKqIdAZUboRARpnEVaJoESG21WzMrRYXHEr45IOjcS-yVOZPi1aO8U0tSi09_KmGwyHG42m4FksQdpvhxGdnMx_GH2-u317dsziF4f-ymJYF6Rq99KnUPx-VbIDJIFcg55I7kRaS7kMldYMylJvsm10cnSE0W6MBuZK6YT6sLkel6ajvEqOaF_ewPMJxMY7upWzG7ve-KfV7ezW4_p_DK7-_e7n-7EL1c3N1fXd7O3t-LdDZx1_WZGrsKv78TV9a_i-9n1G08omA6s1EOWkxYQVZNZVWhteKtUR4xFasUqMhXohQ5EBSOxTNcqT6CWyFQeaws4CBkynUjH2kjDz54ox6yG98l98hedBFEZKnERlEE6LOhI4McyGwTl6nJ_RyixIxwuyiQgyjK6PLhuyixSnSWzysvCDEO1hgD-WgUmzQerQ1vUgwpKIu5nKVy6PbxLG5VL0Bj-rjO_-nF4awGYKGB28ESdWJruiQDCh2rReaZTYEDJuPOQjVswveELC8pvOVicgrla-OpBwq8KdrTr81yrhXijYnjEQF4FvxTkRxcf9qgoNBhc_Tgr2PM6CfVah6WMRJqRluzPSH8CPuHH3AwX2NIkg9nn90uQTpZRdZCAR2dFAFjPFWEIDGMgHfHiZAlSyLLWkuRj8ve9BiCkJOLAbDNVNAJ8iwSixB1lD2cACiRSJaw1p1SUlXmWIsARV9F2IGaGtlHy0YlRgCtHbrFKN2ybGE5g8k5KmRixQaLBnjDlHRUzGS1TBPsqrkUadrxkvTBjExTik9oWOC6NyGRRtOMMAiA-Q-QUwyYxlg0FRqOryWQuY_EfmYk7mKHyJDZVFoSNVE7o6xz4Xm1nwCzEyEpo7OArNitYRKxlVCqfzAr7JwhxoymtQQDwmUwgMi92CP5MZ44iCSsfogqRMxU-JfxjZQMkXZlvG5s0RuCN73XyQThQiJtK6bZB2ISblQ5WDoAFikgUdaC3T5B0naslAHkHKvyN850jmyMTMg_rxtQR3qditT-GDu9ECi2KNNDseK5zCmWJeHyeRVLGPgtB9E1qEH54NIc_KumQlh35_bNk0n3r2npmg6DiPhDvECqHINsCqjMp87CiVnXFcUxLY8WtVj8vclEGASrUoozAttruIsooRBsJekGQSWSsCEeeqH85iLee1BhtPavhhVTq-8soncvI98U61SE1H9gMUFrWfYoyhzAqu1_4q0KshtARZ5ooakHmiHOoGpNJoX9HiNVIOOJYE1vkwCMOIIRedHx3cp_s6JgsKT3BZlPgAcUqnIUPgwdxKuZRGnyyP17YH290PHg4p5TYlTtIy4Q0n4oRNYQUqUgPfSJ6USt1InZWyuHQgtGVkj_CpD2gF6JPj_q1P96D9IeTmiLT5FTkaObKlDlq10eTl-ojEdBcI4j4QueFgcKxbZWWeq0SDtCNLFrkaohT8H1cyKiwhOgM7ZYR2WqL2oE-j6EtKlkd0AYOe9QbTSaZ1Pmuq4DXhgo_eWzrJMTpqbPsOYv0mn60Au1gjLE9KxKP9ov7IH-cTsUy1yF7ct-tvJE-wOunLCRw2aiyDiaWT7igUMQ6uArDfhtbXgUJGhAeD9TQ79K85fiVXFOLgZaKE3yV9j18D3IVq8Sw63QOsjka3yxFp4IUzOajDj5N1P9RZW2lzKPLGtpMGOaPy9qzSxoR3bYJfLHUPDNDH8i8tct8W7E6qfdAZj2YAP-H3HRE9pk1UczRW3Qwx31tlUDQ3tY4cF1c0-PZukoD2UbTzGdqDtVx6vjQkPZP7Aqrs0BkkEJVliB--5ntvEl8dvtXzX6m1019TxTyXFxKmxmcR3hTqz9hB1VkWDZC6rTJPzSTTSaWFPHuoKHT93lur_WSX2B2V74Ntssdq3B2WSgETvh4XtFn5RVC3pdIH-OKRIxWP9_6aY6xE0wj-YBadf78RMZpBxEGw-mkT9isUFXSLENQBKkpBeF585TLeP3UJcO3cWa2oohSQAXzPySn8RsWtfcH9D1f4zsmHDzUiYow21j4DyjUqvRR0FBSRiEFeKEiDLI4hCy-cnw4GcJJW5GoNQVlEJQ0xtEFC31SWkJalpTrWP6AhiK6DBCKRCSk-5UIbOOpOBuzdlav_f02qdUn3G4nzXU7MwxtrqUqxqllrtpd3V43UDGp081UvBr9bTQaNcRfAyeG50o3YR9odsVuN_JGj57Yjb0xPgaDgdhpTz8yDOyEPpl0rgUuYJVLJxmz7tcJ4Lx9qOLab20dcAD2T7z2eRtunhh1z3eZsnFrti7vHcfYoWSftXvcZl4ZLo0BA7iSLrw0YDmXhbthgpG_FlEq0f5KkqvOoI1HaNW3q9StDV6dH_ReQ31qFwOlo1ojMWzT6chGM3oZUJhwgeMJ6L5XUUNU2CCysXY2ZmfTh23NGJQttFXA5CsCqwpRnQrbUjXXCbuKwxcbYXuyjpbd07h5fBYNFnR3KJqOoUP5ju0LVKCEmpTxuztWhAh8ZO5neTqHPS84hdLzUC1kGRl_JYuVX923MWnQfmz89S9l4KgkTc7STcJXnHFp-B40P9SucHpCSUk3RT2GwyXctiMNWp9Vtx2OxSeVUzqs3OfgzXWGqyO-uQbZLrXQ1Iw43BSlrZlBuZ69aAgXPj-civcfhO9Kj-_3eRE7UTBdVRZUbMXX4uWJmNLAIloGuYJyzLEAsOl6je6e6ua3aZWetMGH8wJscdmZufrjSr-9uOTy5VMIQoOXr_5x3t3Dpc4uu7TeBONp-_CZGJ8gPJsnTGhvGr64uKjpea29l5eX_cZBR8yUnb9DmfTPkdjLic8k8owhusvcIujPsKsvS6g4908GS2XQorUHZWDIiIsL5MLr7j1JdXSCJdrQJvd-9IEe2QSRhNHnA_fL8cpdbetW95lxS8cPRi0tVJrut_5_hLOKoHcQN6JdPJ1EN8pgQlpzE2N4JISq0I7VJVOoVpfWNPRfaBWIGPpDxEbdLbTMf0TRbwi06v4TEtZoVgEfQve7fBvF98lVK528wa9I-M1F1a1XIsbyk_LbrzX6rSLDx3bP5fxoNaAxg2kCYtSbkuXJ1o07uHHDFLvYWuR9pOUBJdtTMaZcy7-Z-Ee6jJHRRtKcmpeqqe_opVG57LzHGoGPny76XTWtJ7yWIdrfwW_PCd6hqsCZ9a_2XGueclWiZTeE88Xosu82OmX21sfVejWp1EGBGc4qRSVoLxnc2hucr8SdzEGlvkPO6Q6MorU9vtFlLGj2zqtrGifpyN6x9LwevWPF7Js3b457yToIxi9flWMsp5mxr5V7Z5BjGpyejr8RZzIPVtMi9r8ZibMzFCOD_-xblLNIxnN-1xzpeYtmEAQRHq7ti2E8gAuTT71Hr1pHZuisw-69xw_877_T6GKv)) - [Custom data types, key equality operators and hash functions](https://github.com/NVIDIA/cuCollections/blob/dev/examples/static_map/custom_type_example.cu) (see [live example in godbolt](https://godbolt.org/clientstate/eJytVwtv2zYQ_is3DdvkVpbtbEMLxw7gJS1mrHCGOG1R1IVCU7RNRCI1kbKTGf7vO5KSLT_apMAcIIl55PG7u-8eXHuKKcWlUF7389rjsdftBF5CxLwgc-Z1PVrExAs8JYucmu-tFxMBL-BSZo85ny80-LQBZ-2zThN__RbA6MPwajiAy-ubv69vBrfD61FoDthD7zhlQrEYChGzHPSCwSAjFP-UkgA-sNyggbOwDb7ZMPFK2cRrnFstj7KAlDyCkBoKxVANVzDjCQP2QFmmgQugMs0STgRlsOJ6Ya8q9Vg48KlUIqea4H6CJzL8NqvvBKK30M1noXXWbbVWq1VILOxQ5vNW4jar1rvh5ZvR-E0ToW-PvRcJuhdy9k_BczR8-ggkQ2SUTBFvQlYgcyDznKFMS4N8lXPNxTwAJWd6RXJm9cRc6ZxPC73nvAon2l_fgO4jAh03GMNwPPHgj8F4OA6sno_D2z-v39_Cx8HNzWB0O3wzhusbDNboamhChd_ewmD0Cf4ajq4CYOg6vIo9ZLmxAqFy41YWOx-OGduDMZMOlsoY5TNOoaIRzOWS5QLNgozlKXeEQ5Cx1ZPwlGui7dqRcfaq1kRMxI9c0KSIGfRoQWVLmSM0SkkW0mJxcbgjJq1ZIajRSpKLukwv8kLpVsyWeEO0ZFTLPFyc2sI1ywlKW1QWwkQlqlae2K9zIhS6I33iQCLnSIXktHCrJHTWtVrwXrG8GbMZFxjme_YI-jFDgmDoC6qB4imZRrgemXVYo-uQUvrXs0gDOa9_m54bjQBRtJBKRxH-U_ojOlTjN2C9ee7eSv9DA7pA1g-bAKb422rYnJ-yYkmSgp20w0pOWDLbs0Q9bclO0XNsqe3es2ZmrVHftsYpgwVRC8DAJibND-2ywrVDsb28qO6SmSOM3_AP40kxQfTPcN9w_2EBLAveGguMLnIB9yE5B4Psm-gMcbAgkeSrEM2VbschzqmUyTMwJgsVHPGxlOULdWiBucTeBJUlqCAk0O-b3aHj7tbp6Cqs3Vz4S8njxkTYk1ahqVSgdNztKv4vBhFEkUYZ4bmCPrxu_9Jut0u6oGvGTANLNZZ9xUx2s0QZCSmwEDt4LM30o8Vf7UCA_UO71s3O5vzkSUel7dn-McXKsyWiy5wRzUzxrsqG6UhcZIU2QWu5XLH2bO-z36Ipm2Pv6IMrHd1uSu7xgqMq5Dsf7-06qm29kooXfrsRuAOmnHa7WS5pQngauRhZA2wtRhGi6B34JTg29-KiRADw-UuNVr41hTd2TN6pXR-6m29OaMbVDVK_0ah5U1asJkiXzA0CnXY7QBaASqTGbqNMTzLdZs6XTLiw1Vy9JUYII6lttyuVUzMBcNyMvZdiLcHD90KujLqVmTmSBOOGuaeRdvZCVIopYVokhjeRJIYZoWWEX7d_CrcBNVD7pf27Hrd2C-xBI6RejeKBMckQ-2K9CSrnfu1TKqlovT4m-PfpsF5anyL7c_Tsl5pnw09QP8kjZOMU3d3rBPXCil6oJdTQhkBVMXCVAOktbcyNp3Eg25HA6bHVm5k4xdWKBWiivSuYYI6HLsZ-LQmDvYx8uatANWbeMAQfF1iK3XnXzHc57VaNa7BunUjZE4n93Sn91OebKb-XkLucfurzZM4fJno9oysL9-a2nulHF6bomjGexf4pd18xbaZOge6eAQbQxnrP8xhXAVMzweL8uc8JRVJWZ0RFhVJ3NWMCUXDndN6FMMR7bJu9q4XyM_9yB7FkSvyCDeIBB_YA7rbIUWra3Ywkit2FFb9KsfJreoI9ftQYFuz8EFr6-dZ5FueteSTZsjQjPIHYzFyGaKZdIRLMWje0GBO380FYHv6_kJTqBtviWLkfnzm7EwetFAMWbWWH6WCEcuYf3VYHwERsFk6QrxxIpjUOTg3l3IA5A3_vbrPLFl5MLw29Hr6wxgWl-DL6Ad5a4hhu2TKowgla652bmcXoKpWb4QNX8Dlt3qf4Ys13r25PLCntnP1edFAsM-2e5F4Tb-zTly87r6BJcrroqzR61YZmE0cd3bTtIGZxMyHp1L7TEz6t6aSUJri4dI9qXMB-KO69TVDJsaDuydE_3uaL_fkPoxeK0w==)) -- [Key histogram](https://github.com/NVIDIA/cuCollections/blob/dev/examples/static_map/count_by_key_example.cu) (see [live example in godbolt](https://godbolt.org/clientstate/eJyVWQtTIzcS_is6X6XOXvwAkk2uDKZCYHNxJcemgE0qtWxNZI1sq5iHM6PBOBT__b5ujWZk430cW8XaenS3-vH1J_HUKXVZmjwrO-P3Tx0Td8ZH_U4is0UlF7oz7qgqlp1-p8yrQtH30au7TLwSF_lqU5jF0oqu6onjw-OvB_j1TV9c_Ta9nJ6Li7fXv769Pr-dvr0a0gbe9ItROit1LKos1oWwSy3OV1Lhv3qmL37TBVkjjoeHoksL7jr13F2nd8JSNnklUrkRWW5FVWqIMaWYm0QL_aj0ygqTCZWnq8TITGmxNnbJqmo5bI74oxaSz6zEeokdK3ybhyuFtI3p9LO0djUejdbr9VCy2cO8WIwSt7gc_TK9eHN182YA05tt77IE7hWF_qsyBQ4-2wi5gmVKzmBvItciL4RcFBpzNifL14WxJlv0RZnP7VoWmuXEprSFmVV2y3neTpw_XAD3yQyOO78R05u7jvjh_GZ602c5v09vf3r77lb8fn59fX51O31zI95eI1hXl1MKFb79KM6v_hA_T68u-0LDdVClH1cFnQKmGnKrjp0Pb7TeMmOeO7PKlVZmbpTwaSQW-YMuMhxLrHSRGpdwMDJmOYlJjZWWx14cjlWN7rK77J8mU0kVa3GqKpWPStqiolSuhqpanu2umI1mSa7u3e8Ivq-UrheGy2IJQfFI2jw1av_cvMoUGSeTrXm7LKrSjmL9AEOjB61sXgyX-5bYQmYlnJMOX5iZSrtjETTGev5izGR2a8zkiLeW6dYgO7JkHaNXLgG_58JQeZXZaLaJ7vUm0o8SUSRnuBWzwui5uNQp_A9TrUYUSopaXQ3uhKI0UHH-67TkOJssNg8mrmQicsS0jl5i7pGNiFphR3MswWfWQWJUnln9aEmqdAYNZpsBDGoF9IUZ6iHLlwJVbfNFIVNBySOwsGyRZPpx9RKWZovE20FZy6Yo1MRMUwJSKDTZ5o-mchztwUiyk8XfddrsQu7MUUR2s9KBAd8DfbS4Jeip_UlVSJbHjSMJx1ZVscqBDijKZDMUU0vLCLkQUI1c57Ivl_mafZQiqiy-tlJmVqyBUlgT57zCK5PJIgdSLNPGpNFW2F1Qp-yCkp1H5eb8XgrSB3jRGclEAJSqKKSswWSryooSiKUBn8GJ7UpSNH6ggroxf2tx8e7yXHB9weV_661V_5UrcQuX-SSCI7234U9dkOytDT_rzdQizlNWbywFFd5cL-E98SCTSkcUAkojpIM1hJ9wC_SMx5TVNLkl8F1mcASW-baynxaKmOzIrRCfb7-J2gbwPUt9b7IPok4Kce0PEh4S-3IoMGpZJ2CJDpQkW6m3K5Dsn-kFAnALKfyJwbIWC_hw1chh5DZBgnelZFUa8QoSYnOL2sDQDOf3WykD-NRluDevrNtcscc-LoN6DLDGOmHOCHcY5J7VyEuAB6DJea5NlD4XTyZTTeEKvtUxD0baoAHFomiR5DOZRJF4yE28hWJdSrA6ENTaPvXjU4vM_txaH_fGm5_bEKTZjg97d9kTba4Ij5w3rrkNiYlAfxqPg6FTr7ffuu2M6I6IonIJFhDDCY2Xgo3j8S0cf4OsJsSmIESl-3JCeCCEP48iUBJJntOCgrB8Ihb4_9Kkw0ckQ6P2JNxl4sed804CAHjlqn8aP0LEAXIVHSnmb7XyxptuaivDJuKQVaFWUHJd0nTaeL0nnpzfRyOP49QpuLh8pTGxq1sJpeeR2yErrHlfJjl8acoo02uS-AH66nQZOoERqiGiztAlOjEer6Qpnkj3e5jyoS-Onplv4sfMYV4jqTGNjZubAm5lAN2CAiz0q16e_eCglvwsdAIkCgXyMVGqCW3aeFCm8w7O8E0VOtWZdaf22_jIhEiUWLEcjx2docNyYn19TInlpmprSvBdHTlEPnsibw3OSo0kiZ9PvFjy1VxbtYxkHHePvIQUDa7YRHkBpgYViXzUsXfVc-0xBPNgEmYbzz-7rMApiZ-DqwbgUlZKgWTOqyTZNNgi4HOHNtRZNTi3y7haCuGZO6qkXbBS1PkB3pDFDsC28tCxwe00DKqpGxZQb3hTpd2X0XNnpaQIEl5MkM9NauyNgivvj0eByzFU1PWBeOWI5HhcyHW0yok6FJGSpe3uQo6Pw66oII4vXPD5uCJuHDooRiaarEtw7OENcbgiLmSX0rJXiAvk8y5Qt3dQf76gbO31zv5Nwakz2mQmrdL2asRsQhZqiTatbFVwVy7T6LvDFkQhkyHIJ_VJO8Uqtqdq696kK7sRlOIoq4L4B11nUETuPkafiwd8BunDoMl0Arrn2uSQ-qCnCiXxtCqJqZWXOoGR2IS0XdZ62AHMpzJNjLVhVbiwFjWtiqWVRKn4JAzJdLkSmkxkcu5NqLG2pqEU61NsOesOjlxI3HF3JThK08jY3s9bvAQfuW2CgOqZ6bCzO2hp1TQcYyJeH_7r8NBBOAT91DBKrtKQKjhHlB7KGrpMDtmjgrwQV3xHpqsIFLGO-iSyJNu63caQr3Y29LgS93Ttu86PfD9tGXu_PU6K8qKj062iZA6IzNixBPZzbZCXVrADEvdpoTOiupAKurRD92pB63wNb10YOai1w13NNx3Qe_YCSGH5WlNTch-toXjz0tdLWe7ajVvEBr9Q_-4C01jS3EtroPHjqbzXETcYFFbkWbPLv8Ne_8sXB-caEhJ0e353OMN8t-tn3n8A5al9FHU5NwxwFWUKTMheFoRBBrTZMNrNht6JeA7y_TwB-pE7a4znvtIwiLYbOXhkN388dh7Uz3aZXzcssYu61Sl6MzJAopks60ca1NBXaJIyFnNJEvdUA81GbpYY0_B1K3jqmEZrNDCJuEFJwHmf5euMUlbGD_QM1hdrzVdgejGj5IQSmaiKKbtnGN5EV2_xeExBa7gjHbJRMREf9Xl4dLoIV4qAt6VsewymZh3rkvtA4I9h4xDaTOSGiFp7NX8KTfocUQ9d-dm1TlMDy08vAfr5_5LBwPy0D6S_RA51Z44HEADXIZtz6j99qQkJ9MgiWhX5DDV6ykSOxmM9l1ViI2DGMvKvXCwasp_bMP5HW8Qvy7MBcorfJtPK8gNmse8GzH0QhCxfl-LPHa79Z_tc42G0VgK8Zce0HP9eF9SLgxSIHMelJz98qnn7jgZfeTt15FgP5TMEHL_-9mR7jSNMPM0_kwBTDsLNA3HUQ8a3IywovJmetnNnLj6np6eN-H6w9ezsrOuvsHsRsb2E7iLMkIhEtxfAzLUGzwbvcO9sVFT00JYkDiMQOx3QoPZW8ZnOBHJEGdJ0psCE94cfXI_av92xDS_AvTt9VISLqDtABKO7gd7WG1uy_HCItEut7omCbsOi21Y_WtBDD25qaod5NJ6OFAuZ7DocphKx-ESnCYCZm6B275YUgtqC-vGNX2F0YeabgDISMd1vmdvV2OW9DbkRmLXLsL2e2XWYxlUXg9xgl3lpoyjstAGhdCqDe27de12fhBde4D0tatos3QF23Nk-PboBaugMaBi0qA_Qpht3__vHHYR0TvxVsdZMNBMjnX6HLo4m0UX756pO9qDU0fHr6gjT-cq6v2V1BpA_UQcHR9-JAd0qJnyVEIMB4MDil3t9HSQynfEfuBIzC2QqpRIMPri_RmEAbSy77zz3_TygZ2sefuw8f-B__wPjPWMs)) +- [Key histogram](https://github.com/NVIDIA/cuCollections/blob/dev/examples/static_map/count_by_key_example.cu) (see [live example in godbolt](https://godbolt.org/clientstate/eJyVWQtPI0cS_it9PkVnL34AuU1OBqMlsLlYyUEEbKIIVpN2T9tuMQ_fTA_GQfz3-6p6eh7GLHusxNr9qKqux1dfN0-dXOe5SZO8M7596piwMz7odyKZLAq50J1xRxWh7PQ7eVpkir6P3t0l4p04S1ebzCyWVnRVTxzuH347wK_3fXHx2_R8eirOLq9-vbw6vZleXgxpA2_6xSid5DoURRLqTNilFqcrqfBfOdMXv-mMrBGHw33RpQV3nXLurtM7YimbtBCx3IgktaLINcSYXMxNpIV-VHplhUmESuNVZGSitFgbu2RVpRw2R_xRCklnVmK9xI4Vvs2bK4W0len0s7R2NR6N1uv1ULLZwzRbjCK3OB_9Mj37eHH9cQDTq22fkgjuFZn-b2EyHHy2EXIFy5Scwd5IrkWaCbnINOZsSpavM2NNsuiLPJ3btcw0ywlNbjMzK2zLed5OnL-5AO6TCRx3ei2m13cd8cPp9fS6z3J-n978dPnpRvx-enV1enEz_XgtLq8QrIvzKYUK334Upxd_iJ-nF-d9oeE6qNKPq4xOAVMNuVWHzofXWrfMmKfOrHyllZkbJXwaiUX6oLMExxIrncXGJRyMDFlOZGJjpeWxF4djVaO75C75u0lUVIRaHKtCpaOctqgglquhKpYn2ytmo1mUqnv3O4DvC6XLhc1loYSgcCRtGhu1e25eJIqMk1Fr3i6zIrejUD_A0OBBK5tmw-WuJTaTSQ7nxMMXZsbSblkEjaGevxgziW2NmRTx1jJuDbIjc9YxeucS8AMXhkqLxAazTXCvN4F-lIgiOcOtmGVGz8W5juF_mGo1opBT1MpqcCcUuYGK01-nOcfZJKF5MGEhI5EipmX0InOPbETUMjuaYwk-sw4So9LE6kdLUqUzaDDbDGBQLaAvzFAPWb4UqGqbLjIZC0oegYV5jSTT19VLWJosIm8HZS2bolATM00JSKHQZJs_mkpxtAcjyU4Wf9epswu5M0cR2c1KNwz4APTR4oagp_QnVSFZHlaOJBxbFdkqBTqgKKPNUEwtLSPkQkA1cp3LPl-ma_ZRjKiy-NJKmVixBkphTZjyCq9MRosUSLGMK5NGrbC7oE7ZBTk7j8rN-T0XpA_wohOSiQAoVVBIWYNJVoUVORBLAz4bJ7YrSdH4gQrq2vylxdmn81PB9QWX_6Vbq_4jV-IGLvNJBEd6b8OfOiPZrQ0_683UIs5TVm8sBRXeXC_hPfEgo0IHFAJKI6SDNYSfcAv0jMeU1TTZEvgpMTgCy7ws7JeFIiZbcgvE57t_BnUD-MBSb03yWZRJIa78QZqHxL4UCoxalgmYowNFUSv1tgWS_TO9QABuIIU_MViWYgEfrho5jNwmSPC2lKSIA15BQmxqURsYmuH8fitlAJ86b-5NC-s2F-yx12VQjwHWWCfMGeEOg9yzGnkJ8AA0Oc_VidLn4klkrClcjW9lzBsjddCAYkGwiNKZjIJAPKQmbKFYlxKsDAS1ti_9-NQis99a6-NeefOtDY002_Jh7y55os0F4ZHzxhW3ITER6E_jcWPo2Ovt1247IbojgiBfggWEcELlpcbG8fgGjr9GVhNiUxCC3H05IjwQwp9HESiJKE1pQUZYPhEL_H9u4uEjkqFSe9TcZcLHrfNOGgDwzlX_NHyEiD3kKjpSyN9K5ZU33VQrwyZin1WhVlByXdJ0XHm9J56c30cjj-PUKbi4fKUxsStbCaXngdshC6y5zaMUvjR5kOg1SfwMfWW6DJ3AANUQUGfoEp0Yj1fSZE-k-xamfO6Lg2fmm_gxc5hXSapMY-PmJoNbGUBbUICFftXLs-_tlZKfhY6ARE2BfEyUakSbNh6U6byDE3xTmY51Yt2p_TY-MiESJVYox2NHZ-iwnFjfHlJiuanSmhx8VwcOkU-eyFuDk1wjScLnIy-WfDXXVi0DGYbdAy8hRoPLNkGagalBRSQfdehd9Vx6DMHcmzSzjeefXVbglMTPwVUb4JIXSoFkzoso2lTYIuBzhzbUWTU4t8u4UgrhmTuqpF2wUpT5Ad6QhA7AWnno2GA7DRvV1G0WUG94XcTdl9FzZ6WkaCS8mCCfq9TYGQVX3q9HgcuxqajrA_HOEcnxOJPrYJUSdcgCJXPb3YYcH4dtUY04vnDB23FF3Dh0UIxMNEmX4NjDG-JwQVzILqVlrxAXSOddoG5vr_x8Rtna6538i4JTZrRJTFzE9dWI2YTM1BJtWtki466cx8H3-zWIQiZDkE_qo3qKVbSnSus-xiu7EZTiKKuM-AddZ1BE7j5Gn7MHfAbpw6BJdAS659rkkPqgpwo58bQiCqmV5zqCkdiEtF2WetgBzKcSTYy1YlW4sGYlrQqllUSp-CQMyXS5EppMZHLuTSixtqShFOtjbDnpDg5cSNxxtyU4SlPJaO_nLV6Cj1ybIKB6ZrrZ2R201GoqjjER7_f_sb_vIByCfqoYJVdpkyo4R-Qeyiq6TA7ZoYK8EBZ8R6arCBSxjvIkMifbut3KkG-2NvS4End07bvOj3w_rRl7vz5OjPKio9OtImcOiMzYsgT2c22Ql1awAxJ3aaEzorqQCjq3Q_dqQet8DbcujBzU0uGu5qsO6D17BqSwfK0pKbmP1lB8fOnrpcy37cYtYoNfqH93gaksqe6lJdD48Vje64AbDAor8KzZ5d9-r__1ixvnGhISdHt-d3OG-W7Xz9x-BuUpfRR0OTcMcBVlCkxIXhaEQQbU2TDazobekXhu5PtpBPQjd5YYz32lYhB1N3LwyG5-PXYe1E-2mV-3WWJnZatT9GZkgEQzmZePNKihb9AkZSjmkiTuqAaaDdwsMabh-1rw1DGN2mhgEnGDnIDzPknXCaWsDB_oGawv1pqvwPRiRskJJTJSBVN2zzC8ia7ewvGYglZxRzpkpWIiXvV58-h0ES4UAW9N2XYYTM061Dn3gYY_hpVDaDORGyJq9dX8qWnSW0S96co31zpNFSw_vQTo5_9LBgPz0y6Q_ho51J05HkAAXIdsyqn_9LUmRNAjs2CVpTPU6DETORoP9VwWkQ2AGcvAv3KxaMh-rsP4b20RvyRNBsgpfpuMC8sPmNmuGzD3QRCydJ2LP7e49p_1c42H0VIJ8JYdU3P8e51RL26kQOA4Lj354VPJ27c0-MrbqiPHeiifIeDw_XdH7TWOMPE0_0wamLLX3DwQBz1kfD3Cgpo30-N67sTF5_j4uBLfb2w9OTnp-ivsTkSsL6HbCDMkItHtNWDmSoNng3e4dzYqKnpoiyKHEYidbtCg-lbxRmcCOaIMqTpTw4Tb_c-uR-3e7tiGF-DenV4V4SLqDhDA6G5Db-2Nliw_3ETapVb3REHbsOi2lY8W9NCDm5raYh6VpwPFQibbDoepRCy-0GkawMxNULt3SwpBaUH5-MavMDoz802DMhIx3W2Z2-XtajdfCA9Ar3c6ZttfGjddDLb7a4NGOkWN223ZcV13xNlfoDwtqporMf8tJ9YPjm6A2jjDGAYtqgJk6drd-v52ByGdI39BLDUTucRIp9-h66KJdFb_kaqTPCh1cPi-OMB0urLuL1idAeRP1N7ewfdiQHeJCV8gxGAAELD45d5cB5GMZ_xnrcjMGjKVUhEGH9zfoDCA5pXcd577fh6A05qHHzvPn_nf_wAAaV-z)) ### `static_multimap` @@ -251,7 +251,7 @@ We plan to add many GPU-accelerated, concurrent data structures to `cuCollection #### Examples: - [Host-bulk APIs](https://github.com/NVIDIA/cuCollections/blob/dev/examples/hyperloglog/host_bulk_example.cu) (see [live example in godbolt](https://godbolt.org/clientstate/eJyNVm1v4kYQ_isj9wvkwAbaKi2XRCUvvVp3IqfAXXQqFVl2B1jFXrv7Akmj_PfOrjExTVrVoES7M_vMM8_MLH6KDBojC2Wi4e9PkRTRsN-JMqZWjq0wGkbcCRZ1IlM4zf06OZopOIKLonzUcrW20OJtGPQGP3Rg_DW9TEdwcX3z-fpmNE2vx7H3Df6fJEdlUIBTAjXYNcKoZJz-7Swd-IraE4FB3IOWd5hFO9ssar8PKI-Fg5w9giosOIMEIw0sZYaADxxLC1IBL_Iyk0xxhK206xBqhxPowLcdSLGwjPwZnShptWx6ArN76v5ZW1sOk2S73cYs0I4LvUqyytkkn9KLq_HkqkvU98e-qIyUBY1_Oqkp8cUjsJKYcbYgvhnbQqGBrTSSzRae-VZLK9WqA6ZY2i3TGHCENFbLhbMH4tU8Kf-mA8nHFAk3mkA6mUVwPpqkk07AuU2nv11_mcLt6OZmNJ6mVxO4vqFijS9TXypa_Qqj8Tf4mI4vO4AkHYXCh1L7LIiq9LKiqDScIB7QWBYVLVMil0vJoe4gWBUb1IrSghJ1LqteI5Ii4GQyl5bZsPcquRAqmanvpOKZEwgn3PEiWT8SUlas6Btztz6bqaaLXWtnbCJwQyDzDXJb6Ng7vXIxVBmkNon_CcFzZg9PcGOFwOXBnixIdmR5OJwcVUX_JTTjmkzzhcvu5_jASDYknpV5oSUu4RJzSthqZpHSNl4mar87n91w2EjvjirpYaiQHhJGn1NTiyKVpS6WqrUppGjP1BPtE5YXegr_9pxSm1k_StTzRMBXFyi14dDIv3BuQbl8Li3mhjz7Lsvg5AQGP70HSBLofzj3mQJU8g2HBxKfTM8gnGztMfzMen86-wEV-mzhbm-9C31LatrqXBO5rkwrWOIFrijPdqdyjFEJv-g18G8RqDxSVU0p0ISJM5bajGkBnmlosnrKaRB18SDzahO1LvQOqRf3-oNB_-djP1kV2JK5zMKGZQ5935J0mmaiLJQwfnAZfD_4eA7mHi1fgxfSQzFHpiAyGEFqVrWtGc33jJ72AZ9f0kkVXQQsI6hAAUknolpxfNUkXvm9x5MRDZyREMCoilVJidArtP0iZkL8h9ztA1DfZGHaWY47cLbyd-lWUjR_ObPlktoiOJFWpN__DLZbwrtGKyYwaIS_YBl3me8lD85JTKlIKvtYwwf5m01dVaG2innzzGmDVO3RqqMFEF4468dgFk21Owg4pD1v2TP1Z16ecGY2U1d14LfOvs1qf9Q3pnd9hRyosYVpHVrCY_yFygnQ2BNROPq1OWu9GadN0r7l_DLB0IV-3Gu_HZ4aI9sppdE6raBHy2d6WfA_wXQP6pd3ikhtOO8PfnR9MhelrV44oi4BnfJ37_rH0GWar09NPj_uQbdLN5OlP5ZioOhmLF-Et5BMLhqYnPOMNjfVewNtWO3UffTcqe00Kgd2mrro-Y_w-Rvi8QMW)) -- [Device-ref APIs](https://github.com/NVIDIA/cuCollections/blob/dev/examples/hyperloglog/device_ref_example.cu) (see [live example in godbolt](https://godbolt.org/clientstate/eJydWY9z2jgW_ld03OyNSQkkudvZGxIyR5tul9le0gl0OztlxwhbgCbG4iQ5hHbyv9_3JAtsAp3u0kyJ7aen9-N733tyvjaMMEaq3DS6n782ZNronrcaGc_nBZ-LRreRFClvtBpGFTqh687JOGcn7I1abbScLyyLkia7OLv4V4vd_ja4GfTZm7v7D3f3_dHg7rZNsk7-vUxEbkTKijwVmtmFYP0VT_BVPmmx34QmQ9hF-4xFJDBulM_Gjeal07JRBVvyDcuVZYURUCMNm8lMMPGUiJVlMmeJWq4yyfNEsLW0C7dVqceZw34vlaip5ZDnWLHC1awqybjdmk6fhbWrbqezXq_b3JndVnreybyw6bwfvHl7O3x7CtO3yz7mGSLLtPhfITUcn24YX8GyhE9hb8bXTGnG51rgmVVk-VpLK_N5ixk1s2uuhdOTSmO1nBa2FrxgJ_yvCiB8PEfg-kM2GI4b7HV_OBi2nJ5Pg9Evdx9H7FP__r5_Oxq8HbK7eyTr9mZAqcLVz6x_-zv7dXB702ICocNW4mmlyQuYKimsIvUxHApRM2OmvFlmJRI5kwkLCGJz9Sh0DrfYSuil9FiDkanTk8mltNy6ey-cc1t1xvnfZZ5kRSrYVVIkqrPYQFOm5vhpJ8XiepzXRVLeMTbtJPgvFbPr6kO70IWxnVQ8Yof4USRW6fbikIhB2gQw1N7XLxWiLfjS3e6c-Fz_x2GwVKvFLBZPHOESsM8_n2opZuxGLOGo1dwKuGsoPIDdhLzqdituTUpVp0Ziy_6HgdkV0oggX6qHWEXhQq1d9HKVn6q1CzlMEZrcYBbaD-xExk6c3gS4mQqqKg9H0r8UuaX6QEDUkj0gjyLDFtyyGeSM2y3hOpU5z6TdMGGsXLpsMmPFytcfzzduA-UAtVb6IVM89WpgOdARVMl8VViWcstD5se5FTAE7iGxGQcQ78VsBPNbzF8OaMnAIhlxDH-mPItj9qhk6ixMY29zVK6ieLTCGvCGNhbFZtNu18gvIrYsb47zr9ibdTpspHlugOuls20vkpFzzWeJGRCIaFLU-L6cE5tmKnnwUqS7MJQa3IOxhBUn2HPyOV-K4GK3S4tjt8yhutsFNgVP_a3Yab2-pCA5e4cLTjSzBCT0Bl4pTfgKhemkT92mIU1K00rxZBEjFsfGrUf4_F4uLNMNIu8tNQ_CJovPf-w2HC1IfZapNfkDToSTwKZaEQCwDdxMPEtMOTFqmnoqmbF0A0dBEqZmMtaCMhB1C0os90BMl0JYpwUYm-cOkiWn0u_GCVJpMF5AOqF6qIj26Alj50WWsaurqm-JKnKr4y9Cq0gLiV01uM7GCTf2ykkUuLmCiL2OqjFoumbEAD-hbbTb6rq3l1Rs5BbEW5moXOuxXTM5U2oVE5GnBIY5vm_ksv2EwnGpcxeX2zUyfWL1T68iFxYN0idcvGIeN-7qcm9bj82gIoERAmwiH0U816pYGQKdNHGJPCcdNXcYeIPb1id5D1u75msOAZPW75XA9jKqZMmseP61Gv0WlVi7DCzh00TN54pFgxxNFAH_ctCq2rbtJBNcR84pnxf3a9ts8mTr5HpB1B5RwK_AD-yrB9QuhP9gEiSF4J1EjlEQbwiH5c6mfpoyganBS2LhEcuqtqFcIhKvKDrx37-AYNhaOMaGFKYFkEbJ0Xv0yh9q1DohhZN2UEgFDLhxqjwnf4TLy9bgGHXL6Yf43Kutk7qjczZ0XDCpuTdxinWBDTJFw5yPy_DufRjGbu77_wV55OlaphaZh9NzEXbB89JGmhSJ52aYpTDz-IwBx0TeRE3eUpoLizBr0FCyM89rDEXJXHW96lVL0qHj-QhEkOFPZToyo8qNDsBP0HjmNnV9o1xa4wAKz1a6wiftcLOKVjlj_rJdlie4E9XJej12tgVqSdR7hpiFKrKUBlKtntytbEM5nuTFMiaUmElnsiWhyVbVSoMTZ9G48TZoosB7EvkhhcU_ZFkxRlgarQoFtfY8a4ZwbmvWpzNPXY6XQs_FAerYcQuM8GDxPb_KOguJOpuDwGjCIplyjxkBG9xhiswhiILqNvIhbO1iTdY912ePam9u7Tp1OUlU7twV9thAUk6HIQZhNPEjWclnbgx5mLL6ZcuH_zs-YbSR-fevCaPP968ITjJV2DAw_cUx4kUn-gs9SOXALqdxY56Vg06oQVOjiXrNON2xxKHjKWqiTdaqBnnegWq_H0X1fgTZbQJ9Q6qnr9nccfhW58vec5BamKuvCHhnMrT4erVf4gEaE329CgJUxF4IzXHrU3V36i4nUEvNqhn2fz5oBt1ClMuGUyU3X1KHyY1OeKgxW-i8nJ-p8ALHL3CI2u-jrMJ7O0Nf8l5J0d_mPnYCbO4UiUvv3HNZ2RTPJQ7_EVVmgLCfy0dHYd8j2rncSW6N9ONLTfLFQetqdO2WOlfpVF0_dwTWxdIwql78-9IF_vzd671K2SOLsOc_L-JfX5cB8qfYbrd20oUNbgIx0Xa_Shm9EzmVXa0HuHcLaN3Wr6tqDgdkN6SY9lTMEc5mywu2QeV0cXZ8MKsfQuqh3FXeXiXttNFIxREoH7USVod1bkepw1ZWp1meJUUWBtoD0xAwr5U_EE6L7IGVTKWcgmpC64hO44qu2K08iPGqKUQPdacw6MHuMI1pQeNY3VHPKRUtt8VyikHn6JHL0dXuFRXCSOM5ipe9GfXL06JPwWEI-vVVX-qDeS20mY9q7WUCscSKDvL8yGuLvcSGG-8-fCTF1UP-1dXV-VmL_Xh-0aqZd319He3so-PFNv9bOByqhz8DhppTfwYL5cJvouFwLVd2uN6fLaJzT9yHR47dNFMvu243HMWOv2649uxLsT4S6r3R5WikW_vWBZng9veGsOw3vX19n8_CkEG94tvh732rVP27ymoDPWLBt7Rsu3B492CJ48eNYZEkwpi_AW4vAYay0O6IlluJUsTZBmucAjBXVh2iy0575kfXRqtBfRrHIL17rd_IH5Pk_OLH4hyP_UsaPGycQl8vefXq_Cd2ynWy6Jll_NMZOz1Fk7KnNNZhQkpPM76cuj8EZHJa0ZkkSYabj_7VPW5YnOceGs-t8Bx9sPYcsWo8_-H-_R_hsm5I)) +- [Device-ref APIs](https://github.com/NVIDIA/cuCollections/blob/dev/examples/hyperloglog/device_ref_example.cu) (see [live example in godbolt](https://godbolt.org/clientstate/eJydWQ1v2zgS_Ss8H_Ygp_5IclfswYmN8zbdrrG9pIjdLRb1QqYl2iYiSz6SiuMW-e_3hhRlybGL7jpFHEnD4Xy8eTNUvza00FpmqW70Pn9tyLjRu2g1Ep4uc74UjV4jymPeaDV0lquIrrtn05SdsTfZZqfkcmVYEDXZ5fnlv9r49brFbn8b3YyG7M3d_Ye7--FkdHfboQV20XsZiVSLmOVpLBQzK8GGGx7hq3jSYr8JRdawy845C0hg2iieTRvNK6tll-VszXcszQzLtYAaqdlCJoKJp0hsDJMpi7L1JpE8jQTbSrOyWxV6rDns90JJNjcc8hwrNrhaVCUZN6Xp9FkZs-l1u9vttsOt2Z1MLbuJE9bd96M3b2_Hb9swvVz2MU0QXqbE_3Kp4Ph8x_gGlkV8DnsTvmWZYnypBJ6ZjCzfKmlkumwxnS3Mlith9cRSGyXnuakFz9sJ_6sCCB9PEbjhmI3G0wb7aTgejVtWz6fR5Je7jxP2aXh_P7ydjN6O2d09knV7M6JU4epnNrz9nf06ur1pMYHQYSvxtFHkBUyVFFYRuxiOhaiZscicWXojIrmQEfMwYsvsUagUbrGNUGvpAAcjY6snkWtpuLH3Xjhnt-pO07_LNEryWLDrKI-y7moHTUm2xL9OlK8G07QuEvOuNnE3wq9YLAbVh2alcm26sXjEDuGjiEymOqtjIhppE8BQ51C_zBBtwdf2dvfM5fo_FoOFWiUWoXjiCJeAfe75XEmxYDdiDUeN4kbAXU3hAexm5FWvV3FrVqhqa4kthx9Gel9IE4J8oR5iFYWrbGujl2ZpO9vakMMUocgNZqD9yE5k7MzqjYCbuaCqcnAk_WuRGqoPBCRbswfkUSTYghu2gJy2u0VcxTLliTQ7JrSRa5tNpo3YuPrj6c5ukFlAbTP1kGQ8dmpgOdDhVcl0kxsWc8N95qepETAE7iGxCQcQ78ViAvNbzF2OaMnIIBlhCH_mPAlD9pjJ2FoYh87moFhF8Wj5NeANpQ2KzcS9npZfRGhY2pymX7E363bZRPFUA9dra9tBJAPrmssS0yAQ0aSo8UM5KzZPsujBSZHuXFNqcA_GElasYN_Kp3wtvIu9Xuk7aQntegtvPFkBgrG7FVr1gyuKljV8vOLEN2tgQ-3gXqYIaL5CrXTb7u7zlSlaKZ4MgsXCUNv1iKPby8ZnvoMZzmT9IEy0-vzHfsPJitQnSbYlx0CO8BYgzTaEBGwDfyNHF3NO1BrHjlMWLN7BY7CFrpmMteAOhN-AG4s9ENy1EMZqAdiWqcVmQa70t7aCVCOM55COqDAqon16wthFniTs-rrqW5TlqVHhF6GyQAmJXRVIz4QR1-baSuS4uYGIGQTVGDRtV2LAoVAm2G816B9kFxvZBWEpExRrHchrJidZtgmJ0WNCxRLfN3LdeUIF2dTZi6tyjYyfWP3Tr8j5RaP4CRevmMONvbo62NaB1KuIYIQArchHES5Vlm80gU7qsECelQ6aewy8wW3jknyArX0X1seASesPaqG8DCpZ0huefq1Gv0W11ikCS_jUQfO5YtEoRTdFwL8ctaq2bSdKBFeBdcrlxf7Z0bs0Kp3crojjAwr4NYiCfXWA2ofwH0yiYhG8s8BSC-INYb_c2jSMYyYwPjhJLDxhWdU2lEtA4hVFZ-77FzAN2wpL3ZDC2AD2KMj6gGf5Q41jZ6Rw1vEKqYABN06VZ-VPkHrRIyy1luR-jNid2jq7W15nY8sFs5p7M6tY5dggyWiqc3EZ3733U9nN_fC_II803srYIPNwein8Lnhe2EgjI_HcAkMVhh-XMeCYWJyoyVlKA2Luhw6aTvbmOY2-KJmtrlf9akladDyfgAgy_KlIR6KzYqMj8BM0p9lNbQMpltY4gMJTSlf4pONvVtEqF8xddoryBHeiOlm_z85LoBZEfWCIXmV5EtNkqrIneyvZUY5nab4OCSV61p2VJDQrVW0UOHERTBtvvSYKvCORH2JY_EOS5FOEpdGqUFDrwLOmD2dZsy6daWxzvBZqKY5Qx55bYIQDi2v-VdZZSdTZEgRGoxbJFHssCNjgDp0nFkEUVLuRC2FrH2uy7rk-hFSbdGvfsouRonLnLjenJpNiTPQx8DOKm80KPrPzyMOc1S9bLvzf8fEzjky_f42fgb5_hXeSZbnxk9NfHCNedKK_0IOyFNjlNG4sk2LQ8TWoazRRrxmrO5Q4fTwFTbTJWtUgz3tQHfajoN6PIFsm0DWkevqazT2Hlzpf9p6j1MJsfQXAO5O-xder_QoP0Jjo65UXoCJ2QmiOpU_V3am7nEEtNaum3__5qBl0C1EuGk6V3FxJHSc3Ouqhxkyu0mKQpsLzHL_Caeqwj7IK7-0Nfcl7BUV_m_vYGbC5VySunHPPRWVTPNdcpgFVpoewG9AnJ2HfJ9q52kuWRrrxpSb54sR1PRnYpdZVOl7XDyCedbHUj6qX_76ygb9499NBpRyQhd_zn5fhrz8VAXLH2V6vduSFDXYC0UG5X6WM3omUyq7WA-xLBrRu49ZVNfuTsh1SdGculghns-UEO6Byujg_PZjVDyH1UO4r76CS9tpopOIIlItaAavjOstR6riV1WmWJ1Ge-IH2yDQEzKvMnQznefLACqbKrIJqQuuIjsOKrtCuPIrxqilED3WnMOjBbj-NKUHjWN1RxykVLbf5eo5B5-SRy9LV_l0VwkjjOYqXvZkMi9OiS8FxCLr1VV_qg3kttImLau2tArHEhk70_MT7i4PE-hvvPnwkxdXT_vX19cV5i72-uGzVzBsMBsHePjpelPkv4XCsHv4MGGpO_RksFAu_iYbjtVzZYXA4WwQXjriPjxz7aaZedr2eP4qdft0wcOxLsT4R6oPR5WSkW4fWeRnv9veGsOg3_UN9n8_9kEG94tvh73-rVN1Ly2oDPWHBt7SUXdi_ezDE8dPGOI8iofXfALeXAENZKHtES41EKeJsgzVWAZgrqQ7RRac9d6Nro9WgPo1jkNq_5G-kj1F0cfk6v8Bj95IGDxtt6OtHr15d_MjaXEWrvl6HP56zdhtNyrRprMOEFLcTvp7b_xZI5LyiM4qiBDcf3Tt83DA4zz00nlv-Ofpg7Tli1Xj-w_78Hx3Ycro=)) ### `bloom_filter` diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt index 17b5b21c1..34e63fd28 100644 --- a/benchmarks/CMakeLists.txt +++ b/benchmarks/CMakeLists.txt @@ -28,7 +28,11 @@ function(ConfigureBench BENCH_NAME) target_include_directories(${BENCH_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}") target_compile_options(${BENCH_NAME} PRIVATE --compiler-options=-Wall --compiler-options=-Wextra - -Wno-deprecated-gpu-targets --expt-extended-lambda -Xcompiler -Wno-subobject-linkage -lineinfo) + --compiler-options=-Werror -Wno-deprecated-gpu-targets --expt-extended-lambda) + # Add GCC-specific warning suppression only for GCC + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + target_compile_options(${BENCH_NAME} PRIVATE -Xcompiler -Wno-subobject-linkage) + endif() target_link_libraries(${BENCH_NAME} PRIVATE nvbench::main pthread diff --git a/benchmarks/dynamic_map/contains_bench.cu b/benchmarks/dynamic_map/contains_bench.cu index 65cc61a13..594bc135b 100644 --- a/benchmarks/dynamic_map/contains_bench.cu +++ b/benchmarks/dynamic_map/contains_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -43,7 +43,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> dynamic_map_contains( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/dynamic_map/erase_bench.cu b/benchmarks/dynamic_map/erase_bench.cu index aa4ade39d..444ca1de7 100644 --- a/benchmarks/dynamic_map/erase_bench.cu +++ b/benchmarks/dynamic_map/erase_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -43,7 +43,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> dynamic_map_erase( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/dynamic_map/find_bench.cu b/benchmarks/dynamic_map/find_bench.cu index 3706dd512..7f3b04af5 100644 --- a/benchmarks/dynamic_map/find_bench.cu +++ b/benchmarks/dynamic_map/find_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -43,7 +43,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> dynamic_map_find( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/dynamic_map/insert_bench.cu b/benchmarks/dynamic_map/insert_bench.cu index b84bff501..a45807d26 100644 --- a/benchmarks/dynamic_map/insert_bench.cu +++ b/benchmarks/dynamic_map/insert_bench.cu @@ -45,7 +45,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> dynamic_map_insert( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/dynamic_map/retrieve_all_bench.cu b/benchmarks/dynamic_map/retrieve_all_bench.cu index 8c0bc9339..fdc3d2aec 100644 --- a/benchmarks/dynamic_map/retrieve_all_bench.cu +++ b/benchmarks/dynamic_map/retrieve_all_bench.cu @@ -42,7 +42,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> dynamic_map_retrieve_all( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/hyperloglog/hyperloglog_bench.cu b/benchmarks/hyperloglog/hyperloglog_bench.cu index 901f484cb..ea08ce892 100644 --- a/benchmarks/hyperloglog/hyperloglog_bench.cu +++ b/benchmarks/hyperloglog/hyperloglog_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, NVIDIA CORPORATION. + * Copyright (c) 2024-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -58,7 +58,7 @@ template thrust::device_vector items(num_items); - key_generator gen; + key_generator gen{}; Estimator estimator{cuco::sketch_size_kb(sketch_size_kb)}; double error_sum = 0; for (std::size_t i = 0; i < num_samples; ++i) { @@ -97,7 +97,7 @@ void hyperloglog_e2e(nvbench::state& state, nvbench::type_list) thrust::device_vector items(num_items); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), items.begin(), items.end()); estimator_type estimator{cuco::sketch_size_kb(sketch_size_kb)}; @@ -126,7 +126,7 @@ void hyperloglog_add(nvbench::state& state, nvbench::type_list) thrust::device_vector items(num_items); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), items.begin(), items.end()); state.add_element_count(num_items); diff --git a/benchmarks/static_map/contains_bench.cu b/benchmarks/static_map/contains_bench.cu index e190a6dc5..118ae18ae 100644 --- a/benchmarks/static_map/contains_bench.cu +++ b/benchmarks/static_map/contains_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2024, NVIDIA CORPORATION. + * Copyright (c) 2021-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -45,7 +45,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_map_contains( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_map/erase_bench.cu b/benchmarks/static_map/erase_bench.cu index fca4f9759..55cf7b573 100644 --- a/benchmarks/static_map/erase_bench.cu +++ b/benchmarks/static_map/erase_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2024, NVIDIA CORPORATION. + * Copyright (c) 2021-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -45,7 +45,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_map_erase( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_map/find_bench.cu b/benchmarks/static_map/find_bench.cu index c8db479b9..2b8a97aa3 100644 --- a/benchmarks/static_map/find_bench.cu +++ b/benchmarks/static_map/find_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2024, NVIDIA CORPORATION. + * Copyright (c) 2021-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -45,7 +45,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_map_find( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_map/insert_bench.cu b/benchmarks/static_map/insert_bench.cu index 1e95c3b27..f83df9a81 100644 --- a/benchmarks/static_map/insert_bench.cu +++ b/benchmarks/static_map/insert_bench.cu @@ -44,7 +44,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_map_insert( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_map/insert_or_apply_bench.cu b/benchmarks/static_map/insert_or_apply_bench.cu index 4633a8b0f..a6e7d3169 100644 --- a/benchmarks/static_map/insert_or_apply_bench.cu +++ b/benchmarks/static_map/insert_or_apply_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -46,7 +46,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_map_insert_or_appl thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_multimap/count_bench.cu b/benchmarks/static_multimap/count_bench.cu index 15afb29fe..97bbe6a83 100644 --- a/benchmarks/static_multimap/count_bench.cu +++ b/benchmarks/static_multimap/count_bench.cu @@ -45,7 +45,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_multimap_count( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_multimap/insert_bench.cu b/benchmarks/static_multimap/insert_bench.cu index 80fe068c9..f86024043 100644 --- a/benchmarks/static_multimap/insert_bench.cu +++ b/benchmarks/static_multimap/insert_bench.cu @@ -44,7 +44,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_multimap_insert( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_multimap/query_bench.cu b/benchmarks/static_multimap/query_bench.cu index 5100e5241..05b8337c6 100644 --- a/benchmarks/static_multimap/query_bench.cu +++ b/benchmarks/static_multimap/query_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2024, NVIDIA CORPORATION. + * Copyright (c) 2021-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -45,7 +45,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_multimap_query( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_multimap/retrieve_bench.cu b/benchmarks/static_multimap/retrieve_bench.cu index 02ad6b3b9..f042d3d9c 100644 --- a/benchmarks/static_multimap/retrieve_bench.cu +++ b/benchmarks/static_multimap/retrieve_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2024, NVIDIA CORPORATION. + * Copyright (c) 2021-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -45,7 +45,7 @@ std::enable_if_t<(sizeof(Key) == sizeof(Value)), void> static_multimap_retrieve( thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); thrust::device_vector pairs(num_keys); diff --git a/benchmarks/static_multiset/contains_bench.cu b/benchmarks/static_multiset/contains_bench.cu index 254269110..03a202001 100644 --- a/benchmarks/static_multiset/contains_bench.cu +++ b/benchmarks/static_multiset/contains_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, NVIDIA CORPORATION. + * Copyright (c) 2024-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -41,7 +41,7 @@ void static_multiset_contains(nvbench::state& state, nvbench::type_list keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); cuco::static_multiset set{size, cuco::empty_key{-1}}; diff --git a/benchmarks/static_multiset/count_bench.cu b/benchmarks/static_multiset/count_bench.cu index 542a89ac4..1c20d4a6f 100644 --- a/benchmarks/static_multiset/count_bench.cu +++ b/benchmarks/static_multiset/count_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, NVIDIA CORPORATION. + * Copyright (c) 2024-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,7 +42,7 @@ void static_multiset_count(nvbench::state& state, nvbench::type_list) thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); auto map = cuco::static_multiset{size, cuco::empty_key{-1}}; diff --git a/benchmarks/static_multiset/find_bench.cu b/benchmarks/static_multiset/find_bench.cu index cb1baa399..67740c4c8 100644 --- a/benchmarks/static_multiset/find_bench.cu +++ b/benchmarks/static_multiset/find_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, NVIDIA CORPORATION. + * Copyright (c) 2024-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,7 +42,7 @@ void static_multiset_find(nvbench::state& state, nvbench::type_list) thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); cuco::static_multiset set{size, cuco::empty_key{-1}}; diff --git a/benchmarks/static_multiset/insert_bench.cu b/benchmarks/static_multiset/insert_bench.cu index 90939f12d..ddbdc1aac 100644 --- a/benchmarks/static_multiset/insert_bench.cu +++ b/benchmarks/static_multiset/insert_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, NVIDIA CORPORATION. + * Copyright (c) 2024-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -40,7 +40,7 @@ void static_multiset_insert(nvbench::state& state, nvbench::type_list thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); state.add_element_count(num_keys); diff --git a/benchmarks/static_multiset/retrieve_bench.cu b/benchmarks/static_multiset/retrieve_bench.cu index 01ce7599b..38f4b11fa 100644 --- a/benchmarks/static_multiset/retrieve_bench.cu +++ b/benchmarks/static_multiset/retrieve_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, NVIDIA CORPORATION. + * Copyright (c) 2024-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,7 +42,7 @@ void static_multiset_retrieve(nvbench::state& state, nvbench::type_list keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); gen.dropout(keys.begin(), keys.end(), matching_rate); diff --git a/benchmarks/static_set/contains_bench.cu b/benchmarks/static_set/contains_bench.cu index 8a4fc6867..881481cce 100644 --- a/benchmarks/static_set/contains_bench.cu +++ b/benchmarks/static_set/contains_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -41,7 +41,7 @@ void static_set_contains(nvbench::state& state, nvbench::type_list) thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); cuco::static_set set{size, cuco::empty_key{-1}}; diff --git a/benchmarks/static_set/find_bench.cu b/benchmarks/static_set/find_bench.cu index c6922ae62..aab073729 100644 --- a/benchmarks/static_set/find_bench.cu +++ b/benchmarks/static_set/find_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,7 +42,7 @@ void static_set_find(nvbench::state& state, nvbench::type_list) thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); cuco::static_set set{size, cuco::empty_key{-1}}; diff --git a/benchmarks/static_set/insert_bench.cu b/benchmarks/static_set/insert_bench.cu index be104def5..6b39811e8 100644 --- a/benchmarks/static_set/insert_bench.cu +++ b/benchmarks/static_set/insert_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -40,7 +40,7 @@ void static_set_insert(nvbench::state& state, nvbench::type_list) thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); state.add_element_count(num_keys); diff --git a/benchmarks/static_set/rehash_bench.cu b/benchmarks/static_set/rehash_bench.cu index 9a973c63a..684fcc4d4 100644 --- a/benchmarks/static_set/rehash_bench.cu +++ b/benchmarks/static_set/rehash_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -40,7 +40,7 @@ void static_set_rehash(nvbench::state& state, nvbench::type_list) thrust::device_vector keys(num_keys); // slots per second - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); state.add_element_count(capacity); diff --git a/benchmarks/static_set/retrieve_all_bench.cu b/benchmarks/static_set/retrieve_all_bench.cu index 385bd9726..8f32ce797 100644 --- a/benchmarks/static_set/retrieve_all_bench.cu +++ b/benchmarks/static_set/retrieve_all_bench.cu @@ -40,7 +40,7 @@ void static_set_retrieve_all(nvbench::state& state, nvbench::type_list keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); cuco::static_set set{size, cuco::empty_key{-1}}; diff --git a/benchmarks/static_set/retrieve_bench.cu b/benchmarks/static_set/retrieve_bench.cu index 50c59c0b6..3df65c8df 100644 --- a/benchmarks/static_set/retrieve_bench.cu +++ b/benchmarks/static_set/retrieve_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, NVIDIA CORPORATION. + * Copyright (c) 2024-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,7 +42,7 @@ void static_set_retrieve(nvbench::state& state, nvbench::type_list) thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); gen.dropout(keys.begin(), keys.end(), matching_rate); diff --git a/benchmarks/static_set/size_bench.cu b/benchmarks/static_set/size_bench.cu index 327d68144..abb2ac8a4 100644 --- a/benchmarks/static_set/size_bench.cu +++ b/benchmarks/static_set/size_bench.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -40,7 +40,7 @@ void static_set_size(nvbench::state& state, nvbench::type_list) thrust::device_vector keys(num_keys); - key_generator gen; + key_generator gen{}; gen.generate(dist_from_state(state), keys.begin(), keys.end()); state.add_element_count(num_keys); diff --git a/ci/matrix.yml b/ci/matrix.yml index f5d3f620b..b35859289 100644 --- a/ci/matrix.yml +++ b/ci/matrix.yml @@ -14,7 +14,7 @@ # limitations under the License. cuda_oldest: &cuda_oldest '12.0' -cuda_newest: &cuda_newest '12.8' +cuda_newest: &cuda_newest '12.9' # The GPUs to test on # Note: This assumes that the appropriate gpu_build_archs are set to include building for the GPUs listed here @@ -23,7 +23,7 @@ gpus: - 'v100' # The version of the devcontainer images to use from https://hub.docker.com/r/rapidsai/devcontainers -devcontainer_version: '25.08' +devcontainer_version: '25.10' # Each environment below will generate a unique build/test job # See the "compute-matrix" job in the workflow for how this is parsed and used @@ -43,6 +43,7 @@ devcontainer_version: '25.08' pull_request: nvcc: - {cuda: *cuda_oldest, os: 'ubuntu22.04', cpu: 'amd64', compiler: {name: 'gcc', version: '11', exe: 'g++'}, gpu_build_archs: '70', std: [17], jobs: ['build', 'test']} - - {cuda: *cuda_newest, os: 'ubuntu22.04', cpu: 'amd64', compiler: {name: 'gcc', version: '12', exe: 'g++'}, gpu_build_archs: '70', std: [17], jobs: ['build', 'test']} - - {cuda: *cuda_newest, os: 'ubuntu22.04', cpu: 'amd64', compiler: {name: 'gcc', version: '13', exe: 'g++'}, gpu_build_archs: '80', std: [17], jobs: ['build']} - - {cuda: *cuda_newest, os: 'ubuntu22.04', cpu: 'arm64', compiler: {name: 'gcc', version: '12', exe: 'g++'}, gpu_build_archs: '60,90', std: [17], jobs: ['build']} + - {cuda: *cuda_newest, os: 'ubuntu22.04', cpu: 'amd64', compiler: {name: 'gcc', version: '13', exe: 'g++'}, gpu_build_archs: '70', std: [17], jobs: ['build', 'test']} + - {cuda: *cuda_newest, os: 'ubuntu22.04', cpu: 'amd64', compiler: {name: 'gcc', version: '13', exe: 'g++'}, gpu_build_archs: '80,90', std: [17], jobs: ['build']} + - {cuda: *cuda_oldest, os: 'ubuntu20.04', cpu: 'amd64', compiler: {name: 'llvm', version: '14', exe: 'clang++'}, gpu_build_archs: '70', std: [17], jobs: ['build']} + - {cuda: *cuda_newest, os: 'ubuntu22.04', cpu: 'amd64', compiler: {name: 'llvm', version: '18', exe: 'clang++'}, gpu_build_archs: '90', std: [17], jobs: ['build']} diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index 12b508404..01276b2cd 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -25,7 +25,11 @@ function(ConfigureExample EXAMPLE_NAME EXAMPLE_SRC) target_include_directories(${EXAMPLE_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}") target_compile_options(${EXAMPLE_NAME} PRIVATE --compiler-options=-Wall --compiler-options=-Wextra - -Wno-deprecated-gpu-targets --expt-extended-lambda -Xcompiler -Wno-subobject-linkage) + --compiler-options=-Werror -Wno-deprecated-gpu-targets --expt-extended-lambda) + # Add GCC-specific warning suppression only for GCC + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + target_compile_options(${EXAMPLE_NAME} PRIVATE -Xcompiler -Wno-subobject-linkage) + endif() target_link_libraries(${EXAMPLE_NAME} PRIVATE cuco CUDA::cudart) endfunction(ConfigureExample) diff --git a/examples/hyperloglog/device_ref_example.cu b/examples/hyperloglog/device_ref_example.cu index 476eed608..c149f36f1 100644 --- a/examples/hyperloglog/device_ref_example.cu +++ b/examples/hyperloglog/device_ref_example.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, NVIDIA CORPORATION. + * Copyright (c) 2024-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -34,7 +34,7 @@ template __global__ void fused_kernel(RefType ref, InputIt first, std::size_t n) { // Transform the reference type (with device scope) to a reference type with block scope - using local_ref_type = typename RefType::with_scope; + using local_ref_type = typename RefType::template with_scope; // Shared memory storage for the block-local estimator extern __shared__ cuda::std::byte local_sketch[]; diff --git a/examples/static_map/count_by_key_example.cu b/examples/static_map/count_by_key_example.cu index 93e822998..90eaee7b3 100644 --- a/examples/static_map/count_by_key_example.cu +++ b/examples/static_map/count_by_key_example.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -153,8 +153,8 @@ int main(void) auto const num_keys_check = num_unique_keys[0] == (num_keys / key_duplicates); // Iterate over all result counts and verify that they are correct - auto const counts_check = thrust::all_of( - result_counts.begin(), result_counts.end(), [] __host__ __device__(Count const count) { + auto const counts_check = + thrust::all_of(result_counts.begin(), result_counts.end(), [] __device__(Count const count) { return count == key_duplicates; }); diff --git a/include/cuco/detail/bloom_filter/arrow_filter_policy.cuh b/include/cuco/detail/bloom_filter/arrow_filter_policy.cuh index 2f17fa726..481293335 100644 --- a/include/cuco/detail/bloom_filter/arrow_filter_policy.cuh +++ b/include/cuco/detail/bloom_filter/arrow_filter_policy.cuh @@ -156,7 +156,7 @@ class arrow_filter_policy { __device__ constexpr word_type word_pattern(hash_result_type hash, std::uint32_t word_index) const { word_type const key = static_cast(hash); - std::uint32_t salt; + std::uint32_t salt{}; // Basically a switch (word_index) { case 0-7 ... } // First split: 0..3 versus 4..7. diff --git a/include/cuco/detail/hash_functions/murmurhash3.cuh b/include/cuco/detail/hash_functions/murmurhash3.cuh index 2918f4cb1..93c57a29f 100644 --- a/include/cuco/detail/hash_functions/murmurhash3.cuh +++ b/include/cuco/detail/hash_functions/murmurhash3.cuh @@ -233,6 +233,8 @@ struct MurmurHash3_32 { k1 = rotl32(k1, 15); k1 *= c2; h1 ^= k1; + [[fallthrough]]; + case 0: break; }; //---------- // finalization @@ -382,6 +384,8 @@ struct MurmurHash3_x64_128 { k1 = rotl64(k1, 31); k1 *= c2; h1 ^= k1; + [[fallthrough]]; + case 0: break; }; //---------- // finalization @@ -583,6 +587,8 @@ struct MurmurHash3_x86_128 { k1 = rotl32(k1, 15); k1 *= c2; h1 ^= k1; + [[fallthrough]]; + case 0: break; }; //---------- // finalization diff --git a/include/cuco/detail/hash_functions/xxhash.cuh b/include/cuco/detail/hash_functions/xxhash.cuh index cc5ab06f6..b32b4551e 100644 --- a/include/cuco/detail/hash_functions/xxhash.cuh +++ b/include/cuco/detail/hash_functions/xxhash.cuh @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -114,7 +114,7 @@ struct XXHash_32 { Extent size) const noexcept { std::size_t offset = 0; - std::uint32_t h32; + std::uint32_t h32{}; // data can be processed in 16-byte chunks if (size >= 16) { @@ -297,7 +297,7 @@ struct XXHash_64 { Extent size) const noexcept { std::size_t offset = 0; - std::uint64_t h64; + std::uint64_t h64{}; // data can be processed in 32-byte chunks if (size >= 32) { diff --git a/include/cuco/detail/utility/cuda.cuh b/include/cuco/detail/utility/cuda.cuh index 4ec0f7fc5..1e5b009bc 100644 --- a/include/cuco/detail/utility/cuda.cuh +++ b/include/cuco/detail/utility/cuda.cuh @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, NVIDIA CORPORATION. + * Copyright (c) 2023-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -41,14 +41,14 @@ namespace cuco { namespace detail { /// CUDA warp size -__device__ constexpr int32_t warp_size() noexcept { return 32; } +[[nodiscard]] __device__ constexpr int32_t warp_size() noexcept { return 32; } /** * @brief Returns the global thread index in a 1D scalar grid * * @return The global thread index */ -__device__ static index_type global_thread_id() noexcept +[[nodiscard]] __device__ inline index_type global_thread_id() noexcept { return index_type{threadIdx.x} + index_type{blockDim.x} * index_type{blockIdx.x}; } @@ -58,7 +58,7 @@ __device__ static index_type global_thread_id() noexcept * * @return The grid stride */ -__device__ static index_type grid_stride() noexcept +[[nodiscard]] __device__ inline index_type grid_stride() noexcept { return index_type{gridDim.x} * index_type{blockDim.x}; } diff --git a/include/cuco/detail/utility/cuda.hpp b/include/cuco/detail/utility/cuda.hpp index 49445e02f..09ba68044 100644 --- a/include/cuco/detail/utility/cuda.hpp +++ b/include/cuco/detail/utility/cuda.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2023, NVIDIA CORPORATION. + * Copyright (c) 2021-2025, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -69,7 +69,7 @@ constexpr auto max_occupancy_grid_size(int32_t block_size, CUCO_CUDA_TRY( cudaDeviceGetAttribute(&num_multiprocessors, cudaDevAttrMultiProcessorCount, device)); - int32_t max_active_blocks_per_multiprocessor; + int32_t max_active_blocks_per_multiprocessor{}; CUCO_CUDA_TRY(cudaOccupancyMaxActiveBlocksPerMultiprocessor( &max_active_blocks_per_multiprocessor, kernel, block_size, dynamic_shm_size)); diff --git a/include/cuco/utility/key_generator.cuh b/include/cuco/utility/key_generator.cuh index 26628cf13..a00b931c8 100644 --- a/include/cuco/utility/key_generator.cuh +++ b/include/cuco/utility/key_generator.cuh @@ -158,7 +158,7 @@ struct generate_gaussian_fn { * * @return A resulting random number */ - __host__ __device__ constexpr T operator()(std::size_t seed) const noexcept + __host__ __device__ T operator()(std::size_t seed) const noexcept { RNG rng; thrust::normal_distribution<> normal_dist(static_cast(num_ / 2), num_ * dist_.value); @@ -199,7 +199,7 @@ struct dropout_fn { * * @return A resulting random number */ - __host__ __device__ constexpr T operator()(std::size_t seed) const noexcept + __host__ __device__ T operator()(std::size_t seed) const noexcept { RNG rng; thrust::uniform_int_distribution non_match_dist{static_cast(num_), @@ -232,7 +232,7 @@ struct dropout_pred { * * @return A random boolean value */ - __host__ __device__ constexpr bool operator()(std::size_t seed) const noexcept + __host__ __device__ bool operator()(std::size_t seed) const noexcept { RNG rng; thrust::uniform_real_distribution rate_dist{0.0, 1.0}; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 117351f38..21828b360 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -39,7 +39,11 @@ function(ConfigureTest TEST_NAME) set_target_properties(${TEST_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/tests") target_compile_options(${TEST_NAME} PRIVATE --compiler-options=-Wall --compiler-options=-Wextra - -Wno-deprecated-gpu-targets --expt-extended-lambda -Xcompiler -Wno-subobject-linkage) + --compiler-options=-Werror -Wno-deprecated-gpu-targets --expt-extended-lambda) + # Add GCC-specific warning suppression only for GCC + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + target_compile_options(${TEST_NAME} PRIVATE -Xcompiler -Wno-subobject-linkage) + endif() catch_discover_tests(${TEST_NAME} EXTRA_ARGS --allow-running-no-tests) endfunction(ConfigureTest)