dash::halo::StencilOperatorInner< StencilOperatorT > Class Template Reference

Proxy StencilOperator for inner elements only. More...

#include <StencilOperator.h>

Public Types
using	Element_t = typename StencilOperatorT::Element_t
using	ViewSpec_t = typename StencilOperatorT::ViewSpec_t
using	Coords_t = typename StencilOperatorT::Coords_t
using	iterator = typename StencilOperatorT::iterator_inner
using	const_iterator = const iterator
using	StencilOffsets_t = typename StencilOperatorT::StencilOffsets_t

Public Member Functions
	StencilOperatorInner (StencilOperatorT *stencil_op)
iterator	begin () noexcept
	Returns the begin iterator for all inner elements. More...
const_iterator	begin () const noexcept
	Returns the begin const iterator for all inner elements. More...
iterator	end () noexcept
	Returns the end iterator for all inner elements. More...
const_iterator	end () const noexcept
	Returns the end const iterator for all inner elements. More...
const ViewSpec_t &	view () const
	Returns a view for all inner elements. More...
template<typename BinaryFunc = internal::replace<Element_t>>
void	set_values_at (const Coords_t &coords, Element_t value, Element_t coefficient_center, BinaryFunc op=BinaryFunc())
	Modifies all stencil point elements and the center within the inner view. More...
template<typename BinaryFunc = std::plus<Element_t>>
Element_t	get_value_at (const Coords_t &coords, Element_t coefficient_center, BinaryFunc op=BinaryFunc()) const
	Returns the result of the given operation done on all stencil point elements and the center. More...
template<typename Op >
void	update (Element_t *begin_dst, Op operation)
	Updates all inner elements using a user-defined stencil operation. More...
template<typename Op >
void	update (iterator begin, iterator end, Element_t *begin_dst, Op operation)
	Updates all inner elements within a user defined range using a user-defined stencil operation. More...
template<typename Op >
void	update_blocked (const Coords_t &begin_coords, const Coords_t &end_coords, Element_t *begin_dst, Op operation)
	Updates all inner elements within a user defined range using a user-defined stencil operation. More...

Detailed Description

template<typename StencilOperatorT>
class dash::halo::StencilOperatorInner< StencilOperatorT >

Proxy StencilOperator for inner elements only.

Definition at line 30 of file StencilOperator.h.

Member Function Documentation

begin() [1/2]

template<typename StencilOperatorT>

iterator dash::halo::StencilOperatorInner< StencilOperatorT >::begin ( )

inlinenoexcept

Returns the begin iterator for all inner elements.

Definition at line 52 of file StencilOperator.h.

{ return _stencil_op->_ibegin; }

begin() [2/2]

template<typename StencilOperatorT>

const_iterator dash::halo::StencilOperatorInner< StencilOperatorT >::begin ( ) const

inlinenoexcept

Returns the begin const iterator for all inner elements.

Definition at line 57 of file StencilOperator.h.

{ return _stencil_op->_ibegin; }

end() [1/2]

template<typename StencilOperatorT>

iterator dash::halo::StencilOperatorInner< StencilOperatorT >::end ( )

inlinenoexcept

Returns the end iterator for all inner elements.

Definition at line 62 of file StencilOperator.h.

{ return _stencil_op->_iend; }

end() [2/2]

template<typename StencilOperatorT>

const_iterator dash::halo::StencilOperatorInner< StencilOperatorT >::end ( ) const

inlinenoexcept

Returns the end const iterator for all inner elements.

Definition at line 67 of file StencilOperator.h.

{ return _stencil_op->_iend; }

get_value_at()

template<typename StencilOperatorT>

template<typename BinaryFunc = std::plus<Element_t>>

Element_t dash::halo::StencilOperatorInner< StencilOperatorT >::get_value_at ( const Coords_t &  coords, Element_t  coefficient_center, BinaryFunc  op = BinaryFunc()  ) const

inline

Returns the result of the given operation done on all stencil point elements and the center.

The stencil points are multiplied with their coefficent (StencilPoint) and the center is multiplied with the given center coefficient. No test for halo elements. -> useful only for elements with stencil points pointing to inner elements. (no halo elements)

Parameters

coords	center coordinate
coefficient	for center
op	operation to use (e.g. std::plus). default: std::plus

Definition at line 114 of file StencilOperator.h.

                                                                        {
    auto* center = _stencil_op->_local_memory + _stencil_op->get_offset(coords);
    Element_t value = *center * coefficient_center;

    for(auto i = 0; i < NumStencilPoints; ++i) {
      auto& stencil_point_value = center[_stencil_op->_stencil_offsets[i]];
      value = op(value, _stencil_op->_stencil_spec[i].coefficient()
                          * stencil_point_value);
    }

    return value;
  }

set_values_at()

template<typename StencilOperatorT>

template<typename BinaryFunc = internal::replace<Element_t>>

void dash::halo::StencilOperatorInner< StencilOperatorT >::set_values_at ( const Coords_t &  coords, Element_t  value, Element_t  coefficient_center, BinaryFunc  op = BinaryFunc()  )

inline

Modifies all stencil point elements and the center within the inner view.

The stencil points are multiplied with their coefficent (StencilPoint) and the center is multiplied with the given center coefficient. The results then modifies the center/stencil point elements via the given operation.

Parameters

coords	center coordinate
value	base value for all points
coefficient	for center
op	operation to use (e.g. std::plus). default: replace

Definition at line 87 of file StencilOperator.h.

                                                   {
    auto* center = _stencil_op->_local_memory + _stencil_op->get_offset(coords);

    *center = op(*center, coefficient_center * value);
    for(auto i = 0; i < NumStencilPoints; ++i) {
      auto& stencil_point_value = center[_stencil_op->_stencil_offsets[i]];
      stencil_point_value =
        op(stencil_point_value,
           _stencil_op->_stencil_spec[i].coefficient() * value);
    }
  }

update() [1/2]

template<typename StencilOperatorT>

template<typename Op >

void dash::halo::StencilOperatorInner< StencilOperatorT >::update ( Element_t *  begin_dst, Op  operation  )

inline

Updates all inner elements using a user-defined stencil operation.

Parameters

begin_dst	Pointer to the beginning of the destination memory
operation	User-definied operation for updating all inner elements

Definition at line 136 of file StencilOperator.h.

                                                  {
    update(begin(), end(), begin_dst, operation);
  }

update() [2/2]

template<typename StencilOperatorT>

template<typename Op >

void dash::halo::StencilOperatorInner< StencilOperatorT >::update ( iterator  begin, iterator  end, Element_t *  begin_dst, Op  operation  )

inline

Updates all inner elements within a user defined range using a user-defined stencil operation.

Parameters

begin	Iterator of the beginnning inner data element
end	Iterator of the last inner data element
begin_dst	Pointer to the beginning of the destination memory
operation	User-definied operation for updating all inner elements

Definition at line 150 of file StencilOperator.h.

                                                                                {
    if(begin < this->begin() || end < this->begin() ||
       begin > this->end() || end > this->end()) {

      DASH_LOG_ERROR("Begin or End iterator located outside of inner view.");

      return;
    }

    end -= 1;

    const auto& view = this->view();
    const auto& offsets_view = view.offsets();
    const auto& extents_view = view.extents();
    auto end_coords_view = offsets_view;
    for(auto d = 0; d < NumDimensions; ++d) {
      end_coords_view[d] += extents_view[d];
    }

    auto begin_coords = begin.coords();
    auto end_coords   = end.coords();

    auto center  = _stencil_op->_local_memory;
    auto offsets = _stencil_op->set_dimension_offsets();
    auto offset  = 0;
    for(dim_t d = 0; d < NumDimensions; ++d) {
      offset += offsets[d] * begin_coords[d];
    }
    center += offset;
    auto center_dst = begin_dst + offset;

    // specialization for 2-D
    if(NumDimensions == 2) {
      if(begin_coords[0] == end_coords[0]) {
        auto center_i     = center;
        auto center_dst_i = center_dst;
        auto offset_i     = offset;
        for(int j = begin_coords[1]; j <= end_coords[1];
            ++j, ++center_i, ++center_dst_i, ++offset_i) {
          operation(center_i, center_dst_i, offset_i,
                    _stencil_op->_stencil_offsets);
        }

        return;
      }

      auto center_i     = center;
      auto center_dst_i = center_dst;
      auto offset_i     = offset;
      auto align_offset = begin_coords[1] - offsets_view[1];
      for(int j = begin_coords[1]; j < end_coords_view[1];
          ++j, ++center_i, ++center_dst_i, ++offset_i) {
        operation(center_i, center_dst_i, offset_i,
                  _stencil_op->_stencil_offsets);
      }

      center += offsets[0] - align_offset;
      center_dst += offsets[0] - align_offset;
      offset += offsets[0] - align_offset;
      for(int i = begin_coords[0] + 1; i < end_coords[0]; ++i,
              center += offsets[0], center_dst += offsets[0],
              offset += offsets[0]) {
        center_i     = center;
        center_dst_i = center_dst;
        offset_i     = offset;
        for(int j = offsets_view[1]; j < end_coords_view[1];
            ++j, ++center_i, ++center_dst_i, ++offset_i) {
          operation(center_i, center_dst_i, offset_i,
                    _stencil_op->_stencil_offsets);
        }
      }

      center_i     = center;
      center_dst_i = center_dst;
      offset_i     = offset;
      for(int j = offsets_view[1]; j <= end_coords[1];
          ++j, ++center_i, ++center_dst_i, ++offset_i) {
        operation(center_i, center_dst_i, offset_i,
                  _stencil_op->_stencil_offsets);
      }
      return;
    }

    // specialization for 3-D
    if(NumDimensions == 3) {
      for(int i = begin_coords[0]; i <= end_coords[0]; ++i,
              center += offsets[0], center_dst += offsets[0],
              offset += offsets[0]) {
        auto center_i     = center;
        auto center_dst_i = center_dst;
        auto offset_i     = offset;
        for(int j = begin_coords[1]; j <= end_coords[1]; ++j,
                center_i += offsets[1], center_dst_i += offsets[1],
                offset_i += offsets[1]) {
          auto center_j     = center_i;
          auto center_dst_j = center_dst_i;
          auto offset_j     = offset_i;
          for(int k = begin_coords[2]; k <= end_coords[2];
              ++k, ++center_j, ++center_dst_j, ++offset_j) {
            operation(center_j, center_dst_j, offset_j,
                      _stencil_op->_stencil_offsets);
          }
        }
      }

      return;
    }

    // dimensions above 3-D
    for(int i = begin_coords[0]; i <= end_coords[0]; ++i, center += offsets[0],
            center_dst += offsets[0], offset += offsets[0]) {
      Loop<1, Op>()(_stencil_op->_stencil_offsets, offsets, begin_coords,
                    end_coords, center, center_dst, offset, operation);
    }
  }

update_blocked()

template<typename StencilOperatorT>

template<typename Op >

void dash::halo::StencilOperatorInner< StencilOperatorT >::update_blocked ( const Coords_t &  begin_coords, const Coords_t &  end_coords, Element_t *  begin_dst, Op  operation  )

inline

Updates all inner elements within a user defined range using a user-defined stencil operation.

Parameters

begin	Iterator of the beginnning inner data element
end	Iterator of the last inner data element
begin_dst	Pointer to the beginning of the destination memory
operation	User-definied operation for updating all inner elements

Definition at line 276 of file StencilOperator.h.

                                                                                                                    {
    const auto& view = this->view();
    const auto& offsets_view = view.offsets();
    const auto& extents_view = view.extents();

    for(auto d = 0; d < NumDimensions; ++d) {
      auto end_coord = offsets_view[d] + extents_view[d];
      if(begin_coords[d] < offsets_view[d] ||
         end_coords[d] < offsets_view[d] ||
         begin_coords[d] >= end_coord ||
         end_coords[d] >= end_coord) {

        DASH_LOG_ERROR("Begin or End coordinates located outside of inner view.");

        return;
      }
    }

    auto center  = _stencil_op->_local_memory;
    auto offsets = _stencil_op->set_dimension_offsets();
    auto offset  = 0;
    for(dim_t d = 0; d < NumDimensions; ++d) {
      offset += offsets[d] * begin_coords[d];
    }
    center += offset;
    auto center_dst = begin_dst + offset;

    // specialization for 2-D
    if(NumDimensions == 2) {
      for(int i = begin_coords[0]; i <= end_coords[0]; ++i,
              center += offsets[0], center_dst += offsets[0],
              offset += offsets[0]) {
        auto center_i     = center;
        auto center_dst_i = center_dst;
        auto offset_i     = offset;
        for(int j = begin_coords[1]; j <= end_coords[1];
            ++j, ++center_i, ++center_dst_i, ++offset_i) {
          operation(center_i, center_dst_i, offset_i,
                    _stencil_op->_stencil_offsets);
        }
      }
      return;
    }

    // specialization for 3-D
    if(NumDimensions == 3) {
      for(int i = begin_coords[0]; i <= end_coords[0]; ++i,
              center += offsets[0], center_dst += offsets[0],
              offset += offsets[0]) {
        auto center_i     = center;
        auto center_dst_i = center_dst;
        auto offset_i     = offset;
        for(int j = begin_coords[1]; j <= end_coords[1]; ++j,
                center_i += offsets[1], center_dst_i += offsets[1],
                offset_i += offsets[1]) {
          auto center_j     = center_i;
          auto center_dst_j = center_dst_i;
          auto offset_j     = offset_i;
          for(int k = begin_coords[2]; k <= end_coords[2];
              ++k, ++center_j, ++center_dst_j, ++offset_j) {
            operation(center_j, center_dst_j, offset_j,
                      _stencil_op->_stencil_offsets);
          }
        }
      }

      return;
    }

    // dimensions above 3-D
    for(int i = begin_coords[0]; i <= end_coords[0]; ++i, center += offsets[0],
            center_dst += offsets[0], offset += offsets[0]) {
      Loop<1, Op>()(_stencil_op->_stencil_offsets, offsets, begin_coords,
                    end_coords, center, center_dst, offset, operation);
    }
  }

view()

template<typename StencilOperatorT>

const ViewSpec_t& dash::halo::StencilOperatorInner< StencilOperatorT >::view ( ) const

inline

Returns a view for all inner elements.

Definition at line 72 of file StencilOperator.h.

{ return _stencil_op->_spec_views.inner(); }

---

The documentation for this class was generated from the following file:

• /tmp/tmporruphar/dash/include/dash/halo/StencilOperator.h