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_load.cuh

@@ -1,30 +1,6 @@
-/******************************************************************************
- * Copyright (c) 2011, Duane Merrill.  All rights reserved.
- * Copyright (c) 2011-2016, 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-2016, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
 
 //! @file
 //! block_load.cuh Operations for reading linear tiles of data into the CUDA thread block.
@@ -46,6 +22,8 @@
 #include <cub/util_ptx.cuh>
 #include <cub/util_type.cuh>
 
+#include <cuda/std/__new/device_new.h>
+
 CUB_NAMESPACE_BEGIN
 
 //! @name Blocked arrangement I/O (direct)
@@ -61,7 +39,7 @@ CUB_NAMESPACE_BEGIN
 //! @tparam T
 //!   **[inferred]** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **[inferred]** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -76,15 +54,15 @@ CUB_NAMESPACE_BEGIN
 //!
 //! @param[out] dst_items
 //!   Destination to load data into
-template <typename T, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <typename T, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void
-LoadDirectBlocked(int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+LoadDirectBlocked(int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
 {
   // Load directly in thread-blocked order
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
-    dst_items[i] = block_src_it[linear_tid * ITEMS_PER_THREAD + i];
+    dst_items[i] = block_src_it[linear_tid * ItemsPerThread + i];
   }
 }
 
@@ -98,7 +76,7 @@ LoadDirectBlocked(int linear_tid, RandomAccessIterator block_src_it, T (&dst_ite
 //! @tparam T
 //!   **[inferred]** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **[inferred]** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -116,14 +94,14 @@ LoadDirectBlocked(int linear_tid, RandomAccessIterator block_src_it, T (&dst_ite
 //!
 //! @param[in] block_items_end
 //!   First out-of-bounds index when loading from block_src_it
-template <typename T, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <typename T, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectBlocked(
-  int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+  int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
 {
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
-    const auto src_pos = linear_tid * ITEMS_PER_THREAD + i;
+    const auto src_pos = linear_tid * ItemsPerThread + i;
     if (src_pos < block_items_end)
     {
       dst_items[i] = block_src_it[src_pos];
@@ -142,7 +120,7 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectBlocked(
 //! @tparam T
 //!   **[inferred]** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **[inferred]** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -163,16 +141,16 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectBlocked(
 //!
 //! @param[in] oob_default
 //!   Default value to assign out-of-bound items
-template <typename T, typename DefaultT, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <typename T, typename DefaultT, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectBlocked(
   int linear_tid,
   RandomAccessIterator block_src_it,
-  T (&dst_items)[ITEMS_PER_THREAD],
+  T (&dst_items)[ItemsPerThread],
   int block_items_end,
   DefaultT oob_default)
 {
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
     dst_items[i] = oob_default;
   }
@@ -193,9 +171,9 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectBlocked(
 //!
 //! @param[out] dst_items
 //!   Destination to load data into
-template <CacheLoadModifier MODIFIER, typename T, int ITEMS_PER_THREAD>
+template <CacheLoadModifier MODIFIER, typename T, int ItemsPerThread>
 _CCCL_DEVICE _CCCL_FORCEINLINE void
-InternalLoadDirectBlockedVectorized(int linear_tid, const T* block_src_ptr, T (&dst_items)[ITEMS_PER_THREAD])
+InternalLoadDirectBlockedVectorized(int linear_tid, const T* block_src_ptr, T (&dst_items)[ItemsPerThread])
 {
   // Find biggest memory access word that T is a whole multiple of
   using device_word_t = typename UnitWord<T>::DeviceWord;
@@ -226,7 +204,7 @@ InternalLoadDirectBlockedVectorized(int linear_tid, const T* block_src_ptr, T (&
 
     // Copy to destination
     _CCCL_PRAGMA_UNROLL_FULL()
-    for (int i = 0; i < ITEMS_PER_THREAD; i++)
+    for (int i = 0; i < ItemsPerThread; i++)
     {
       dst_items[i] = *(reinterpret_cast<T*>(vec_items) + i);
     }
@@ -248,7 +226,7 @@ InternalLoadDirectBlockedVectorized(int linear_tid, const T* block_src_ptr, T (&
 //!
 //! The following conditions will prevent vectorization and loading will fall back to cub::BLOCK_LOAD_DIRECT:
 //!
-//! - ``ITEMS_PER_THREAD`` is odd
+//! - ``ItemsPerThread`` is odd
 //! - The data type ``T`` is not a built-in primitive or CUDA vector type
 //!   (e.g., ``short``, ``int2``, ``double``, ``float2``, etc.)
 //!
@@ -257,7 +235,7 @@ InternalLoadDirectBlockedVectorized(int linear_tid, const T* block_src_ptr, T (&
 //! @tparam T
 //!   **[inferred]** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **[inferred]** The number of consecutive items partitioned onto each thread.
 //!
 //! @param[in] linear_tid
@@ -269,9 +247,9 @@ InternalLoadDirectBlockedVectorized(int linear_tid, const T* block_src_ptr, T (&
 //!
 //! @param[out] dst_items
 //!  destination to load data into
-template <typename T, int ITEMS_PER_THREAD>
+template <typename T, int ItemsPerThread>
 _CCCL_DEVICE _CCCL_FORCEINLINE void
-LoadDirectBlockedVectorized(int linear_tid, T* block_src_ptr, T (&dst_items)[ITEMS_PER_THREAD])
+LoadDirectBlockedVectorized(int linear_tid, T* block_src_ptr, T (&dst_items)[ItemsPerThread])
 {
   InternalLoadDirectBlockedVectorized<LOAD_DEFAULT>(linear_tid, block_src_ptr, dst_items);
 }
@@ -287,13 +265,13 @@ LoadDirectBlockedVectorized(int linear_tid, T* block_src_ptr, T (&dst_items)[ITE
 //!
 //! @endrst
 //!
-//! @tparam BLOCK_THREADS
+//! @tparam BlockThreads
 //!   The thread block size in threads
 //!
 //! @tparam T
 //!   **[inferred]** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **[inferred]** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -308,27 +286,27 @@ LoadDirectBlockedVectorized(int linear_tid, T* block_src_ptr, T (&dst_items)[ITE
 //!
 //! @param[out] dst_items
 //!   Destination to load data into
-template <int BLOCK_THREADS, typename T, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <int BlockThreads, typename T, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void
-LoadDirectStriped(int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+LoadDirectStriped(int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
 {
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
-    dst_items[i] = block_src_it[linear_tid + i * BLOCK_THREADS];
+    dst_items[i] = block_src_it[linear_tid + i * BlockThreads];
   }
 }
 
 namespace detail
 {
-template <int BLOCK_THREADS, typename T, int ITEMS_PER_THREAD, typename RandomAccessIterator, typename TransformOpT>
+template <int BlockThreads, typename T, int ItemsPerThread, typename RandomAccessIterator, typename TransformOpT>
 _CCCL_DEVICE _CCCL_FORCEINLINE void load_transform_direct_striped(
-  int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], TransformOpT transform_op)
+  int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], TransformOpT transform_op)
 {
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
-    dst_items[i] = transform_op(block_src_it[linear_tid + i * BLOCK_THREADS]);
+    dst_items[i] = transform_op(block_src_it[linear_tid + i * BlockThreads]);
   }
 }
 } // namespace detail
@@ -340,13 +318,13 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void load_transform_direct_striped(
 //!
 //! @endrst
 //!
-//! @tparam BLOCK_THREADS
+//! @tparam BlockThreads
 //!   The thread block size in threads
 //!
 //! @tparam T
 //!   **inferred** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **inferred** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -364,14 +342,14 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void load_transform_direct_striped(
 //!
 //! @param[in] block_items_end
 //!   Number of valid items to load
-template <int BLOCK_THREADS, typename T, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <int BlockThreads, typename T, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectStriped(
-  int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+  int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
 {
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
-    const auto src_pos = linear_tid + i * BLOCK_THREADS;
+    const auto src_pos = linear_tid + i * BlockThreads;
     if (src_pos < block_items_end)
     {
       dst_items[i] = block_src_it[src_pos];
@@ -387,13 +365,13 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectStriped(
 //!
 //! @endrst
 //!
-//! @tparam BLOCK_THREADS
+//! @tparam BlockThreads
 //!   The thread block size in threads
 //!
 //! @tparam T
 //!   **inferred** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **inferred** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -414,21 +392,21 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectStriped(
 //!
 //! @param[in] oob_default
 //!   Default value to assign out-of-bound items
-template <int BLOCK_THREADS, typename T, typename DefaultT, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <int BlockThreads, typename T, typename DefaultT, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectStriped(
   int linear_tid,
   RandomAccessIterator block_src_it,
-  T (&dst_items)[ITEMS_PER_THREAD],
+  T (&dst_items)[ItemsPerThread],
   int block_items_end,
   DefaultT oob_default)
 {
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
     dst_items[i] = oob_default;
   }
 
-  LoadDirectStriped<BLOCK_THREADS>(linear_tid, block_src_it, dst_items, block_items_end);
+  LoadDirectStriped<BlockThreads>(linear_tid, block_src_it, dst_items, block_items_end);
 }
 
 //! @} end member group
@@ -450,7 +428,7 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectStriped(
 //! @tparam T
 //!   **inferred** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **inferred** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -465,17 +443,17 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectStriped(
 //!
 //! @param[out] dst_items
 //!   Destination to load data into
-template <typename T, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <typename T, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void
-LoadDirectWarpStriped(int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+LoadDirectWarpStriped(int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
 {
   const int tid         = linear_tid & (detail::warp_threads - 1);
   const int wid         = linear_tid >> detail::log2_warp_threads;
-  const int warp_offset = wid * detail::warp_threads * ITEMS_PER_THREAD;
+  const int warp_offset = wid * detail::warp_threads * ItemsPerThread;
 
   // Load directly in warp-striped order
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
     new (&dst_items[i]) T(block_src_it[warp_offset + tid + (i * detail::warp_threads)]);
   }
@@ -496,7 +474,7 @@ LoadDirectWarpStriped(int linear_tid, RandomAccessIterator block_src_it, T (&dst
 //! @tparam T
 //!   **inferred** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **inferred** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -514,17 +492,17 @@ LoadDirectWarpStriped(int linear_tid, RandomAccessIterator block_src_it, T (&dst
 //!
 //! @param[in] block_items_end
 //!   Number of valid items to load
-template <typename T, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <typename T, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectWarpStriped(
-  int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+  int linear_tid, RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
 {
   const int tid         = linear_tid & (detail::warp_threads - 1);
   const int wid         = linear_tid >> detail::log2_warp_threads;
-  const int warp_offset = wid * detail::warp_threads * ITEMS_PER_THREAD;
+  const int warp_offset = wid * detail::warp_threads * ItemsPerThread;
 
   // Load directly in warp-striped order
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
     const auto src_pos = warp_offset + tid + (i * detail::warp_threads);
     if (src_pos < block_items_end)
@@ -550,7 +528,7 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectWarpStriped(
 //! @tparam T
 //!   **inferred** The data type to load.
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   **inferred** The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam RandomAccessIterator
@@ -571,17 +549,17 @@ _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectWarpStriped(
 //!
 //! @param[in] oob_default
 //!   Default value to assign out-of-bound items
-template <typename T, typename DefaultT, int ITEMS_PER_THREAD, typename RandomAccessIterator>
+template <typename T, typename DefaultT, int ItemsPerThread, typename RandomAccessIterator>
 _CCCL_DEVICE _CCCL_FORCEINLINE void LoadDirectWarpStriped(
   int linear_tid,
   RandomAccessIterator block_src_it,
-  T (&dst_items)[ITEMS_PER_THREAD],
+  T (&dst_items)[ItemsPerThread],
   int block_items_end,
   DefaultT oob_default)
 {
   // Load directly in warp-striped order
   _CCCL_PRAGMA_UNROLL_FULL()
-  for (int i = 0; i < ITEMS_PER_THREAD; i++)
+  for (int i = 0; i < ItemsPerThread; i++)
   {
     dst_items[i] = oob_default;
   }
@@ -629,7 +607,7 @@ enum BlockLoadAlgorithm
   //!
   //! A :ref:`blocked arrangement <flexible-data-arrangement>` of data is read from memory using CUDA's built-in
   //! vectorized loads as a coalescing optimization. For example, ``ld.global.v4.s32`` instructions will be generated
-  //! when ``T = int`` and ``ITEMS_PER_THREAD % 4 == 0``.
+  //! when ``T = int`` and ``ItemsPerThread % 4 == 0``.
   //!
   //! Performance Considerations
   //! ++++++++++++++++++++++++++
@@ -639,7 +617,7 @@ enum BlockLoadAlgorithm
   //!   is lower).
   //! - The following conditions will prevent vectorization and loading will fall back to cub::BLOCK_LOAD_DIRECT:
   //!
-  //!   - ``ITEMS_PER_THREAD`` is odd
+  //!   - ``ItemsPerThread`` is odd
   //!   - The ``RandomAccessIterator`` is not a simple pointer type
   //!   - The block input offset is not quadword-aligned
   //!   - The data type ``T`` is not a built-in primitive or CUDA vector type
@@ -675,7 +653,7 @@ enum BlockLoadAlgorithm
   //! Usage Considerations
   //! ++++++++++++++++++++++++++
   //!
-  //! - BLOCK_THREADS must be a multiple of WARP_THREADS
+  //! - BlockThreads must be a multiple of WARP_THREADS
   //!
   //! Performance Considerations
   //! ++++++++++++++++++++++++++
@@ -701,7 +679,7 @@ enum BlockLoadAlgorithm
   //! Usage Considerations
   //! ++++++++++++++++++++++++++
   //!
-  //! - BLOCK_THREADS must be a multiple of WARP_THREADS
+  //! - BlockThreads must be a multiple of WARP_THREADS
   //!
   //! Performance Considerations
   //! ++++++++++++++++++++++++++
@@ -791,7 +769,7 @@ enum BlockLoadAlgorithm
 //! @tparam BLOCK_DIM_X
 //!   The thread block length in threads along the X dimension
 //!
-//! @tparam ITEMS_PER_THREAD
+//! @tparam ItemsPerThread
 //!   The number of consecutive items partitioned onto each thread.
 //!
 //! @tparam ALGORITHM
@@ -804,20 +782,20 @@ enum BlockLoadAlgorithm
 //!   **[optional]** The thread block length in threads along the Z dimension (default: 1)
 //!
 template <typename T,
-          int BLOCK_DIM_X,
-          int ITEMS_PER_THREAD,
-          BlockLoadAlgorithm ALGORITHM = BLOCK_LOAD_DIRECT,
-          int BLOCK_DIM_Y              = 1,
-          int BLOCK_DIM_Z              = 1>
+          int BlockDimX,
+          int ItemsPerThread,
+          BlockLoadAlgorithm Algorithm = BLOCK_LOAD_DIRECT,
+          int BlockDimY                = 1,
+          int BlockDimZ                = 1>
 class BlockLoad
 {
-  static constexpr int BLOCK_THREADS = BLOCK_DIM_X * BLOCK_DIM_Y * BLOCK_DIM_Z; // total threads in the block
+  static constexpr int BlockThreads = BlockDimX * BlockDimY * BlockDimZ; // total threads in the block
 
-  template <BlockLoadAlgorithm _POLICY, int DUMMY>
+  template <BlockLoadAlgorithm _POLICY, int Dummy>
   struct LoadInternal; // helper to dispatch the load algorithm
 
-  template <int DUMMY>
-  struct LoadInternal<BLOCK_LOAD_DIRECT, DUMMY>
+  template <int Dummy>
+  struct LoadInternal<BLOCK_LOAD_DIRECT, Dummy>
   {
     using TempStorage = NullType;
     int linear_tid;
@@ -827,28 +805,28 @@ class BlockLoad
     {}
 
     template <typename RandomAccessIterator>
-    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
     {
       LoadDirectBlocked(linear_tid, block_src_it, dst_items);
     }
 
     template <typename RandomAccessIterator>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
     {
       LoadDirectBlocked(linear_tid, block_src_it, dst_items, block_items_end);
     }
 
     template <typename RandomAccessIterator, typename DefaultT>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end, DefaultT oob_default)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end, DefaultT oob_default)
     {
       LoadDirectBlocked(linear_tid, block_src_it, dst_items, block_items_end, oob_default);
     }
   };
 
-  template <int DUMMY>
-  struct LoadInternal<BLOCK_LOAD_STRIPED, DUMMY>
+  template <int Dummy>
+  struct LoadInternal<BLOCK_LOAD_STRIPED, Dummy>
   {
     using TempStorage = NullType;
     int linear_tid;
@@ -858,28 +836,28 @@ class BlockLoad
     {}
 
     template <typename RandomAccessIterator>
-    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
     {
-      LoadDirectStriped<BLOCK_THREADS>(linear_tid, block_src_it, dst_items);
+      LoadDirectStriped<BlockThreads>(linear_tid, block_src_it, dst_items);
     }
 
     template <typename RandomAccessIterator>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
     {
-      LoadDirectStriped<BLOCK_THREADS>(linear_tid, block_src_it, dst_items, block_items_end);
+      LoadDirectStriped<BlockThreads>(linear_tid, block_src_it, dst_items, block_items_end);
     }
 
     template <typename RandomAccessIterator, typename DefaultT>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end, DefaultT oob_default)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end, DefaultT oob_default)
     {
-      LoadDirectStriped<BLOCK_THREADS>(linear_tid, block_src_it, dst_items, block_items_end, oob_default);
+      LoadDirectStriped<BlockThreads>(linear_tid, block_src_it, dst_items, block_items_end, oob_default);
     }
   };
 
-  template <int DUMMY>
-  struct LoadInternal<BLOCK_LOAD_VECTORIZE, DUMMY>
+  template <int Dummy>
+  struct LoadInternal<BLOCK_LOAD_VECTORIZE, Dummy>
   {
     using TempStorage = NullType;
     int linear_tid;
@@ -889,7 +867,7 @@ class BlockLoad
     {}
 
     // attempts vectorization (pointer)
-    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(const T* block_ptr, T (&dst_items)[ITEMS_PER_THREAD])
+    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(const T* block_ptr, T (&dst_items)[ItemsPerThread])
     {
       InternalLoadDirectBlockedVectorized<LOAD_DEFAULT>(linear_tid, block_ptr, dst_items);
     }
@@ -898,14 +876,14 @@ class BlockLoad
     // Otherwise, when the pointer type is 'T*', the compiler will prefer the overloaded version
     // Load(RandomAccessIterator...) over Load(const T*...), which means it will never perform vectorized loading for
     // pointers to non-const types.
-    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(T* block_ptr, T (&dst_items)[ITEMS_PER_THREAD])
+    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(T* block_ptr, T (&dst_items)[ItemsPerThread])
     {
       InternalLoadDirectBlockedVectorized<LOAD_DEFAULT>(linear_tid, block_ptr, dst_items);
     }
 
     // any other iterator, no vectorization
     template <typename RandomAccessIterator>
-    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
     {
       LoadDirectBlocked(linear_tid, block_src_it, dst_items);
     }
@@ -913,7 +891,7 @@ class BlockLoad
     // attempts vectorization (cache modified iterator)
     template <CacheLoadModifier MODIFIER, typename ValueType, typename OffsetT>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(CacheModifiedInputIterator<MODIFIER, ValueType, OffsetT> block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+    Load(CacheModifiedInputIterator<MODIFIER, ValueType, OffsetT> block_src_it, T (&dst_items)[ItemsPerThread])
     {
       InternalLoadDirectBlockedVectorized<MODIFIER>(linear_tid, block_src_it.ptr, dst_items);
     }
@@ -921,7 +899,7 @@ class BlockLoad
     // skips vectorization
     template <typename RandomAccessIterator>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
     {
       LoadDirectBlocked(linear_tid, block_src_it, dst_items, block_items_end);
     }
@@ -929,16 +907,16 @@ class BlockLoad
     // skips vectorization
     template <typename RandomAccessIterator, typename DefaultT>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end, DefaultT oob_default)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end, DefaultT oob_default)
     {
       LoadDirectBlocked(linear_tid, block_src_it, dst_items, block_items_end, oob_default);
     }
   };
 
-  template <int DUMMY>
-  struct LoadInternal<BLOCK_LOAD_TRANSPOSE, DUMMY>
+  template <int Dummy>
+  struct LoadInternal<BLOCK_LOAD_TRANSPOSE, Dummy>
   {
-    using BlockExchange = BlockExchange<T, BLOCK_DIM_X, ITEMS_PER_THREAD, false, BLOCK_DIM_Y, BLOCK_DIM_Z>;
+    using BlockExchange = BlockExchange<T, BlockDimX, ItemsPerThread, false, BlockDimY, BlockDimZ>;
     using _TempStorage  = typename BlockExchange::TempStorage;
     using TempStorage   = Uninitialized<_TempStorage>;
 
@@ -951,36 +929,36 @@ class BlockLoad
     {}
 
     template <typename RandomAccessIterator>
-    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
     {
-      LoadDirectStriped<BLOCK_THREADS>(linear_tid, block_src_it, dst_items);
+      LoadDirectStriped<BlockThreads>(linear_tid, block_src_it, dst_items);
       BlockExchange(temp_storage).StripedToBlocked(dst_items, dst_items);
     }
 
     template <typename RandomAccessIterator>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
     {
-      LoadDirectStriped<BLOCK_THREADS>(linear_tid, block_src_it, dst_items, block_items_end);
+      LoadDirectStriped<BlockThreads>(linear_tid, block_src_it, dst_items, block_items_end);
       BlockExchange(temp_storage).StripedToBlocked(dst_items, dst_items);
     }
 
     template <typename RandomAccessIterator, typename DefaultT>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end, DefaultT oob_default)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end, DefaultT oob_default)
     {
-      LoadDirectStriped<BLOCK_THREADS>(linear_tid, block_src_it, dst_items, block_items_end, oob_default);
+      LoadDirectStriped<BlockThreads>(linear_tid, block_src_it, dst_items, block_items_end, oob_default);
       BlockExchange(temp_storage).StripedToBlocked(dst_items, dst_items);
     }
   };
 
-  template <int DUMMY>
-  struct LoadInternal<BLOCK_LOAD_WARP_TRANSPOSE, DUMMY>
+  template <int Dummy>
+  struct LoadInternal<BLOCK_LOAD_WARP_TRANSPOSE, Dummy>
   {
     static constexpr int WARP_THREADS = detail::warp_threads;
-    static_assert(BLOCK_THREADS % WARP_THREADS == 0, "BLOCK_THREADS must be a multiple of WARP_THREADS");
+    static_assert(BlockThreads % WARP_THREADS == 0, "BlockThreads must be a multiple of WARP_THREADS");
 
-    using BlockExchange = BlockExchange<T, BLOCK_DIM_X, ITEMS_PER_THREAD, false, BLOCK_DIM_Y, BLOCK_DIM_Z>;
+    using BlockExchange = BlockExchange<T, BlockDimX, ItemsPerThread, false, BlockDimY, BlockDimZ>;
     using _TempStorage  = typename BlockExchange::TempStorage;
     using TempStorage   = Uninitialized<_TempStorage>;
 
@@ -993,7 +971,7 @@ class BlockLoad
     {}
 
     template <typename RandomAccessIterator>
-    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
     {
       LoadDirectWarpStriped(linear_tid, block_src_it, dst_items);
       BlockExchange(temp_storage).WarpStripedToBlocked(dst_items, dst_items);
@@ -1001,7 +979,7 @@ class BlockLoad
 
     template <typename RandomAccessIterator>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
     {
       LoadDirectWarpStriped(linear_tid, block_src_it, dst_items, block_items_end);
       BlockExchange(temp_storage).WarpStripedToBlocked(dst_items, dst_items);
@@ -1009,20 +987,20 @@ class BlockLoad
 
     template <typename RandomAccessIterator, typename DefaultT>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end, DefaultT oob_default)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end, DefaultT oob_default)
     {
       LoadDirectWarpStriped(linear_tid, block_src_it, dst_items, block_items_end, oob_default);
       BlockExchange(temp_storage).WarpStripedToBlocked(dst_items, dst_items);
     }
   };
 
-  template <int DUMMY>
-  struct LoadInternal<BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED, DUMMY>
+  template <int Dummy>
+  struct LoadInternal<BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED, Dummy>
   {
     static constexpr int WARP_THREADS = detail::warp_threads;
-    static_assert(BLOCK_THREADS % WARP_THREADS == 0, "BLOCK_THREADS must be a multiple of WARP_THREADS");
+    static_assert(BlockThreads % WARP_THREADS == 0, "BlockThreads must be a multiple of WARP_THREADS");
 
-    using BlockExchange = BlockExchange<T, BLOCK_DIM_X, ITEMS_PER_THREAD, true, BLOCK_DIM_Y, BLOCK_DIM_Z>;
+    using BlockExchange = BlockExchange<T, BlockDimX, ItemsPerThread, true, BlockDimY, BlockDimZ>;
     using _TempStorage  = typename BlockExchange::TempStorage;
     using TempStorage   = Uninitialized<_TempStorage>;
 
@@ -1035,7 +1013,7 @@ class BlockLoad
     {}
 
     template <typename RandomAccessIterator>
-    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+    _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
     {
       LoadDirectWarpStriped(linear_tid, block_src_it, dst_items);
       BlockExchange(temp_storage).WarpStripedToBlocked(dst_items, dst_items);
@@ -1043,7 +1021,7 @@ class BlockLoad
 
     template <typename RandomAccessIterator>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
     {
       LoadDirectWarpStriped(linear_tid, block_src_it, dst_items, block_items_end);
       BlockExchange(temp_storage).WarpStripedToBlocked(dst_items, dst_items);
@@ -1051,14 +1029,14 @@ class BlockLoad
 
     template <typename RandomAccessIterator, typename DefaultT>
     _CCCL_DEVICE _CCCL_FORCEINLINE void
-    Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end, DefaultT oob_default)
+    Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end, DefaultT oob_default)
     {
       LoadDirectWarpStriped(linear_tid, block_src_it, dst_items, block_items_end, oob_default);
       BlockExchange(temp_storage).WarpStripedToBlocked(dst_items, dst_items);
     }
   };
 
-  using InternalLoad = LoadInternal<ALGORITHM, 0>; // load implementation to use
+  using InternalLoad = LoadInternal<Algorithm, 0>; // load implementation to use
   using _TempStorage = typename InternalLoad::TempStorage;
 
   // Internal storage allocator
@@ -1081,14 +1059,14 @@ public:
   /// @brief Collective constructor using a private static allocation of shared memory as temporary storage.
   _CCCL_DEVICE _CCCL_FORCEINLINE BlockLoad()
       : temp_storage(PrivateStorage())
-      , linear_tid(RowMajorTid(BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z))
+      , linear_tid(RowMajorTid(BlockDimX, BlockDimY, BlockDimZ))
   {}
 
   /// @brief Collective constructor using the specified memory allocation as temporary storage.
   /// @param[in] temp_storage Reference to memory allocation having layout type TempStorage
   _CCCL_DEVICE _CCCL_FORCEINLINE BlockLoad(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
@@ -1137,7 +1115,7 @@ public:
   //! @param[out] dst_items
   //!   Destination to load data into
   template <typename RandomAccessIterator>
-  _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD])
+  _CCCL_DEVICE _CCCL_FORCEINLINE void Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread])
   {
     InternalLoad(temp_storage, linear_tid).Load(block_src_it, dst_items);
   }
@@ -1191,7 +1169,7 @@ public:
   //!   Number of valid items to load
   template <typename RandomAccessIterator>
   _CCCL_DEVICE _CCCL_FORCEINLINE void
-  Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end)
+  Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end)
   {
     InternalLoad(temp_storage, linear_tid).Load(block_src_it, dst_items, block_items_end);
   }
@@ -1247,7 +1225,7 @@ public:
   //!   Default value to assign out-of-bound items
   template <typename RandomAccessIterator, typename DefaultT>
   _CCCL_DEVICE _CCCL_FORCEINLINE void
-  Load(RandomAccessIterator block_src_it, T (&dst_items)[ITEMS_PER_THREAD], int block_items_end, DefaultT oob_default)
+  Load(RandomAccessIterator block_src_it, T (&dst_items)[ItemsPerThread], int block_items_end, DefaultT oob_default)
   {
     InternalLoad(temp_storage, linear_tid).Load(block_src_it, dst_items, block_items_end, oob_default);
   }