thread_operators.cuh

Go to the documentation of this file.

/******************************************************************************
 * 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.
 *
 ******************************************************************************/
 
/******************************************************************************
 * Simple functor operators
 ******************************************************************************/
 
#pragma once
 
#include "../util_macro.cuh"
#include "../util_type.cuh"
#include "../util_namespace.cuh"
 
CUB_NS_PREFIX
 
namespace cub {
 
 
struct Equality
{
    template <typename T>
    __host__ __device__ __forceinline__ bool operator()(const T &a, const T &b) const
    {
        return a == b;
    }
};
 
 
struct Inequality
{
    template <typename T>
    __host__ __device__ __forceinline__ bool operator()(const T &a, const T &b) const
    {
        return a != b;
    }
};
 
 
template <typename EqualityOp>
struct InequalityWrapper
{
    EqualityOp op;
 
    __host__ __device__ __forceinline__
    InequalityWrapper(EqualityOp op) : op(op) {}
 
    template <typename T>
    __host__ __device__ __forceinline__ bool operator()(const T &a, const T &b)
    {
        return !op(a, b);
    }
};
 
 
struct Sum
{
    template <typename T>
    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const
    {
        return a + b;
    }
};
 
 
struct Max
{
    template <typename T>
    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const
    {
        return CUB_MAX(a, b);
    }
};
 
 
struct ArgMax
{
    template <typename T, typename OffsetT>
    __host__ __device__ __forceinline__ KeyValuePair<OffsetT, T> operator()(
        const KeyValuePair<OffsetT, T> &a,
        const KeyValuePair<OffsetT, T> &b) const
    {
// Mooch BUG (device reduce argmax gk110 3.2 million random fp32)
//        return ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key))) ? b : a;
 
        if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
            return b;
        return a;
    }
};
 
 
struct Min
{
    template <typename T>
    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const
    {
        return CUB_MIN(a, b);
    }
};
 
 
struct ArgMin
{
    template <typename T, typename OffsetT>
    __host__ __device__ __forceinline__ KeyValuePair<OffsetT, T> operator()(
        const KeyValuePair<OffsetT, T> &a,
        const KeyValuePair<OffsetT, T> &b) const
    {
// Mooch BUG (device reduce argmax gk110 3.2 million random fp32)
//        return ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key))) ? b : a;
 
        if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
            return b;
        return a;
    }
};
 
 
template <typename B>
struct CastOp
{
    template <typename A>
    __host__ __device__ __forceinline__ B operator()(const A &a) const
    {
        return (B) a;
    }
};
 
 
template <typename ScanOp>
class SwizzleScanOp
{
private:
 
    ScanOp scan_op;
 
public:
 
    __host__ __device__ __forceinline__
    SwizzleScanOp(ScanOp scan_op) : scan_op(scan_op) {}
 
    template <typename T>
    __host__ __device__ __forceinline__
    T operator()(const T &a, const T &b)
    {
      T _a(a);
      T _b(b);
 
      return scan_op(_b, _a);
    }
};
 
 
template <typename ReductionOpT>    
struct ReduceBySegmentOp
{
    ReductionOpT op;
 
    __host__ __device__ __forceinline__ ReduceBySegmentOp() {}
 
    __host__ __device__ __forceinline__ ReduceBySegmentOp(ReductionOpT op) : op(op) {}
 
    template <typename KeyValuePairT>       
    __host__ __device__ __forceinline__ KeyValuePairT operator()(
        const KeyValuePairT &first,         
        const KeyValuePairT &second)        
    {
        KeyValuePairT retval;
        retval.key = first.key + second.key;
        retval.value = (second.key) ?
                second.value :                          // The second partial reduction spans a segment reset, so it's value aggregate becomes the running aggregate
                op(first.value, second.value);          // The second partial reduction does not span a reset, so accumulate both into the running aggregate
        return retval;
    }
};
 
 
 
template <typename ReductionOpT>    
struct ReduceByKeyOp
{
    ReductionOpT op;
 
    __host__ __device__ __forceinline__ ReduceByKeyOp() {}
 
    __host__ __device__ __forceinline__ ReduceByKeyOp(ReductionOpT op) : op(op) {}
 
    template <typename KeyValuePairT>
    __host__ __device__ __forceinline__ KeyValuePairT operator()(
        const KeyValuePairT &first,       
        const KeyValuePairT &second)      
    {
        KeyValuePairT retval = second;
 
        if (first.key == second.key)
            retval.value = op(first.value, retval.value);
 
        return retval;
    }
};
 
 
 
 
 
 
       // end group UtilModule
 
 
}               // CUB namespace
CUB_NS_POSTFIX  // Optional outer namespace(s)