Bcast.h

#ifndef DASH__ALGORITHM__BCAST_H__
#define DASH__ALGORITHM__BCAST_H__

#include <dash/iterator/GlobIter.h>
#include <dash/iterator/IteratorTraits.h>

#include <dash/Team.h>
#include <dash/Shared.h>
#include <dash/algorithm/LocalRange.h>
#include <dash/Coarray.h>

#include <iterator>
#include <vector>
#include <algorithm>


namespace dash {

namespace internal {

template<class LocalInputIter>
void
broadcast(
  LocalInputIter    in_first,
  LocalInputIter    in_last,
  dash::team_unit_t root,
  dash::Team      & team,
  std::random_access_iterator_tag)
{
  using value_t    = typename std::iterator_traits<LocalInputIter>::value_type;
  auto myid        = team.myid();
  auto nelem       = std::distance(in_first, in_last);
  auto ds          = dash::dart_storage<value_t>(nelem);

  DASH_ASSERT_RETURNS(
    dart_bcast(&(*in_first), ds.nelem, ds.dtype, root, team.dart_id()),
    DART_OK);
}

template<class LocalInputIter, class IterTag>
void
broadcast(
  LocalInputIter    in_first,
  LocalInputIter    in_last,
  dash::team_unit_t root,
  dash::Team      & team,
  IterTag           tag = {})
{
  using value_t    = typename std::iterator_traits<LocalInputIter>::value_type;

  // create a contiguous buffer
  std::vector<value_t> tmp(in_first, in_last);

  // broadcast
  dash::internal::broadcast(tmp.begin(), tmp.end(), root, team,
    std::random_access_iterator_tag{});

  // copy back into non-contiguous memory
  if (team.myid() != root) {
    std::copy(tmp.begin(), tmp.end(), in_first);
  }
}

} // namespace internal

template <
  class LocalInputIter,
  typename = typename std::enable_if<
                        !dash::detail::is_global_iterator<LocalInputIter>::value
                      >::type>
void
broadcast(
  LocalInputIter    in_first,
  LocalInputIter    in_last,
  dash::team_unit_t root,
  dash::Team      & team = dash::Team::All())
{
  dash::internal::broadcast(
    in_first, in_last, root, team,
    typename std::iterator_traits<LocalInputIter>::iterator_category());
}

template <class ValueType>
ValueType broadcast(dash::Shared<ValueType>& shared)
{
  ValueType res{};
  auto& team  = shared.team();
  auto  owner = shared.owner();
  ValueType *ptr = (team.myid() == owner) ? shared.local() : std::addressof(res);
  dash::broadcast(ptr,
                  std::next(ptr),
                  owner,
                  shared.team());

  return *ptr;
}

template<typename T>
void broadcast(Coarray<T> & coarr, const team_unit_t & root){
  dash::coarray::cobroadcast(coarr, root);
}

} // namespace dash

#endif // DASH__ALGORITHM__BCAST_H__