all-reduce.hpp

#ifndef DIY_PARTNERS_ALL_REDUCE_HPP
#define DIY_PARTNERS_ALL_REDUCE_HPP

#include "merge.hpp"

namespace diy
{

class Master;


struct RegularAllReducePartners: public RegularMergePartners
{
  typedef       RegularMergePartners                            Parent; 

  template<class Decomposer>
                RegularAllReducePartners(const Decomposer& decomposer,  
                                         int k,                         
                                         bool contiguous = true         
                    ):
                  Parent(decomposer, k, contiguous)         {}
                RegularAllReducePartners(const DivisionVector&   divs,
                                         const KVSVector&        kvs, 
                                         bool  contiguous = true      
                    ):
                  Parent(divs, kvs, contiguous)               {}

  size_t        rounds() const                                  { return 2*Parent::rounds(); }
  int           size(int round) const                           { return Parent::size(parent_round(round)); }
  int           dim(int round) const                            { return Parent::dim(parent_round(round)); }
  inline bool   active(int round, int gid, const Master& m) const { return Parent::active(parent_round(round), gid, m); }
  int           parent_round(int round) const                   { return round < (int) Parent::rounds() ? round : static_cast<int>(rounds()) - round; }

  // incoming is only valid for an active gid; it will only be called with an active gid
  inline void   incoming(int round, int gid, std::vector<int>& partners, const Master& m) const
  {
      if (round <= (int) Parent::rounds())
          Parent::incoming(round, gid, partners, m);
      else
          Parent::outgoing(parent_round(round), gid, partners, m);
  }

  inline void   outgoing(int round, int gid, std::vector<int>& partners, const Master& m) const
  {
      if (round < (int) Parent::rounds())
          Parent::outgoing(round, gid, partners, m);
      else
          Parent::incoming(parent_round(round), gid, partners, m);
  }
};

} // diy

#endif