* The cub::WarpScan class provides [<em>collective</em>](index.html#sec0) methods for computing a parallel prefix scan of items partitioned across CUDA warp threads.
*/
#pragma once
#include "specializations/warp_scan_shfl.cuh"
#include "specializations/warp_scan_smem.cuh"
#include "../thread/thread_operators.cuh"
#include "../util_arch.cuh"
#include "../util_type.cuh"
#include "../util_namespace.cuh"
/// Optional outer namespace(s)
CUB_NS_PREFIX
/// CUB namespace
namespace cub {
/**
* \addtogroup WarpModule
* @{
*/
/**
* \brief The WarpScan class provides [<em>collective</em>](index.html#sec0) methods for computing a parallel prefix scan of items partitioned across CUDA warp threads. 
*
* \par Overview
* Given a list of input elements and a binary reduction operator, a [<em>prefix scan</em>](http://en.wikipedia.org/wiki/Prefix_sum)
* produces an output list where each element is computed to be the reduction
* of the elements occurring earlier in the input list. <em>Prefix sum</em>
* connotes a prefix scan with the addition operator. The term \em inclusive indicates
* that the <em>i</em><sup>th</sup> output reduction incorporates the <em>i</em><sup>th</sup> input.
* The term \em exclusive indicates the <em>i</em><sup>th</sup> input is not incorporated into
* the <em>i</em><sup>th</sup> output reduction.
*
* \tparam T The scan input/output element type
* \tparam LOGICAL_WARPS <b>[optional]</b> The number of "logical" warps performing concurrent warp scans. Default is 1.
* \tparam LOGICAL_WARP_THREADS <b>[optional]</b> The number of threads per "logical" warp (may be less than the number of hardware warp threads). Default is the warp size associated with the CUDA Compute Capability targeted by the compiler (e.g., 32 threads for SM20).
*
* \par Simple Examples
* \warpcollective{WarpScan}
* \par
* The code snippet below illustrates four concurrent warp prefix sums within a block of
* 128 threads (one per each of the 32-thread warps).
/// Internal specialization. Use SHFL-based reduction if (architecture is >= SM30) and ((only one logical warp) or (LOGICAL_WARP_THREADS is a power-of-two))
* \brief Collective constructor for 1D thread blocks using a private static allocation of shared memory as temporary storage. Logical warp and lane identifiers are constructed from <tt>threadIdx.x</tt>.
* \brief Collective constructor for 1D thread blocks using the specified memory allocation as temporary storage. Logical warp and lane identifiers are constructed from <tt>threadIdx.x</tt>.
*/
__device__ __forceinline__ WarpScan(
TempStorage &temp_storage) ///< [in] Reference to memory allocation having layout type TempStorage
* \brief Collective constructor using a private static allocation of shared memory as temporary storage. Threads are identified using the given warp and lane identifiers.
*/
__device__ __forceinline__ WarpScan(
int warp_id, ///< [in] A suitable warp membership identifier
int lane_id) ///< [in] A lane identifier within the warp
:
temp_storage(PrivateStorage()),
warp_id(warp_id),
lane_id(lane_id)
{}
/**
* \brief Collective constructor using the specified memory allocation as temporary storage. Threads are identified using the given warp and lane identifiers.
*/
__device__ __forceinline__ WarpScan(
TempStorage &temp_storage, ///< [in] Reference to memory allocation having layout type TempStorage
int warp_id, ///< [in] A suitable warp membership identifier
int lane_id) ///< [in] A lane identifier within the warp
* \brief Computes an inclusive prefix sum in each logical warp. Instead of using 0 as the warp-wide prefix, the call-back functor \p warp_prefix_op is invoked to provide the "seed" value that logically prefixes the warp's scan inputs. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
*
* The \p warp_aggregate is undefined in threads other than <em>warp-lane</em><sub>0</sub>.
*
* The \p warp_prefix_op functor must implement a member function <tt>T operator()(T warp_aggregate)</tt>.
* The functor's input parameter \p warp_aggregate is the same value also returned by the scan operation.
* The functor will be invoked by the entire warp of threads, however only the return value from
* <em>lane</em><sub>0</sub> is applied as the threadblock-wide prefix. Can be stateful.
*
* \smemreuse
*
* The code snippet below illustrates a single thread block of 32 threads (one warp) that progressively
* computes an inclusive prefix sum over multiple "tiles" of input using a
* prefix functor to maintain a running total between block-wide scans. Each tile consists
* of 32 integer items that are partitioned across the warp.
* \par
* \code
* #include <cub/cub.cuh>
*
* // A stateful callback functor that maintains a running prefix to be applied
* Suppose the input \p d_data is <tt>1, 1, 1, 1, 1, 1, 1, 1, ...</tt>.
* The corresponding output for the first segment will be <tt>1, 2, 3, ..., 32</tt>.
* The output for the second segment will be <tt>33, 34, 35, ..., 64</tt>. Furthermore,
* the value \p 32 will be stored in \p warp_aggregate for all threads after each scan.
*
* \tparam WarpPrefixOp <b>[inferred]</b> Call-back functor type having member <tt>T operator()(T warp_aggregate)</tt>
*/
template <typename WarpPrefixOp>
__device__ __forceinline__ void InclusiveSum(
T input, ///< [in] Calling thread's input item.
T &output, ///< [out] Calling thread's output item. May be aliased with \p input.
T &warp_aggregate, ///< [out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Warp-wide aggregate reduction of input items, exclusive of the \p warp_prefix_op value
WarpPrefixOp &warp_prefix_op) ///< [in-out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Call-back functor for specifying a warp-wide prefix to be applied to all inputs.
{
// Compute inclusive warp scan
InclusiveSum(input, output, warp_aggregate);
// Compute warp-wide prefix from aggregate, then broadcast to other lanes
/// Computes an exclusive prefix sum in each logical warp.
__device__ __forceinline__ void ExclusiveSum(T input, T &output, Int2Type<true> is_primitive)
{
// Compute exclusive warp scan from inclusive warp scan
T inclusive;
InclusiveSum(input, inclusive);
output = inclusive - input;
}
/// Computes an exclusive prefix sum in each logical warp. Specialized for non-primitive types.
__device__ __forceinline__ void ExclusiveSum(T input, T &output, Int2Type<false> is_primitive)
{
// Delegate to regular scan for non-primitive types (because we won't be able to use subtraction)
T identity = T();
ExclusiveScan(input, output, identity, Sum());
}
/// Computes an exclusive prefix sum in each logical warp. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
__device__ __forceinline__ void ExclusiveSum(T input, T &output, T &warp_aggregate, Int2Type<true> is_primitive)
{
// Compute exclusive warp scan from inclusive warp scan
T inclusive;
InclusiveSum(input, inclusive, warp_aggregate);
output = inclusive - input;
}
/// Computes an exclusive prefix sum in each logical warp. Also provides every thread with the warp-wide \p warp_aggregate of all inputs. Specialized for non-primitive types.
__device__ __forceinline__ void ExclusiveSum(T input, T &output, T &warp_aggregate, Int2Type<false> is_primitive)
{
// Delegate to regular scan for non-primitive types (because we won't be able to use subtraction)
/// Computes an exclusive prefix sum in each logical warp. Instead of using 0 as the warp-wide prefix, the call-back functor \p warp_prefix_op is invoked to provide the "seed" value that logically prefixes the warp's scan inputs. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
template <typename WarpPrefixOp>
__device__ __forceinline__ void ExclusiveSum(T input, T &output, T &warp_aggregate, WarpPrefixOp &warp_prefix_op, Int2Type<true> is_primitive)
{
// Compute exclusive warp scan from inclusive warp scan
/// Computes an exclusive prefix sum in each logical warp. Instead of using 0 as the warp-wide prefix, the call-back functor \p warp_prefix_op is invoked to provide the "seed" value that logically prefixes the warp's scan inputs. Also provides every thread with the warp-wide \p warp_aggregate of all inputs. Specialized for non-primitive types.
template <typename WarpPrefixOp>
__device__ __forceinline__ void ExclusiveSum(T input, T &output, T &warp_aggregate, WarpPrefixOp &warp_prefix_op, Int2Type<false> is_primitive)
{
// Delegate to regular scan for non-primitive types (because we won't be able to use subtraction)
* \brief Computes an exclusive prefix sum in each logical warp. Instead of using 0 as the warp-wide prefix, the call-back functor \p warp_prefix_op is invoked to provide the "seed" value that logically prefixes the warp's scan inputs. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
*
* This operation assumes the value of obtained by the <tt>T</tt>'s default
* constructor (or by zero-initialization if no user-defined default
* constructor exists) is suitable as the identity value "zero" for
* addition.
*
* The \p warp_prefix_op functor must implement a member function <tt>T operator()(T warp_aggregate)</tt>.
* The functor's input parameter \p warp_aggregate is the same value also returned by the scan operation.
* The functor will be invoked by the entire warp of threads, however only the return value from
* <em>lane</em><sub>0</sub> is applied as the threadblock-wide prefix. Can be stateful.
*
* \smemreuse
*
* The code snippet below illustrates a single thread block of 32 threads (one warp) that progressively
* computes an exclusive prefix sum over multiple "tiles" of input using a
* prefix functor to maintain a running total between block-wide scans. Each tile consists
* of 32 integer items that are partitioned across the warp.
* \par
* \code
* #include <cub/cub.cuh>
*
* // A stateful callback functor that maintains a running prefix to be applied
* Suppose the input \p d_data is <tt>1, 1, 1, 1, 1, 1, 1, 1, ...</tt>.
* The corresponding output for the first segment will be <tt>0, 1, 2, ..., 31</tt>.
* The output for the second segment will be <tt>32, 33, 34, ..., 63</tt>. Furthermore,
* the value \p 32 will be stored in \p warp_aggregate for all threads after each scan.
*
* \tparam WarpPrefixOp <b>[inferred]</b> Call-back functor type having member <tt>T operator()(T warp_aggregate)</tt>
*/
template <typename WarpPrefixOp>
__device__ __forceinline__ void ExclusiveSum(
T input, ///< [in] Calling thread's input item.
T &output, ///< [out] Calling thread's output item. May be aliased with \p input.
T &warp_aggregate, ///< [out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Warp-wide aggregate reduction of input items (exclusive of the \p warp_prefix_op value).
WarpPrefixOp &warp_prefix_op) ///< [in-out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Call-back functor for specifying a warp-wide prefix to be applied to all inputs.
* \brief Computes an inclusive prefix sum using the specified binary scan functor in each logical warp. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
*
* Supports non-commutative scan operators.
*
* \smemreuse
*
* The code snippet below illustrates four concurrent warp-wide inclusive prefix max scans within a block of
* 128 threads (one per each of the 32-thread warps).
* \brief Computes an inclusive prefix sum using the specified binary scan functor in each logical warp. The call-back functor \p warp_prefix_op is invoked to provide the "seed" value that logically prefixes the warp's scan inputs. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
*
* The \p warp_prefix_op functor must implement a member function <tt>T operator()(T warp_aggregate)</tt>.
* The functor's input parameter \p warp_aggregate is the same value also returned by the scan operation.
* The functor will be invoked by the entire warp of threads, however only the return value from
* <em>lane</em><sub>0</sub> is applied as the threadblock-wide prefix. Can be stateful.
*
* Supports non-commutative scan operators.
*
* \smemreuse
*
* The code snippet below illustrates a single thread block of 32 threads (one warp) that progressively
* computes an inclusive prefix max scan over multiple "tiles" of input using a
* prefix functor to maintain a running total between block-wide scans. Each tile consists
* of 32 integer items that are partitioned across the warp.
* \par
* \code
* #include <cub/cub.cuh>
*
* // A stateful callback functor that maintains a running prefix to be applied
* Suppose the input \p d_data is <tt>0, -1, 2, -3, 4, -5, ...</tt>.
* The corresponding output for the first segment will be <tt>0, 0, 2, 2, ..., 30, 30</tt>.
* The output for the second segment will be <tt>32, 32, 34, 34, ..., 62, 62</tt>. Furthermore,
* \p block_aggregate will be assigned \p 30 in all threads after the first scan, assigned \p 62 after the second
* scan, etc.
*
* \tparam ScanOp <b>[inferred]</b> Binary scan operator type having member <tt>T operator()(const T &a, const T &b)</tt>
* \tparam WarpPrefixOp <b>[inferred]</b> Call-back functor type having member <tt>T operator()(T warp_aggregate)</tt>
*/
template <
typename ScanOp,
typename WarpPrefixOp>
__device__ __forceinline__ void InclusiveScan(
T input, ///< [in] Calling thread's input item.
T &output, ///< [out] Calling thread's output item. May be aliased with \p input.
ScanOp scan_op, ///< [in] Binary scan operator
T &warp_aggregate, ///< [out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Warp-wide aggregate reduction of input items (exclusive of the \p warp_prefix_op value).
WarpPrefixOp &warp_prefix_op) ///< [in-out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Call-back functor for specifying a warp-wide prefix to be applied to all inputs.
* \brief Computes an exclusive prefix scan using the specified binary scan functor in each logical warp. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
*
* Supports non-commutative scan operators.
*
* \smemreuse
*
* The code snippet below illustrates four concurrent warp-wide exclusive prefix max scans within a block of
* 128 threads (one per each of the 32-thread warps).
* \brief Computes an exclusive prefix scan using the specified binary scan functor in each logical warp. The call-back functor \p warp_prefix_op is invoked to provide the "seed" value that logically prefixes the warp's scan inputs. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
*
* The \p warp_prefix_op functor must implement a member function <tt>T operator()(T warp_aggregate)</tt>.
* The functor's input parameter \p warp_aggregate is the same value also returned by the scan operation.
* The functor will be invoked by the entire warp of threads, however only the return value from
* <em>lane</em><sub>0</sub> is applied as the threadblock-wide prefix. Can be stateful.
*
* Supports non-commutative scan operators.
*
* \smemreuse
*
* The code snippet below illustrates a single thread block of 32 threads (one warp) that progressively
* computes an exclusive prefix max scan over multiple "tiles" of input using a
* prefix functor to maintain a running total between block-wide scans. Each tile consists
* of 32 integer items that are partitioned across the warp.
* \par
* \code
* #include <cub/cub.cuh>
*
* // A stateful callback functor that maintains a running prefix to be applied
* Suppose the input \p d_data is <tt>0, -1, 2, -3, 4, -5, ...</tt>.
* The corresponding output for the first segment will be <tt>INT_MIN, 0, 0, 2, ..., 28, 30</tt>.
* The output for the second segment will be <tt>30, 32, 32, 34, ..., 60, 62</tt>. Furthermore,
* \p block_aggregate will be assigned \p 30 in all threads after the first scan, assigned \p 62 after the second
* scan, etc.
*
* \tparam ScanOp <b>[inferred]</b> Binary scan operator type having member <tt>T operator()(const T &a, const T &b)</tt>
* \tparam WarpPrefixOp <b>[inferred]</b> Call-back functor type having member <tt>T operator()(T warp_aggregate)</tt>
*/
template <
typename ScanOp,
typename WarpPrefixOp>
__device__ __forceinline__ void ExclusiveScan(
T input, ///< [in] Calling thread's input item.
T &output, ///< [out] Calling thread's output item. May be aliased with \p input.
T identity, ///< [in] Identity value
ScanOp scan_op, ///< [in] Binary scan operator
T &warp_aggregate, ///< [out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Warp-wide aggregate reduction of input items (exclusive of the \p warp_prefix_op value).
WarpPrefixOp &warp_prefix_op) ///< [in-out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Call-back functor for specifying a warp-wide prefix to be applied to all inputs.
* \brief Computes an exclusive prefix scan using the specified binary scan functor in each logical warp. Because no identity value is supplied, the \p output computed for <em>warp-lane</em><sub>0</sub> is undefined.
*
* Supports non-commutative scan operators.
*
* \smemreuse
*
* The code snippet below illustrates four concurrent warp-wide exclusive prefix max scans within a block of
* 128 threads (one per each of the 32-thread warps).
* \brief Computes an exclusive prefix scan using the specified binary scan functor in each logical warp. Because no identity value is supplied, the \p output computed for <em>warp-lane</em><sub>0</sub> is undefined. Also provides every thread with the warp-wide \p warp_aggregate of all inputs.
*
* Supports non-commutative scan operators.
*
* \smemreuse
*
* The code snippet below illustrates four concurrent warp-wide exclusive prefix max scans within a block of
* 128 threads (one per each of the 32-thread warps).
* Suppose the set of input \p thread_data across the block of threads is <tt>0, -1, 2, -3, ..., 126, -127</tt>.
* The corresponding output \p thread_data in the first warp would be
* <tt>?, 0, 0, 2, ..., 28, 30</tt>, the output for the second warp would be <tt>?, 32, 32, 34, ..., 60, 62</tt>, etc.
* (The output \p thread_data in each warp lane0 is undefined.) Furthermore, \p warp_aggregate would be assigned \p 30 for threads in the first warp, \p 62 for threads
* in the second warp, etc.
*
* \tparam ScanOp <b>[inferred]</b> Binary scan operator type having member <tt>T operator()(const T &a, const T &b)</tt>
*/
template <typename ScanOp>
__device__ __forceinline__ void ExclusiveScan(
T input, ///< [in] Calling thread's input item.
T &output, ///< [out] Calling thread's output item. May be aliased with \p input.
ScanOp scan_op, ///< [in] Binary scan operator
T &warp_aggregate) ///< [out] Warp-wide aggregate reduction of input items.
* \brief Computes an exclusive prefix scan using the specified binary scan functor in each logical warp. The \p warp_prefix_op value from thread-thread-lane<sub>0</sub> is applied to all scan outputs. Also computes the warp-wide \p warp_aggregate of all inputs for thread-thread-lane<sub>0</sub>.
*
* The \p warp_prefix_op functor must implement a member function <tt>T operator()(T warp_aggregate)</tt>.
* The functor's input parameter \p warp_aggregate is the same value also returned by the scan operation.
* The functor will be invoked by the entire warp of threads, however only the return value from
* <em>lane</em><sub>0</sub> is applied as the threadblock-wide prefix. Can be stateful.
*
* Supports non-commutative scan operators.
*
* \smemreuse
*
* The code snippet below illustrates a single thread block of 32 threads (one warp) that progressively
* computes an exclusive prefix max scan over multiple "tiles" of input using a
* prefix functor to maintain a running total between block-wide scans. Each tile consists
* of 32 integer items that are partitioned across the warp.
* \par
* \code
* #include <cub/cub.cuh>
*
* // A stateful callback functor that maintains a running prefix to be applied
* Suppose the input \p d_data is <tt>0, -1, 2, -3, 4, -5, ...</tt>.
* The corresponding output for the first segment will be <tt>INT_MIN, 0, 0, 2, ..., 28, 30</tt>.
* The output for the second segment will be <tt>30, 32, 32, 34, ..., 60, 62</tt>. Furthermore,
* \p block_aggregate will be assigned \p 30 in all threads after the first scan, assigned \p 62 after the second
* scan, etc.
*
* \tparam ScanOp <b>[inferred]</b> Binary scan operator type having member <tt>T operator()(const T &a, const T &b)</tt>
* \tparam WarpPrefixOp <b>[inferred]</b> Call-back functor type having member <tt>T operator()(T warp_aggregate)</tt>
*/
template <
typename ScanOp,
typename WarpPrefixOp>
__device__ __forceinline__ void ExclusiveScan(
T input, ///< [in] Calling thread's input item.
T &output, ///< [out] Calling thread's output item. May be aliased with \p input.
ScanOp scan_op, ///< [in] Binary scan operator
T &warp_aggregate, ///< [out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Warp-wide aggregate reduction of input items (exclusive of the \p warp_prefix_op value).
WarpPrefixOp &warp_prefix_op) ///< [in-out] <b>[<em>warp-lane</em><sub>0</sub> only]</b> Call-back functor for specifying a warp-wide prefix to be applied to all inputs.