for_each

Header File: Kokkos_StdAlgorithms.hpp

namespace Kokkos{
namespace Experimental{

template <class ExecutionSpace, class InputIterator, class UnaryFunctorType>
void for_each(const ExecutionSpace& exespace,                            (1)
              InputIterator first, InputIterator last,
              UnaryFunctorType functor);

template <class ExecutionSpace, class InputIterator, class UnaryFunctorType>
void for_each(const std::string& label, const ExecutionSpace& exespace,  (2)
              InputIterator first, InputIterator last,
              UnaryFunctorType functor);

template <class ExecutionSpace, class DataType, class... Properties, class UnaryFunctorType>
void for_each(const ExecutionSpace& exespace,
              const Kokkos::View<DataType, Properties...>& view,                      (3)
              UnaryFunctorType functor);

template <class ExecutionSpace, class DataType, class... Properties, class PredicateType>
void for_each(const std::string& label, const ExecutionSpace& exespace,
              const Kokkos::View<DataType, Properties...>& view,                      (4)
              UnaryFunctorType func);

} //end namespace Experimental
} //end namespace Kokkos

Description

Applies the UnaryFunctorType func to the result of dereferencing each iterator in [first,last) for (1,2) and to the view elements in (3,4).

Parameters and Requirements

• exespace:

  • execution space instance

• label:

  • for 1, the default string is: “Kokkos::for_each_iterator_api_default”

  • for 3, the default string is: “Kokkos::for_each_view_api_default”

• first, last:

  • range of elements to operate on

  • must be random access iterators

  • must represent a valid range, i.e., last >= first (this condition is checked in debug mode)

  • must be accessible from exespace

• view:

  • must be rank-1, and have LayoutLeft, LayoutRight, or LayoutStride

  • must be accessible from exespace

• func:

  • function object called on the all the elements;

  • The signature of the function should be func(v).

  • Must be valid to be called from the execution space passed, and must accept every argument v of type (possible const) value_type, where value_type is the value type of InputIterator, and must not modify v.

  • must conform to:

  struct func
  {
     KOKKOS_INLINE_FUNCTION
     void operator()(const /*type needed */ & operand) const { /* ... */; }
  
     // or, also valid
  
     KOKKOS_INLINE_FUNCTION
     void operator()(/*type needed */ operand) const { /* ... */; }
  };
  

Return

(nothing)

Example

namespace KE = Kokkos::Experimental;

template<class ValueType>
struct IncrementValsFunctor
{
  const ValueType m_value;
  IncrementValsFunctor(ValueType value) : m_value(value){}

  KOKKOS_INLINE_FUNCTION
  void operator()(const ValueType & operand) const {
    operand += m_value;
  }
};

auto exespace = Kokkos::DefaultExecutionSpace;
using view_type = Kokkos::View<exespace, int*>;
view_type a("a", 15);
// fill "a" somehow

// create functor
IncrementValsFunctor<int> p(5);

// Increment each element in "a" by 5.
KE::for_each(exespace, KE::begin(a), KE::end(a), p);

// assuming OpenMP is enabled, then you can also explicitly call
KE::for_each(Kokkos::OpenMP(), KE::begin(a), KE::end(a), p);