`ReducerConcept`#

The concept of a Reducer is the abstraction that defines the “how” a “Reduction” is performed during the parallel reduce execution pattern. The abstraction of “what” is given as a template parameter and corresponds to the “what” that is being reduced in the parallel_reduce operation. This page describes the definitions and functions expected from a Reducer with a hypothetical ‘Reducer’ class definition. A brief description of built-in reducers is also included.

Header File: <Kokkos_Core.hpp>

Usage#

T result;
parallel_reduce(N,Functor,ReducerConcept<T>(result));

Synopsis#

class Reducer {
    public:
        //Required for Concept
        typedef Reducer reducer;
        typedef ... value_type;
        typedef Kokkos::View<value_type, ... > result_view_type;

        KOKKOS_INLINE_FUNCTION
        void join(value_type& dest, const value_type& src) const;

        KOKKOS_INLINE_FUNCTION
        value_type& reference() const;

        KOKKOS_INLINE_FUNCTION
        result_view_type view() const;

        //Optional
        KOKKOS_INLINE_FUNCTION
        void init(value_type& val) const;

        KOKKOS_INLINE_FUNCTION
        void final(value_type& val) const;

        //Part of Build-In reducers for Kokkos
        KOKKOS_INLINE_FUNCTION
        Reducer(value_type& value_);

        KOKKOS_INLINE_FUNCTION
        Reducer(const result_view_type& value_);
};

Public Class Members#

Typedefs#

reducer: The self type.
value_type: The reduction scalar type.
result_view_type: A Kokkos::View referencing where the reduction result should be placed. Can be an unmanaged view of a scalar or complex datatype (class or struct). Unmanaged views must specify the same memory space where the referenced scalar (or complex datatype) resides.

Constructors#

Constructors are not part of the concept. A custom reducer can have complex custom constructors. All Build-In reducers in Kokkos have the following two constructors:

KOKKOS_INLINE_FUNCTION Reducer(value_type &value_);#

Constructs a reducer which references a local variable as its result location.

KOKKOS_INLINE_FUNCTION Reducer(const result_view_type &value_);#

Constructs a reducer which references a specific view as its result location.

Functions#

KOKKOS_INLINE_FUNCTION void join(value_type &dest, const value_type &src) const;#

Combine src into dest. For example, Add performs dest+=src;.

KOKKOS_INLINE_FUNCTION void init(value_type &val) const;#

Optional callback initializing val with appropriate initial value. For example, ‘Add’ assigns val = 0;, but Prod assigns val = 1;. Defaults to calling the default constructor.

KOKKOS_INLINE_FUNCTION void final(value_type &val) const;#

Optional callback modifying the result val. Defaults to a no-op.

KOKKOS_INLINE_FUNCTION value_type &reference() const;#

Returns a reference to the result place.

KOKKOS_INLINE_FUNCTION result_view_type view() const;#

Returns a view of the result place.

Requirements#

The reducer is assumed to define a commutative monoid with respect to the value type it is used with, i.e., the binary operation

value_type op(const value_type& val1, const value_type& val2) {
  value_type result = val1;
  reducer.join(result, val2);
  return result;
}

is commutative and associative with identity element that can be set by calling reducer.init(el).

Built-In Reducers#

Kokkos provides a number of built-in reducers that automatically work with the intrinsic C++ types as well as Kokkos::complex. In order to use a Built-in reducer with a custom type, a template specialization of Kokkos::reduction_identity<CustomType> must be defined. A simple example is shown below and more information can be found under Custom Reductions.

Examples#

#include<Kokkos_Core.hpp>

int main(int argc, char* argv[]) {

    long N = argc>1 ? atoi(argv[1]):100;
    long result;
    Kokkos::parallel_reduce("ReduceSum: ", N, KOKKOS_LAMBDA (const int i, long& lval) {
        lval += i;
    }, Sum<long>(result));

    printf("Result: %l Expected: %l\n",result,N*(N-1)/2);
}

ReducerConcept#