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/block/block_radix_sort.cuh

@@ -1,30 +1,6 @@
-/******************************************************************************
- * Copyright (c) 2011, Duane Merrill.  All rights reserved.
- * Copyright (c) 2011-2018, 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) 2011, Duane Merrill. All rights reserved.
+// SPDX-FileCopyrightText: Copyright (c) 2011-2018, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 /**
  * @file
@@ -212,46 +188,46 @@ CUB_NAMESPACE_BEGIN
 //! @tparam KeyT
 //!   KeyT type
 //!
-//! @tparam BLOCK_DIM_X
+//! @tparam BlockDimX
 //!   The thread block length in threads along the X dimension
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   The number of items per thread
 //!
 //! @tparam ValueT
 //!   **[optional]** ValueT type (default: cub::NullType, which indicates a keys-only sort)
 //!
-//! @tparam RADIX_BITS
+//! @tparam RadixBits
 //!   **[optional]** The number of radix bits per digit place (default: 4 bits)
 //!
-//! @tparam MEMOIZE_OUTER_SCAN
+//! @tparam MemoizeOuterScan
 //!  **[optional]** Whether or not to buffer outer raking scan partials to incur fewer shared memory
 //!  reads at the expense of higher register pressure (default: true for architectures SM35 and
 //!  newer, false otherwise).
 //!
-//! @tparam INNER_SCAN_ALGORITHM
+//! @tparam InnerScanAlgorithm
 //!   **[optional]** The cub::BlockScanAlgorithm algorithm to use
 //!   (default: cub::BLOCK_SCAN_WARP_SCANS)
 //!
-//! @tparam SMEM_CONFIG
+//! @tparam SMemConfig
 //!   **[optional]*8 Shared memory bank mode (default: `cudaSharedMemBankSizeFourByte`)
 //!
-//! @tparam BLOCK_DIM_Y
+//! @tparam BlockDimY
 //!   **[optional]** The thread block length in threads along the Y dimension (default: 1)
 //!
-//! @tparam BLOCK_DIM_Z
+//! @tparam BlockDimZ
 //!   **[optional]** The thread block length in threads along the Z dimension (default: 1)
 //!
 template <typename KeyT,
-          int BLOCK_DIM_X,
-          int ITEMS_PER_THREAD,
-          typename ValueT                         = NullType,
-          int RADIX_BITS                          = 4,
-          bool MEMOIZE_OUTER_SCAN                 = true,
-          BlockScanAlgorithm INNER_SCAN_ALGORITHM = BLOCK_SCAN_WARP_SCANS,
-          cudaSharedMemConfig SMEM_CONFIG         = cudaSharedMemBankSizeFourByte,
-          int BLOCK_DIM_Y                         = 1,
-          int BLOCK_DIM_Z                         = 1>
+          int BlockDimX,
+          int ItemsPerThread,
+          typename ValueT                       = NullType,
+          int RadixBits                         = 4,
+          bool MemoizeOuterScan                 = true,
+          BlockScanAlgorithm InnerScanAlgorithm = BLOCK_SCAN_WARP_SCANS,
+          cudaSharedMemConfig SMemConfig        = cudaSharedMemBankSizeFourByte,
+          int BlockDimY                         = 1,
+          int BlockDimZ                         = 1>
 class BlockRadixSort
 {
 private:
@@ -262,7 +238,7 @@ private:
   enum
   {
     // The thread block size in threads
-    BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z,
+    BLOCK_THREADS = BlockDimX * BlockDimY * BlockDimZ,
 
     // Whether or not there are values to be trucked along with keys
     KEYS_ONLY = ::cuda::std::is_same_v<ValueT, NullType>,
@@ -275,34 +251,20 @@ private:
 
   /// Ascending BlockRadixRank utility type
   using AscendingBlockRadixRank =
-    BlockRadixRank<BLOCK_DIM_X,
-                   RADIX_BITS,
-                   false,
-                   MEMOIZE_OUTER_SCAN,
-                   INNER_SCAN_ALGORITHM,
-                   SMEM_CONFIG,
-                   BLOCK_DIM_Y,
-                   BLOCK_DIM_Z>;
+    BlockRadixRank<BlockDimX, RadixBits, false, MemoizeOuterScan, InnerScanAlgorithm, SMemConfig, BlockDimY, BlockDimZ>;
 
   /// Descending BlockRadixRank utility type
   using DescendingBlockRadixRank =
-    BlockRadixRank<BLOCK_DIM_X,
-                   RADIX_BITS,
-                   true,
-                   MEMOIZE_OUTER_SCAN,
-                   INNER_SCAN_ALGORITHM,
-                   SMEM_CONFIG,
-                   BLOCK_DIM_Y,
-                   BLOCK_DIM_Z>;
+    BlockRadixRank<BlockDimX, RadixBits, true, MemoizeOuterScan, InnerScanAlgorithm, SMemConfig, BlockDimY, BlockDimZ>;
 
   /// Digit extractor type
   using fundamental_digit_extractor_t = BFEDigitExtractor<KeyT>;
 
   /// BlockExchange utility type for keys
-  using BlockExchangeKeys = BlockExchange<KeyT, BLOCK_DIM_X, ITEMS_PER_THREAD, false, BLOCK_DIM_Y, BLOCK_DIM_Z>;
+  using BlockExchangeKeys = BlockExchange<KeyT, BlockDimX, ItemsPerThread, false, BlockDimY, BlockDimZ>;
 
   /// BlockExchange utility type for values
-  using BlockExchangeValues = BlockExchange<ValueT, BLOCK_DIM_X, ITEMS_PER_THREAD, false, BLOCK_DIM_Y, BLOCK_DIM_Z>;
+  using BlockExchangeValues = BlockExchange<ValueT, BlockDimX, ItemsPerThread, false, BlockDimY, BlockDimZ>;
 
 #ifndef _CCCL_DOXYGEN_INVOKED // Do not document
   /// Shared memory storage layout type
@@ -339,8 +301,8 @@ private:
   /// Rank keys (specialized for ascending sort)
   template <class DigitExtractorT>
   _CCCL_DEVICE _CCCL_FORCEINLINE void
-  RankKeys(bit_ordered_type (&unsigned_keys)[ITEMS_PER_THREAD],
-           int (&ranks)[ITEMS_PER_THREAD],
+  RankKeys(bit_ordered_type (&unsigned_keys)[ItemsPerThread],
+           int (&ranks)[ItemsPerThread],
            DigitExtractorT digit_extractor,
            ::cuda::std::false_type /*is_descending*/)
   {
@@ -350,8 +312,8 @@ private:
   /// Rank keys (specialized for descending sort)
   template <class DigitExtractorT>
   _CCCL_DEVICE _CCCL_FORCEINLINE void
-  RankKeys(bit_ordered_type (&unsigned_keys)[ITEMS_PER_THREAD],
-           int (&ranks)[ITEMS_PER_THREAD],
+  RankKeys(bit_ordered_type (&unsigned_keys)[ItemsPerThread],
+           int (&ranks)[ItemsPerThread],
            DigitExtractorT digit_extractor,
            ::cuda::std::true_type /*is_descending*/)
   {
@@ -360,8 +322,8 @@ private:
 
   /// ExchangeValues (specialized for key-value sort, to-blocked arrangement)
   _CCCL_DEVICE _CCCL_FORCEINLINE void ExchangeValues(
-    ValueT (&values)[ITEMS_PER_THREAD],
-    int (&ranks)[ITEMS_PER_THREAD],
+    ValueT (&values)[ItemsPerThread],
+    int (&ranks)[ItemsPerThread],
     ::cuda::std::false_type /*is_keys_only*/,
     ::cuda::std::true_type /*is_blocked*/)
   {
@@ -373,8 +335,8 @@ private:
 
   /// ExchangeValues (specialized for key-value sort, to-striped arrangement)
   _CCCL_DEVICE _CCCL_FORCEINLINE void ExchangeValues(
-    ValueT (&values)[ITEMS_PER_THREAD],
-    int (&ranks)[ITEMS_PER_THREAD],
+    ValueT (&values)[ItemsPerThread],
+    int (&ranks)[ItemsPerThread],
     ::cuda::std::false_type /*is_keys_only*/,
     ::cuda::std::false_type /*is_blocked*/)
   {
@@ -387,8 +349,8 @@ private:
   /// ExchangeValues (specialized for keys-only sort)
   template <bool IS_BLOCKED>
   _CCCL_DEVICE _CCCL_FORCEINLINE void ExchangeValues(
-    ValueT (& /*values*/)[ITEMS_PER_THREAD],
-    int (& /*ranks*/)[ITEMS_PER_THREAD],
+    ValueT (& /*values*/)[ItemsPerThread],
+    int (& /*ranks*/)[ItemsPerThread],
     ::cuda::std::true_type /*is_keys_only*/,
     ::cuda::std::bool_constant<IS_BLOCKED> /*is_blocked*/)
   {}
@@ -416,18 +378,18 @@ private:
    */
   template <bool DESCENDING, bool KEYS_ONLY, class DecomposerT = detail::identity_decomposer_t>
   _CCCL_DEVICE _CCCL_FORCEINLINE void SortBlocked(
-    KeyT (&keys)[ITEMS_PER_THREAD],
-    ValueT (&values)[ITEMS_PER_THREAD],
+    KeyT (&keys)[ItemsPerThread],
+    ValueT (&values)[ItemsPerThread],
     int begin_bit,
     int end_bit,
     ::cuda::std::bool_constant<DESCENDING> is_descending,
     ::cuda::std::bool_constant<KEYS_ONLY> is_keys_only,
     DecomposerT decomposer = {})
   {
-    bit_ordered_type(&unsigned_keys)[ITEMS_PER_THREAD] = reinterpret_cast<bit_ordered_type(&)[ITEMS_PER_THREAD]>(keys);
+    bit_ordered_type(&unsigned_keys)[ItemsPerThread] = reinterpret_cast<bit_ordered_type(&)[ItemsPerThread]>(keys);
 
     _CCCL_PRAGMA_UNROLL_FULL()
-    for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++)
+    for (int KEY = 0; KEY < ItemsPerThread; KEY++)
     {
       unsigned_keys[KEY] = bit_ordered_conversion::to_bit_ordered(decomposer, unsigned_keys[KEY]);
     }
@@ -435,14 +397,14 @@ private:
     // Radix sorting passes
     while (true)
     {
-      int pass_bits = ::cuda::std::min(RADIX_BITS, end_bit - begin_bit);
+      int pass_bits = ::cuda::std::min(RadixBits, end_bit - begin_bit);
       auto digit_extractor =
         traits::template digit_extractor<fundamental_digit_extractor_t>(begin_bit, pass_bits, decomposer);
 
       // Rank the blocked keys
-      int ranks[ITEMS_PER_THREAD];
+      int ranks[ItemsPerThread];
       RankKeys(unsigned_keys, ranks, digit_extractor, is_descending);
-      begin_bit += RADIX_BITS;
+      begin_bit += RadixBits;
 
       __syncthreads();
 
@@ -463,7 +425,7 @@ private:
 
     // Untwiddle bits if necessary
     _CCCL_PRAGMA_UNROLL_FULL()
-    for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++)
+    for (int KEY = 0; KEY < ItemsPerThread; KEY++)
     {
       unsigned_keys[KEY] = bit_ordered_conversion::from_bit_ordered(decomposer, unsigned_keys[KEY]);
     }
@@ -495,18 +457,18 @@ public:
    */
   template <bool DESCENDING, bool KEYS_ONLY, class DecomposerT = detail::identity_decomposer_t>
   _CCCL_DEVICE _CCCL_FORCEINLINE void SortBlockedToStriped(
-    KeyT (&keys)[ITEMS_PER_THREAD],
-    ValueT (&values)[ITEMS_PER_THREAD],
+    KeyT (&keys)[ItemsPerThread],
+    ValueT (&values)[ItemsPerThread],
     int begin_bit,
     int end_bit,
     ::cuda::std::bool_constant<DESCENDING> is_descending,
     ::cuda::std::bool_constant<KEYS_ONLY> is_keys_only,
     DecomposerT decomposer = {})
   {
-    bit_ordered_type(&unsigned_keys)[ITEMS_PER_THREAD] = reinterpret_cast<bit_ordered_type(&)[ITEMS_PER_THREAD]>(keys);
+    bit_ordered_type(&unsigned_keys)[ItemsPerThread] = reinterpret_cast<bit_ordered_type(&)[ItemsPerThread]>(keys);
 
     _CCCL_PRAGMA_UNROLL_FULL()
-    for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++)
+    for (int KEY = 0; KEY < ItemsPerThread; KEY++)
     {
       unsigned_keys[KEY] = bit_ordered_conversion::to_bit_ordered(decomposer, unsigned_keys[KEY]);
     }
@@ -514,14 +476,14 @@ public:
     // Radix sorting passes
     while (true)
     {
-      int pass_bits = ::cuda::std::min(RADIX_BITS, end_bit - begin_bit);
+      int pass_bits = ::cuda::std::min(RadixBits, end_bit - begin_bit);
       auto digit_extractor =
         traits::template digit_extractor<fundamental_digit_extractor_t>(begin_bit, pass_bits, decomposer);
 
       // Rank the blocked keys
-      int ranks[ITEMS_PER_THREAD];
+      int ranks[ItemsPerThread];
       RankKeys(unsigned_keys, ranks, digit_extractor, is_descending);
-      begin_bit += RADIX_BITS;
+      begin_bit += RadixBits;
 
       __syncthreads();
 
@@ -549,7 +511,7 @@ public:
 
     // Untwiddle bits if necessary
     _CCCL_PRAGMA_UNROLL_FULL()
-    for (int KEY = 0; KEY < ITEMS_PER_THREAD; KEY++)
+    for (int KEY = 0; KEY < ItemsPerThread; KEY++)
     {
       unsigned_keys[KEY] = bit_ordered_conversion::from_bit_ordered(decomposer, unsigned_keys[KEY]);
     }
@@ -567,7 +529,7 @@ public:
   //! @brief Collective constructor using a private static allocation of shared memory as temporary storage.
   _CCCL_DEVICE _CCCL_FORCEINLINE BlockRadixSort()
       : temp_storage(PrivateStorage())
-      , linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z))
+      , linear_tid(RowMajorTid(BlockDimX, BlockDimY, BlockDimZ))
   {}
 
   /**
@@ -578,7 +540,7 @@ public:
    */
   _CCCL_DEVICE _CCCL_FORCEINLINE BlockRadixSort(TempStorage& temp_storage)
       : temp_storage(temp_storage.Alias())
-      , linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z))
+      , linear_tid(RowMajorTid(BlockDimX, BlockDimY, BlockDimZ))
   {}
 
   //! @} end member group
@@ -633,9 +595,9 @@ public:
   //! @param[in] end_bit
   //!   **[optional]** The past-the-end (most-significant) bit index needed for key comparison
   _CCCL_DEVICE _CCCL_FORCEINLINE void
-  Sort(KeyT (&keys)[ITEMS_PER_THREAD], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
+  Sort(KeyT (&keys)[ItemsPerThread], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlocked(keys, values, begin_bit, end_bit, ::cuda::std::false_type(), detail::bool_constant_v<KEYS_ONLY>);
   }
@@ -700,9 +662,9 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  Sort(KeyT (&keys)[ITEMS_PER_THREAD], DecomposerT decomposer, int begin_bit, int end_bit)
+  Sort(KeyT (&keys)[ItemsPerThread], DecomposerT decomposer, int begin_bit, int end_bit)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlocked(
       keys, values, begin_bit, end_bit, ::cuda::std::false_type(), detail::bool_constant_v<KEYS_ONLY>, decomposer);
@@ -760,7 +722,7 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  Sort(KeyT (&keys)[ITEMS_PER_THREAD], DecomposerT decomposer)
+  Sort(KeyT (&keys)[ItemsPerThread], DecomposerT decomposer)
   {
     Sort(keys, decomposer, 0, detail::radix::traits_t<KeyT>::default_end_bit(decomposer));
   }
@@ -824,11 +786,8 @@ public:
   //!
   //! @param[in] end_bit
   //!   **[optional]** The past-the-end (most-significant) bit index needed for key comparison
-  _CCCL_DEVICE _CCCL_FORCEINLINE void
-  Sort(KeyT (&keys)[ITEMS_PER_THREAD],
-       ValueT (&values)[ITEMS_PER_THREAD],
-       int begin_bit = 0,
-       int end_bit   = sizeof(KeyT) * 8)
+  _CCCL_DEVICE _CCCL_FORCEINLINE void Sort(
+    KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
   {
     SortBlocked(keys, values, begin_bit, end_bit, ::cuda::std::false_type(), detail::bool_constant_v<KEYS_ONLY>);
   }
@@ -901,11 +860,8 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  Sort(KeyT (&keys)[ITEMS_PER_THREAD],
-       ValueT (&values)[ITEMS_PER_THREAD],
-       DecomposerT decomposer,
-       int begin_bit,
-       int end_bit)
+  Sort(
+    KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], DecomposerT decomposer, int begin_bit, int end_bit)
   {
     SortBlocked(
       keys, values, begin_bit, end_bit, ::cuda::std::false_type(), detail::bool_constant_v<KEYS_ONLY>, decomposer);
@@ -971,7 +927,7 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  Sort(KeyT (&keys)[ITEMS_PER_THREAD], ValueT (&values)[ITEMS_PER_THREAD], DecomposerT decomposer)
+  Sort(KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], DecomposerT decomposer)
   {
     Sort(keys, values, decomposer, 0, detail::radix::traits_t<KeyT>::default_end_bit(decomposer));
   }
@@ -1025,9 +981,9 @@ public:
   //! @param[in] end_bit
   //!   **[optional]** The past-the-end (most-significant) bit index needed for key comparison
   _CCCL_DEVICE _CCCL_FORCEINLINE void
-  SortDescending(KeyT (&keys)[ITEMS_PER_THREAD], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
+  SortDescending(KeyT (&keys)[ItemsPerThread], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlocked(keys, values, begin_bit, end_bit, ::cuda::std::true_type(), detail::bool_constant_v<KEYS_ONLY>);
   }
@@ -1092,9 +1048,9 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortDescending(KeyT (&keys)[ITEMS_PER_THREAD], DecomposerT decomposer, int begin_bit, int end_bit)
+  SortDescending(KeyT (&keys)[ItemsPerThread], DecomposerT decomposer, int begin_bit, int end_bit)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlocked(
       keys, values, begin_bit, end_bit, ::cuda::std::true_type(), detail::bool_constant_v<KEYS_ONLY>, decomposer);
@@ -1152,9 +1108,9 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortDescending(KeyT (&keys)[ITEMS_PER_THREAD], DecomposerT decomposer)
+  SortDescending(KeyT (&keys)[ItemsPerThread], DecomposerT decomposer)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlocked(
       keys,
@@ -1224,10 +1180,7 @@ public:
   //! @param[in] end_bit
   //!   **[optional]** The past-the-end (most-significant) bit index needed for key comparison
   _CCCL_DEVICE _CCCL_FORCEINLINE void SortDescending(
-    KeyT (&keys)[ITEMS_PER_THREAD],
-    ValueT (&values)[ITEMS_PER_THREAD],
-    int begin_bit = 0,
-    int end_bit   = sizeof(KeyT) * 8)
+    KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
   {
     SortBlocked(keys, values, begin_bit, end_bit, ::cuda::std::true_type(), detail::bool_constant_v<KEYS_ONLY>);
   }
@@ -1300,11 +1253,8 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortDescending(KeyT (&keys)[ITEMS_PER_THREAD],
-                 ValueT (&values)[ITEMS_PER_THREAD],
-                 DecomposerT decomposer,
-                 int begin_bit,
-                 int end_bit)
+  SortDescending(
+    KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], DecomposerT decomposer, int begin_bit, int end_bit)
   {
     SortBlocked(
       keys, values, begin_bit, end_bit, ::cuda::std::true_type(), detail::bool_constant_v<KEYS_ONLY>, decomposer);
@@ -1370,7 +1320,7 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortDescending(KeyT (&keys)[ITEMS_PER_THREAD], ValueT (&values)[ITEMS_PER_THREAD], DecomposerT decomposer)
+  SortDescending(KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], DecomposerT decomposer)
   {
     SortBlocked(
       keys,
@@ -1435,9 +1385,9 @@ public:
   //! @param[in] end_bit
   //!   **[optional]** The past-the-end (most-significant) bit index needed for key comparison
   _CCCL_DEVICE _CCCL_FORCEINLINE void
-  SortBlockedToStriped(KeyT (&keys)[ITEMS_PER_THREAD], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
+  SortBlockedToStriped(KeyT (&keys)[ItemsPerThread], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlockedToStriped(
       keys, values, begin_bit, end_bit, ::cuda::std::false_type(), detail::bool_constant_v<KEYS_ONLY>);
@@ -1504,9 +1454,9 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortBlockedToStriped(KeyT (&keys)[ITEMS_PER_THREAD], DecomposerT decomposer, int begin_bit, int end_bit)
+  SortBlockedToStriped(KeyT (&keys)[ItemsPerThread], DecomposerT decomposer, int begin_bit, int end_bit)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlockedToStriped(
       keys, values, begin_bit, end_bit, ::cuda::std::false_type(), detail::bool_constant_v<KEYS_ONLY>, decomposer);
@@ -1565,9 +1515,9 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortBlockedToStriped(KeyT (&keys)[ITEMS_PER_THREAD], DecomposerT decomposer)
+  SortBlockedToStriped(KeyT (&keys)[ItemsPerThread], DecomposerT decomposer)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlockedToStriped(
       keys,
@@ -1637,10 +1587,7 @@ public:
   //! @param[in] end_bit
   //!   **[optional]** The past-the-end (most-significant) bit index needed for key comparison
   _CCCL_DEVICE _CCCL_FORCEINLINE void SortBlockedToStriped(
-    KeyT (&keys)[ITEMS_PER_THREAD],
-    ValueT (&values)[ITEMS_PER_THREAD],
-    int begin_bit = 0,
-    int end_bit   = sizeof(KeyT) * 8)
+    KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
   {
     SortBlockedToStriped(
       keys, values, begin_bit, end_bit, ::cuda::std::false_type(), detail::bool_constant_v<KEYS_ONLY>);
@@ -1710,11 +1657,8 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortBlockedToStriped(KeyT (&keys)[ITEMS_PER_THREAD],
-                       ValueT (&values)[ITEMS_PER_THREAD],
-                       DecomposerT decomposer,
-                       int begin_bit,
-                       int end_bit)
+  SortBlockedToStriped(
+    KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], DecomposerT decomposer, int begin_bit, int end_bit)
   {
     SortBlockedToStriped(
       keys, values, begin_bit, end_bit, ::cuda::std::false_type(), detail::bool_constant_v<KEYS_ONLY>, decomposer);
@@ -1776,7 +1720,7 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortBlockedToStriped(KeyT (&keys)[ITEMS_PER_THREAD], ValueT (&values)[ITEMS_PER_THREAD], DecomposerT decomposer)
+  SortBlockedToStriped(KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], DecomposerT decomposer)
   {
     SortBlockedToStriped(
       keys,
@@ -1837,9 +1781,9 @@ public:
   //! @param[in] end_bit
   //!   **[optional]** The past-the-end (most-significant) bit index needed for key comparison
   _CCCL_DEVICE _CCCL_FORCEINLINE void
-  SortDescendingBlockedToStriped(KeyT (&keys)[ITEMS_PER_THREAD], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
+  SortDescendingBlockedToStriped(KeyT (&keys)[ItemsPerThread], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlockedToStriped(keys, values, begin_bit, end_bit, ::cuda::std::true_type(), detail::bool_constant_v<KEYS_ONLY>);
   }
@@ -1905,9 +1849,9 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortDescendingBlockedToStriped(KeyT (&keys)[ITEMS_PER_THREAD], DecomposerT decomposer, int begin_bit, int end_bit)
+  SortDescendingBlockedToStriped(KeyT (&keys)[ItemsPerThread], DecomposerT decomposer, int begin_bit, int end_bit)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlockedToStriped(
       keys, values, begin_bit, end_bit, ::cuda::std::true_type(), detail::bool_constant_v<KEYS_ONLY>, decomposer);
@@ -1966,9 +1910,9 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortDescendingBlockedToStriped(KeyT (&keys)[ITEMS_PER_THREAD], DecomposerT decomposer)
+  SortDescendingBlockedToStriped(KeyT (&keys)[ItemsPerThread], DecomposerT decomposer)
   {
-    NullType values[ITEMS_PER_THREAD];
+    NullType values[ItemsPerThread];
 
     SortBlockedToStriped(
       keys,
@@ -2038,10 +1982,7 @@ public:
   //! @param[in] end_bit
   //!   **[optional]** The past-the-end (most-significant) bit index needed for key comparison
   _CCCL_DEVICE _CCCL_FORCEINLINE void SortDescendingBlockedToStriped(
-    KeyT (&keys)[ITEMS_PER_THREAD],
-    ValueT (&values)[ITEMS_PER_THREAD],
-    int begin_bit = 0,
-    int end_bit   = sizeof(KeyT) * 8)
+    KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], int begin_bit = 0, int end_bit = sizeof(KeyT) * 8)
   {
     SortBlockedToStriped(keys, values, begin_bit, end_bit, ::cuda::std::true_type(), detail::bool_constant_v<KEYS_ONLY>);
   }
@@ -2111,11 +2052,7 @@ public:
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
   SortDescendingBlockedToStriped(
-    KeyT (&keys)[ITEMS_PER_THREAD],
-    ValueT (&values)[ITEMS_PER_THREAD],
-    DecomposerT decomposer,
-    int begin_bit,
-    int end_bit)
+    KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], DecomposerT decomposer, int begin_bit, int end_bit)
   {
     SortBlockedToStriped(
       keys, values, begin_bit, end_bit, ::cuda::std::true_type(), detail::bool_constant_v<KEYS_ONLY>, decomposer);
@@ -2177,8 +2114,7 @@ public:
   _CCCL_DEVICE _CCCL_FORCEINLINE //
   ::cuda::std::enable_if_t< //
     !::cuda::std::is_convertible_v<DecomposerT, int>>
-  SortDescendingBlockedToStriped(
-    KeyT (&keys)[ITEMS_PER_THREAD], ValueT (&values)[ITEMS_PER_THREAD], DecomposerT decomposer)
+  SortDescendingBlockedToStriped(KeyT (&keys)[ItemsPerThread], ValueT (&values)[ItemsPerThread], DecomposerT decomposer)
   {
     SortBlockedToStriped(
       keys,

cuda/cccl/headers/include/cub/block/block_raking_layout.cuh

@@ -1,30 +1,6 @@
-/******************************************************************************
- * Copyright (c) 2011, Duane Merrill.  All rights reserved.
- * Copyright (c) 2011-2018, 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) 2011, Duane Merrill. All rights reserved.
+// SPDX-FileCopyrightText: Copyright (c) 2011-2018, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 /**
  * @file
@@ -65,10 +41,10 @@ CUB_NAMESPACE_BEGIN
 //! @tparam T
 //!   The data type to be exchanged.
 //!
-//! @tparam BLOCK_THREADS
+//! @tparam BlockThreads
 //!   The thread block size in threads.
 //!
-template <typename T, int BLOCK_THREADS>
+template <typename T, int BlockThreads>
 struct BlockRakingLayout
 {
   //---------------------------------------------------------------------
@@ -78,15 +54,15 @@ struct BlockRakingLayout
   enum
   {
     /// The total number of elements that need to be cooperatively reduced
-    SHARED_ELEMENTS = BLOCK_THREADS,
+    SHARED_ELEMENTS = BlockThreads,
 
     /// Maximum number of warp-synchronous raking threads
-    MAX_RAKING_THREADS = ::cuda::std::min(BLOCK_THREADS, detail::warp_threads),
+    MAX_RAKING_THREADS = ::cuda::std::min(BlockThreads, detail::warp_threads),
 
     /// Number of raking elements per warp-synchronous raking thread (rounded up)
     SEGMENT_LENGTH = (SHARED_ELEMENTS + MAX_RAKING_THREADS - 1) / MAX_RAKING_THREADS,
 
-    /// Never use a raking thread that will have no valid data (e.g., when BLOCK_THREADS is 62 and SEGMENT_LENGTH is 2,
+    /// Never use a raking thread that will have no valid data (e.g., when BlockThreads is 62 and SEGMENT_LENGTH is 2,
     /// we should only use 31 raking threads)
     RAKING_THREADS = (SHARED_ELEMENTS + SEGMENT_LENGTH - 1) / SEGMENT_LENGTH,