cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cub/device/dispatch/tuning/tuning_run_length_encode.cuh

@@ -1,29 +1,5 @@
-/******************************************************************************
- * Copyright (c) 2023, NVIDIA CORPORATION.  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
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
+// SPDX-FileCopyrightText: Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 #pragma once
 
@@ -111,7 +87,6 @@ constexpr length_size classify_length_size()
 
 namespace encode
 {
-
 template <class LengthT,
           class KeyT,
           primitive_length PrimitiveLength = is_primitive_length<LengthT>(),
@@ -381,7 +356,6 @@ struct policy_hub
 
 namespace non_trivial_runs
 {
-
 template <class LengthT,
           class KeyT,
           primitive_length PrimitiveLength = is_primitive_length<LengthT>(),

cuda/cccl/headers/include/cub/device/dispatch/tuning/tuning_scan.cuh

@@ -1,29 +1,5 @@
-/******************************************************************************
- * Copyright (c) 2023, NVIDIA CORPORATION.  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
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
+// SPDX-FileCopyrightText: Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 #pragma once
 
@@ -101,13 +77,13 @@ enum class accum_size
 };
 
 template <class AccumT>
-constexpr primitive_accum is_primitive_accum()
+constexpr _CCCL_HOST_DEVICE primitive_accum is_primitive_accum()
 {
   return is_primitive<AccumT>::value ? primitive_accum::yes : primitive_accum::no;
 }
 
 template <class ScanOpT>
-constexpr primitive_op is_primitive_op()
+constexpr _CCCL_HOST_DEVICE primitive_op is_primitive_op()
 {
   return basic_binary_op_t<ScanOpT>::value ? primitive_op::yes : primitive_op::no;
 }
@@ -125,13 +101,13 @@ struct is_plus<::cuda::std::plus<T>>
 };
 
 template <class ScanOpT>
-constexpr op_type classify_op()
+constexpr _CCCL_HOST_DEVICE op_type classify_op()
 {
   return is_plus<ScanOpT>::value ? op_type::plus : op_type::unknown;
 }
 
 template <class ValueT>
-constexpr value_size classify_value_size()
+constexpr _CCCL_HOST_DEVICE value_size classify_value_size()
 {
   return sizeof(ValueT) == 1 ? value_size::_1
        : sizeof(ValueT) == 2 ? value_size::_2
@@ -143,7 +119,7 @@ constexpr value_size classify_value_size()
 }
 
 template <class AccumT>
-constexpr accum_size classify_accum_size()
+constexpr _CCCL_HOST_DEVICE accum_size classify_accum_size()
 {
   return sizeof(AccumT) == 1 ? accum_size::_1
        : sizeof(AccumT) == 2 ? accum_size::_2
@@ -155,7 +131,7 @@ constexpr accum_size classify_accum_size()
 }
 
 template <class OffsetT>
-constexpr offset_size classify_offset_size()
+constexpr _CCCL_HOST_DEVICE offset_size classify_offset_size()
 {
   return sizeof(OffsetT) == 4 ? offset_size::_4 : sizeof(OffsetT) == 8 ? offset_size::_8 : offset_size::unknown;
 }
@@ -438,7 +414,7 @@ struct sm100_tuning<double, AccumT, OffsetT, op_type::plus, primitive_accum::yes
 template <typename PolicyT, typename = void, typename = void>
 struct ScanPolicyWrapper : PolicyT
 {
-  CUB_RUNTIME_FUNCTION ScanPolicyWrapper(PolicyT base)
+  _CCCL_HOST_DEVICE ScanPolicyWrapper(PolicyT base)
       : PolicyT(base)
   {}
 };
@@ -447,21 +423,21 @@ template <typename StaticPolicyT>
 struct ScanPolicyWrapper<StaticPolicyT, ::cuda::std::void_t<decltype(StaticPolicyT::ScanPolicyT::LOAD_MODIFIER)>>
     : StaticPolicyT
 {
-  CUB_RUNTIME_FUNCTION ScanPolicyWrapper(StaticPolicyT base)
+  _CCCL_HOST_DEVICE ScanPolicyWrapper(StaticPolicyT base)
       : StaticPolicyT(base)
   {}
 
-  CUB_RUNTIME_FUNCTION static constexpr auto Scan()
+  _CCCL_HOST_DEVICE static constexpr auto Scan()
   {
     return cub::detail::MakePolicyWrapper(typename StaticPolicyT::ScanPolicyT());
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr CacheLoadModifier LoadModifier()
+  _CCCL_HOST_DEVICE static constexpr CacheLoadModifier LoadModifier()
   {
     return StaticPolicyT::ScanPolicyT::LOAD_MODIFIER;
   }
 
-  CUB_RUNTIME_FUNCTION constexpr void CheckLoadModifier()
+  _CCCL_HOST_DEVICE constexpr void CheckLoadModifier()
   {
     static_assert(LoadModifier() != CacheLoadModifier::LOAD_LDG,
                   "The memory consistency model does not apply to texture "
@@ -480,7 +456,7 @@ struct ScanPolicyWrapper<StaticPolicyT, ::cuda::std::void_t<decltype(StaticPolic
 };
 
 template <typename PolicyT>
-CUB_RUNTIME_FUNCTION ScanPolicyWrapper<PolicyT> MakeScanPolicyWrapper(PolicyT policy)
+_CCCL_HOST_DEVICE ScanPolicyWrapper<PolicyT> MakeScanPolicyWrapper(PolicyT policy)
 {
   return ScanPolicyWrapper<PolicyT>{policy};
 }
@@ -521,7 +497,7 @@ struct policy_hub
 
   // Use values from tuning if a specialization exists, otherwise pick DefaultPolicy
   template <typename Tuning>
-  static auto select_agent_policy(int)
+  _CCCL_HOST_DEVICE static auto select_agent_policy(int)
     -> AgentScanPolicy<Tuning::threads,
                        Tuning::items,
                        AccumT,
@@ -532,7 +508,7 @@ struct policy_hub
                        cub::detail::MemBoundScaling<Tuning::threads, Tuning::items, AccumT>,
                        typename Tuning::delay_constructor>;
   template <typename Tuning>
-  static auto select_agent_policy(long) -> typename DefaultPolicy::ScanPolicyT;
+  _CCCL_HOST_DEVICE static auto select_agent_policy(long) -> typename DefaultPolicy::ScanPolicyT;
 
   struct Policy750 : ChainedPolicy<750, Policy750, Policy600>
   {
@@ -547,7 +523,7 @@ struct policy_hub
               ::cuda::std::enable_if_t<sizeof(AccumT) == sizeof(::cuda::std::__accumulator_t<ScanOpT, IVT, IVT>)
                                          && sizeof(IVT) == sizeof(OutputValueT),
                                        int> = 0>
-    static auto select_agent_policy750(int)
+    _CCCL_HOST_DEVICE static auto select_agent_policy750(int)
       -> AgentScanPolicy<Tuning::threads,
                          Tuning::items,
                          AccumT,
@@ -558,7 +534,7 @@ struct policy_hub
                          MemBoundScaling<Tuning::threads, Tuning::items, AccumT>,
                          typename Tuning::delay_constructor>;
     template <typename Tuning, typename IVT>
-    static auto select_agent_policy750(long) -> typename Policy600::ScanPolicyT;
+    _CCCL_HOST_DEVICE static auto select_agent_policy750(long) -> typename Policy600::ScanPolicyT;
 
     using ScanPolicyT =
       decltype(select_agent_policy750<sm75_tuning<InputValueT, AccumT, OffsetT, classify_op<ScanOpT>()>, InputValueT>(
@@ -593,7 +569,7 @@ struct policy_hub
               ::cuda::std::enable_if_t<sizeof(AccumT) == sizeof(::cuda::std::__accumulator_t<ScanOpT, IVT, IVT>)
                                          && sizeof(IVT) == sizeof(OutputValueT),
                                        int> = 0>
-    static auto select_agent_policy100(int)
+    _CCCL_HOST_DEVICE static auto select_agent_policy100(int)
       -> AgentScanPolicy<Tuning::threads,
                          Tuning::items,
                          AccumT,
@@ -604,7 +580,7 @@ struct policy_hub
                          MemBoundScaling<Tuning::threads, Tuning::items, AccumT>,
                          typename Tuning::delay_constructor>;
     template <typename Tuning, typename IVT>
-    static auto select_agent_policy100(long) -> typename Policy900::ScanPolicyT;
+    _CCCL_HOST_DEVICE static auto select_agent_policy100(long) -> typename Policy900::ScanPolicyT;
 
     using ScanPolicyT =
       decltype(select_agent_policy100<sm100_tuning<InputValueT, AccumT, OffsetT, classify_op<ScanOpT>()>, InputValueT>(

cuda/cccl/headers/include/cub/device/dispatch/tuning/tuning_scan_by_key.cuh

@@ -1,29 +1,5 @@
-/******************************************************************************
- * Copyright (c) 2023, NVIDIA CORPORATION.  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
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
+// SPDX-FileCopyrightText: Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 #pragma once
 

cuda/cccl/headers/include/cub/device/dispatch/tuning/tuning_segmented_sort.cuh

@@ -1,29 +1,5 @@
-/******************************************************************************
- * Copyright (c) 2024, NVIDIA CORPORATION. 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
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- *AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- *IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
+// SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 #pragma once
 
@@ -45,11 +21,10 @@ CUB_NAMESPACE_BEGIN
 
 namespace detail::segmented_sort
 {
-
 template <typename PolicyT, typename = void>
 struct SegmentedSortPolicyWrapper : PolicyT
 {
-  CUB_RUNTIME_FUNCTION SegmentedSortPolicyWrapper(PolicyT base)
+  _CCCL_HOST_DEVICE SegmentedSortPolicyWrapper(PolicyT base)
       : PolicyT(base)
   {}
 };
@@ -60,81 +35,81 @@ struct SegmentedSortPolicyWrapper<StaticPolicyT,
                                                      typename StaticPolicyT::SmallSegmentPolicy,
                                                      typename StaticPolicyT::MediumSegmentPolicy>> : StaticPolicyT
 {
-  CUB_RUNTIME_FUNCTION SegmentedSortPolicyWrapper(StaticPolicyT base)
+  _CCCL_HOST_DEVICE SegmentedSortPolicyWrapper(StaticPolicyT base)
       : StaticPolicyT(base)
   {}
 
-  CUB_RUNTIME_FUNCTION static constexpr auto LargeSegment()
+  _CCCL_HOST_DEVICE static constexpr auto LargeSegment()
   {
     return cub::detail::MakePolicyWrapper(typename StaticPolicyT::LargeSegmentPolicy());
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr auto SmallSegment()
+  _CCCL_HOST_DEVICE static constexpr auto SmallSegment()
   {
     return cub::detail::MakePolicyWrapper(typename StaticPolicyT::SmallSegmentPolicy());
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr auto MediumSegment()
+  _CCCL_HOST_DEVICE static constexpr auto MediumSegment()
   {
     return cub::detail::MakePolicyWrapper(typename StaticPolicyT::MediumSegmentPolicy());
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr int PartitioningThreshold()
+  _CCCL_HOST_DEVICE static constexpr int PartitioningThreshold()
   {
     return StaticPolicyT::PARTITIONING_THRESHOLD;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr int LargeSegmentRadixBits()
+  _CCCL_HOST_DEVICE static constexpr int LargeSegmentRadixBits()
   {
     return StaticPolicyT::LargeSegmentPolicy::RADIX_BITS;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr int SegmentsPerSmallBlock()
+  _CCCL_HOST_DEVICE static constexpr int SegmentsPerSmallBlock()
   {
     return StaticPolicyT::SmallSegmentPolicy::SEGMENTS_PER_BLOCK;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr int SegmentsPerMediumBlock()
+  _CCCL_HOST_DEVICE static constexpr int SegmentsPerMediumBlock()
   {
     return StaticPolicyT::MediumSegmentPolicy::SEGMENTS_PER_BLOCK;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr int SmallPolicyItemsPerTile()
+  _CCCL_HOST_DEVICE static constexpr int SmallPolicyItemsPerTile()
   {
     return StaticPolicyT::SmallSegmentPolicy::ITEMS_PER_TILE;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr int MediumPolicyItemsPerTile()
+  _CCCL_HOST_DEVICE static constexpr int MediumPolicyItemsPerTile()
   {
     return StaticPolicyT::MediumSegmentPolicy::ITEMS_PER_TILE;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr CacheLoadModifier LargeSegmentLoadModifier()
+  _CCCL_HOST_DEVICE static constexpr CacheLoadModifier LargeSegmentLoadModifier()
   {
     return StaticPolicyT::LargeSegmentPolicy::LOAD_MODIFIER;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr BlockLoadAlgorithm LargeSegmentLoadAlgorithm()
+  _CCCL_HOST_DEVICE static constexpr BlockLoadAlgorithm LargeSegmentLoadAlgorithm()
   {
     return StaticPolicyT::LargeSegmentPolicy::LOAD_ALGORITHM;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr WarpLoadAlgorithm MediumSegmentLoadAlgorithm()
+  _CCCL_HOST_DEVICE static constexpr WarpLoadAlgorithm MediumSegmentLoadAlgorithm()
   {
     return StaticPolicyT::MediumSegmentPolicy::LOAD_ALGORITHM;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr WarpLoadAlgorithm SmallSegmentLoadAlgorithm()
+  _CCCL_HOST_DEVICE static constexpr WarpLoadAlgorithm SmallSegmentLoadAlgorithm()
   {
     return StaticPolicyT::SmallSegmentPolicy::LOAD_ALGORITHM;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr WarpStoreAlgorithm MediumSegmentStoreAlgorithm()
+  _CCCL_HOST_DEVICE static constexpr WarpStoreAlgorithm MediumSegmentStoreAlgorithm()
   {
     return StaticPolicyT::MediumSegmentPolicy::STORE_ALGORITHM;
   }
 
-  CUB_RUNTIME_FUNCTION static constexpr WarpStoreAlgorithm SmallSegmentStoreAlgorithm()
+  _CCCL_HOST_DEVICE static constexpr WarpStoreAlgorithm SmallSegmentStoreAlgorithm()
   {
     return StaticPolicyT::SmallSegmentPolicy::STORE_ALGORITHM;
   }
@@ -152,7 +127,7 @@ struct SegmentedSortPolicyWrapper<StaticPolicyT,
 };
 
 template <typename PolicyT>
-CUB_RUNTIME_FUNCTION SegmentedSortPolicyWrapper<PolicyT> MakeSegmentedSortPolicyWrapper(PolicyT policy)
+_CCCL_HOST_DEVICE SegmentedSortPolicyWrapper<PolicyT> MakeSegmentedSortPolicyWrapper(PolicyT policy)
 {
   return SegmentedSortPolicyWrapper<PolicyT>{policy};
 }

cuda/cccl/headers/include/cub/device/dispatch/tuning/tuning_select_if.cuh

@@ -1,29 +1,5 @@
-/******************************************************************************
- * Copyright (c) 2023, NVIDIA CORPORATION.  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
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
+// SPDX-FileCopyrightText: Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 #pragma once
 
@@ -52,7 +28,6 @@ CUB_NAMESPACE_BEGIN
 
 namespace detail::select
 {
-
 enum class may_alias
 {
   no,

cuda/cccl/headers/include/cub/device/dispatch/tuning/tuning_three_way_partition.cuh

@@ -1,29 +1,5 @@
-/******************************************************************************
- * Copyright (c) 2023, NVIDIA CORPORATION.  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
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
+// SPDX-FileCopyrightText: Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 #pragma once
 
@@ -49,11 +25,10 @@ CUB_NAMESPACE_BEGIN
 
 namespace detail::three_way_partition
 {
-
 template <typename PolicyT, typename = void>
 struct ThreeWayPartitionPolicyWrapper : PolicyT
 {
-  CUB_RUNTIME_FUNCTION ThreeWayPartitionPolicyWrapper(PolicyT base)
+  _CCCL_HOST_DEVICE ThreeWayPartitionPolicyWrapper(PolicyT base)
       : PolicyT(base)
   {}
 };
@@ -62,7 +37,7 @@ template <typename StaticPolicyT>
 struct ThreeWayPartitionPolicyWrapper<StaticPolicyT, _CUDA_VSTD::void_t<typename StaticPolicyT::ThreeWayPartitionPolicy>>
     : StaticPolicyT
 {
-  CUB_RUNTIME_FUNCTION ThreeWayPartitionPolicyWrapper(StaticPolicyT base)
+  _CCCL_HOST_DEVICE ThreeWayPartitionPolicyWrapper(StaticPolicyT base)
       : StaticPolicyT(base)
   {}
 
@@ -80,7 +55,7 @@ struct ThreeWayPartitionPolicyWrapper<StaticPolicyT, _CUDA_VSTD::void_t<typename
 };
 
 template <typename PolicyT>
-CUB_RUNTIME_FUNCTION ThreeWayPartitionPolicyWrapper<PolicyT> MakeThreeWayPartitionPolicyWrapper(PolicyT policy)
+_CCCL_HOST_DEVICE ThreeWayPartitionPolicyWrapper<PolicyT> MakeThreeWayPartitionPolicyWrapper(PolicyT policy)
 {
   return ThreeWayPartitionPolicyWrapper<PolicyT>{policy};
 }
@@ -103,7 +78,7 @@ enum class offset_size
 };
 
 template <class InputT>
-constexpr input_size classify_input_size()
+_CCCL_HOST_DEVICE constexpr input_size classify_input_size()
 {
   return sizeof(InputT) == 1 ? input_size::_1
        : sizeof(InputT) == 2 ? input_size::_2
@@ -115,7 +90,7 @@ constexpr input_size classify_input_size()
 }
 
 template <class OffsetT>
-constexpr offset_size classify_offset_size()
+_CCCL_HOST_DEVICE constexpr offset_size classify_offset_size()
 {
   return sizeof(OffsetT) == 4 ? offset_size::_4 : sizeof(OffsetT) == 8 ? offset_size::_8 : offset_size::unknown;
 }
@@ -388,7 +363,7 @@ struct policy_hub
 
   // Use values from tuning if a specialization exists, otherwise pick DefaultPolicy
   template <typename Tuning>
-  static auto select_agent_policy(int)
+  static _CCCL_HOST_DEVICE auto select_agent_policy(int)
     -> AgentThreeWayPartitionPolicy<Tuning::threads,
                                     Tuning::items,
                                     Tuning::load_algorithm,
@@ -397,7 +372,7 @@ struct policy_hub
                                     typename Tuning::delay_constructor>;
 
   template <typename Tuning>
-  static auto select_agent_policy(long) -> typename DefaultPolicy<
+  static _CCCL_HOST_DEVICE auto select_agent_policy(long) -> typename DefaultPolicy<
     default_delay_constructor_t<typename accumulator_pack_t<OffsetT>::pack_t>>::ThreeWayPartitionPolicy;
 
   struct Policy800 : ChainedPolicy<800, Policy800, Policy500>
@@ -419,7 +394,7 @@ struct policy_hub
   {
     // Use values from tuning if a specialization exists, otherwise pick Policy900
     template <typename Tuning>
-    static auto select_agent_policy100(int)
+    static _CCCL_HOST_DEVICE auto select_agent_policy100(int)
       -> AgentThreeWayPartitionPolicy<Tuning::threads,
                                       Tuning::items,
                                       Tuning::load_algorithm,
@@ -428,7 +403,7 @@ struct policy_hub
                                       typename Tuning::delay_constructor>;
 
     template <typename Tuning>
-    static auto select_agent_policy100(long) -> typename Policy900::ThreeWayPartitionPolicy;
+    static _CCCL_HOST_DEVICE auto select_agent_policy100(long) -> typename Policy900::ThreeWayPartitionPolicy;
 
     using ThreeWayPartitionPolicy = decltype(select_agent_policy100<sm100_tuning<InputT, OffsetT>>(0));
   };

cuda/cccl/headers/include/cub/device/dispatch/tuning/tuning_topk.cuh

@@ -80,6 +80,5 @@ struct policy_hub
 
   using max_policy = Policy900;
 };
-
 } // namespace detail::topk
 CUB_NAMESPACE_END

cuda/cccl/headers/include/cub/device/dispatch/tuning/tuning_transform.cuh

@@ -1,29 +1,5 @@
-/******************************************************************************
- * Copyright (c) 2024, NVIDIA CORPORATION. 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
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- *AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- *IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
+// SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 #pragma once
 
@@ -475,7 +451,6 @@ struct policy_hub<RequiresStableAddress,
 
   using max_policy = policy1000;
 };
-
 } // namespace detail::transform
 
 CUB_NAMESPACE_END