LocalityDomain.h

#ifndef DASH__UTIL__LOCALITY_DOMAIN_H__INCLUDED
#define DASH__UTIL__LOCALITY_DOMAIN_H__INCLUDED

#include <dash/util/Locality.h>

#include <dash/dart/if/dart_types.h>
#include <dash/dart/if/dart_locality.h>

#include <dash/algorithm/internal/String.h>

#include <dash/Exception.h>

#include <string>
#include <vector>
#include <unordered_map>
#include <utility>
#include <iterator>
#include <algorithm>
#include <functional>


namespace dash {
namespace util {

namespace internal {

  template< typename LocalityDomainT >
  class LocalityDomainIterator
  : public std::iterator< std::random_access_iterator_tag, LocalityDomainT >
  {
    template< typename LocalityDomainT_ >
    friend class LocalityDomainIterator;

  private:
    typedef LocalityDomainIterator<LocalityDomainT>          self_t;

  public:
    typedef LocalityDomainIterator<LocalityDomainT>       self_type;
    typedef int                                     difference_type;

    typedef       LocalityDomainT                        value_type;
    typedef       LocalityDomainT *                         pointer;
    typedef const LocalityDomainT *                   const_pointer;
    typedef       LocalityDomainT &                       reference;
    typedef const LocalityDomainT &                 const_reference;

  public:

    LocalityDomainIterator(
      LocalityDomainT & domain,
      int               subdomain_idx = 0)
    : _domain(&domain),
      _idx(subdomain_idx)
    { }

    LocalityDomainIterator() = default;

    template< typename LocalityDomainT_Other >
    LocalityDomainIterator(
      const LocalityDomainIterator<LocalityDomainT_Other> & other)
    : _domain(const_cast<LocalityDomainT *>(other._domain)),
      _idx(other._idx)
    { }

    bool operator==(const self_type & rhs) const {
      return *_domain == *(rhs._domain) && _idx == rhs._idx;
    }

    bool operator!=(const self_type & rhs) const {
      return !(*this == rhs);
    }

    reference operator[](int i)
    {
      DASH_ASSERT(_domain != nullptr);
      int subdomain_idx = _idx + i;
      return _domain->at(subdomain_idx);
    }

    const_reference operator[](int i) const
    {
      DASH_ASSERT(_domain != nullptr);
      int subdomain_idx = _idx + i;
      return _domain->at(subdomain_idx);
    }

    reference operator*()
    {
      DASH_ASSERT(_domain != nullptr);
      return _domain->at(_idx);
    }

    const_reference operator*() const
    {
      DASH_ASSERT(_domain != nullptr);
      return _domain->at(_idx);
    }

    pointer operator->()
    {
      DASH_ASSERT(_domain != nullptr);
      return &(_domain->at(_idx));
    }

    const_pointer operator->() const
    {
      DASH_ASSERT(_domain != nullptr);
      return &(_domain->at(_idx));
    }

    self_t & operator++()      { _idx++;   return *this; }
    self_t & operator--()      { _idx--;   return *this; }
    self_t & operator+=(int i) { _idx+= i; return *this; }
    self_t & operator-=(int i) { _idx-= i; return *this; }
    self_t   operator+(int i)  { self_t ret = *this; ret += i; return ret; }
    self_t   operator-(int i)  { self_t ret = *this; ret -= i; return ret; }
    self_t   operator++(int)   { self_t ret = *this; _idx++;   return ret; }
    self_t   operator--(int)   { self_t ret = *this; _idx--;   return ret; }

  private:
    LocalityDomainT * _domain = nullptr;
    int               _idx    = 0;

  }; // class LocalityDomain::iterator

}

class LocalityDomain
{
private:
  typedef LocalityDomain               self_t;
  typedef dash::util::Locality::Scope Scope_t;

public:
  typedef internal::LocalityDomainIterator<self_t>              iterator;
  typedef internal::LocalityDomainIterator<const self_t>  const_iterator;

private:
  LocalityDomain(
    const self_t                 & parent,
    dart_domain_locality_t       * domain);

private:
  dart_domain_locality_t                          * _domain     = nullptr;
  std::string                                       _domain_tag = ".";
  mutable std::unordered_map<int, self_t>         * _subdomains = nullptr;
  std::vector<global_unit_t>                        _unit_ids;
#if 0
  std::unordered_map<team_unit_t, UnitLocality_t>   _unit_localities;
#endif
  iterator                                          _begin;
  iterator                                          _end;
  bool                                              _is_owner   = false;
  std::vector<iterator>                             _groups;
  std::vector<std::string>                          _group_domain_tags;
  std::vector<self_t>                               _parts;

public:
  LocalityDomain() = default;

  explicit LocalityDomain(
    const dart_domain_locality_t & domain);

  explicit LocalityDomain(
    dart_domain_locality_t * domain);

  ~LocalityDomain();

  LocalityDomain(
    const self_t & other);

  LocalityDomain(
    self_t && other);

  self_t & operator=(
    const self_t & other);

  self_t & operator=(
    self_t && other);

  inline bool operator==(
    const self_t & rhs) const {
    return ( (_domain == rhs._domain)
             ||
             ( (_domain     != nullptr &&
                rhs._domain != nullptr)
                &&
               (_domain->team
                  == rhs._domain->team &&
                _domain->domain_tag
                  == rhs._domain->domain_tag) ) );
  }

  inline bool operator!=(
    const self_t & rhs) const {
    return !(*this == rhs);
  }

  self_t & select(
    const std::vector<std::string> & subdomain_tags);

  self_t & exclude(
    const std::vector<std::string> & subdomain_tags);

  self_t & group(
    const std::vector<std::string> & group_subdomain_tags);

  self_t & split(
    dash::util::Locality::Scope      scope,
    int                              num_split_parts);

  self_t & split_groups();

  const self_t & at(
    int relative_index) const;

  self_t & at(
    int relative_index);

  const_iterator find(
    const std::string & subdomain_tag) const;

  iterator find(
    const std::string & subdomain_tag);

  inline std::vector<iterator> & groups()
  {
    return _groups;
  }

  inline const std::vector<iterator> & groups() const
  {
    return _groups;
  }

  inline std::vector<self_t> & parts()
  {
    return _parts;
  }

  inline const std::vector<self_t> & parts() const
  {
    return _parts;
  }

  inline std::vector<self_t> scope_domains(
    dash::util::Locality::Scope scope) const
  {
    std::vector<self_t>       scope_domains;
    int                       num_scope_domains;

    dart_domain_locality_t ** dart_scope_domains;
    dart_ret_t ret = dart_domain_scope_domains(
                       _domain,
                       static_cast<dart_locality_scope_t>(scope),
                       &num_scope_domains,
                       &dart_scope_domains);
    (void)ret; // suppress warning
    DASH_ASSERT(DART_OK == ret || DART_ERR_NOTFOUND == ret);

    DASH_LOG_TRACE_VAR("LocalityDomain.scope_domains", num_scope_domains);
    if (num_scope_domains > 0) {
      scope_domains.reserve(num_scope_domains);
      for (int sd = 0; sd < num_scope_domains; sd++) {
        DASH_LOG_TRACE("LocalityDomain.scope_domains",
                       "scope_domains[", sd, "]", ":",
                       dart_scope_domains[sd]->domain_tag);
        scope_domains.emplace_back(*dart_scope_domains[sd]);
      }
      free(dart_scope_domains);
    }
    return scope_domains;
  }

#if 0
  inline const UnitLocality_t & unit_locality(
      team_unit_t unit) const
  {
    if (nullptr == _parent) {
      return (*_unit_localities.find(unit)).second;
    }
    return _parent->unit_locality(unit);
  }

  inline UnitLocality_t & unit_locality(
      team_unit_t unit)
  {
    if (nullptr == _parent) {
      return _unit_localities[unit];
    }
    return _parent->unit_locality(unit);
  }
#endif

  inline dart_team_t dart_team() const
  {
    if (nullptr == _domain) {
      return DART_TEAM_NULL;
    }
    return _domain->team;
  }

  inline const std::string & domain_tag() const
  {
    return _domain_tag;
  }

  inline const dart_domain_locality_t & dart_type() const
  {
    DASH_ASSERT(_domain != nullptr);
    return *_domain;
  }

  inline std::string host() const
  {
    DASH_ASSERT(_domain != nullptr);
    return _domain->host;
  }

  inline int shared_mem_bytes() const
  {
    DASH_ASSERT(_domain != nullptr);
    return _domain->shared_mem_bytes;
  }

  inline iterator begin()
  {
    return _begin;
  }

  inline const_iterator begin() const
  {
    return const_iterator(_begin);
  }

  inline iterator end()
  {
    return _end;
  }

  inline const_iterator end() const
  {
    return const_iterator(_end);
  }

  inline size_t size() const
  {
    return _domain == nullptr
           ? 0
           : _domain->num_domains;
  }

  inline const std::vector<global_unit_t> & units() const
  {
    return _unit_ids;
  }

  inline std::vector<global_unit_t> & units()
  {
    return _unit_ids;
  }

  inline global_unit_t leader_unit() const
  {
    // TODO: Optimize

    // Unit 0 is default leader if contained in the domain:
    if (std::find(_unit_ids.begin(), _unit_ids.end(), global_unit_t(0))
        != _unit_ids.end()) {
      return global_unit_t(0);
    }
    return _unit_ids.front();
  }

  inline int level() const
  {
    return (nullptr == _domain ? -1 : _domain->level);
  }

  inline Scope_t scope() const
  {
    return _domain == nullptr
           ? Scope_t::Undefined
           : static_cast<Scope_t>(_domain->scope);
  }

  inline int node_id() const
  {
    return (nullptr == _domain ? -1 : _domain->node_id);
  }

  inline int num_nodes() const
  {
    return (nullptr == _domain ? -1 : _domain->num_nodes);
  }

  inline int num_cores() const
  {
    return (nullptr == _domain ? -1 : _domain->num_cores);
  }

  inline int global_index() const
  {
    return (nullptr == _domain ? -1 : _domain->global_index);
  }

  inline int relative_index() const
  {
    return (nullptr == _domain ? -1 : _domain->num_cores);
  }

private:

  inline void init(
    dart_domain_locality_t * domain);

  inline void collect_groups(
    const std::vector<std::string> & group_domain_tags)
  {
    _groups.clear();
    for (const auto& gdt : group_domain_tags) {
      _groups.push_back(find(gdt));
    }
  }

}; // class LocalityDomain

std::ostream & operator<<(
  std::ostream                     & os,
  const dash::util::LocalityDomain & domain_loc);

} // namespace util
} // namespace dash

#endif // DASH__UTIL__LOCALITY_DOMAIN_H__INCLUDED