nimble::ReductionClique_t Struct Reference

#include <nimble.mpi.rank_clique_reducer.h>

Public Member Functions
	ReductionClique_t ()
	ReductionClique_t (const std::vector< int > &index_list, int buffersize, int comm_color, const mpicontext &context)
	ReductionClique_t (const std::vector< int > &index_list, int buffersize, MPI_Comm clique_comm)
	ReductionClique_t (ReductionClique_t &&source)=default
ReductionClique_t &	operator= (ReductionClique_t &&source)=default
bool	okayfieldsizeQ (int field_size)
void	fitnewfieldsize (int new_field_size)
void	resizebuffer (int newbuffersize)
template<int field_size>
void	pack (double *source)
template<int field_size>
void	unpack (double *dest)
template<int field_size, class Lookup>
void	pack (Lookup &source)
template<int field_size, class Lookup>
void	unpack (Lookup &dest)
void	EnsureDataSafety (int field_size)
template<int field_size, class Lookup>
void	reduce (Lookup &&data)
template<int field_size, class Lookup>
void	asyncreduce_initialize (Lookup &&databuffer)
bool	Iallreduce_completedQ ()
template<int field_size, class Lookup>
bool	asyncreduce_finalize (Lookup &&databuffer)
int	GetNumIndices ()
int const *	GetIndices ()
std::vector< int >	GetMPICommWorldRanks ()

Public Attributes
std::unique_ptr< int[]>	indices
std::unique_ptr< double[]>	sendbuffer
std::unique_ptr< double[]>	recvbuffer
int	buffersize
int	n_indices
MPI_Comm	clique_comm
MPI_Request	Iallreduce_request
bool	exists_active_asyncreduce_request = false

Constructor & Destructor Documentation

ReductionClique_t() [1/4]

nimble::ReductionClique_t::ReductionClique_t ( )

inline

{}

ReductionClique_t() [2/4]

nimble::ReductionClique_t::ReductionClique_t ( const std::vector< int > & index_list, int buffersize, int comm_color, const mpicontext & context )

inline

      : indices{new int[index_list.size()]},
        sendbuffer{new double[buffersize]},
        recvbuffer{new double[buffersize]},
        buffersize{buffersize},
        n_indices{(int)index_list.size()},
        // Actual instantiation of clique_comm is performed by MPI_Comm_split
        clique_comm{}
  {
    std::copy_n(index_list.data(), index_list.size(), indices.get());
    // printf("rank %d: Splitting %d with comm color %d\n", context.get_rank(),
    // context.get_comm(), comm_color);
    MPI_Comm_split(context.get_comm(), comm_color, context.get_rank(), &clique_comm);
  }

ReductionClique_t() [3/4]

nimble::ReductionClique_t::ReductionClique_t ( const std::vector< int > & index_list, int buffersize, MPI_Comm clique_comm )

inline

      : indices{new int[index_list.size()]},
        sendbuffer{new double[buffersize]},
        recvbuffer{new double[buffersize]},
        buffersize{buffersize},
        n_indices{(int)index_list.size()},
        clique_comm{clique_comm}
  {
    std::copy_n(index_list.data(), index_list.size(), indices.get());
  }

ReductionClique_t() [4/4]

nimble::ReductionClique_t::ReductionClique_t ( ReductionClique_t && source )

default

Member Function Documentation

asyncreduce_finalize()

template<int field_size, class Lookup>

bool nimble::ReductionClique_t::asyncreduce_finalize ( Lookup && databuffer )

inline

  {
    if (exists_active_asyncreduce_request) {
      if (Iallreduce_completedQ()) {
        unpack<field_size>(databuffer);
        exists_active_asyncreduce_request = false;
        return true;
      } else {
        return false;
      }
    } else {
      NIMBLE_ABORT(
          "asyncreduce_finalize(data) was called "
          "without an active asynchronous reduce request.");
    }
  }

asyncreduce_initialize()

template<int field_size, class Lookup>

void nimble::ReductionClique_t::asyncreduce_initialize ( Lookup && databuffer )

inline

  {
    if (exists_active_asyncreduce_request) {
      NIMBLE_ABORT(
          "asyncreduce_initialize(data) was called "
          "when an active asynchronous reduce already exists");
    }
 
    EnsureDataSafety(field_size);
    pack<field_size>(databuffer);
    MPI_Iallreduce(
        sendbuffer.get(),
        recvbuffer.get(),
        n_indices * field_size,
        MPI_DOUBLE,
        MPI_SUM,
        clique_comm,
        &Iallreduce_request);
    exists_active_asyncreduce_request = true;
  }

EnsureDataSafety()

void nimble::ReductionClique_t::EnsureDataSafety ( int field_size )

inline

  {
    if (!okayfieldsizeQ(field_size)) { throw std::invalid_argument("Field size too big"); }
  }

fitnewfieldsize()

void nimble::ReductionClique_t::fitnewfieldsize ( int new_field_size )

inline

  {
    resizebuffer(n_indices * new_field_size);
  }

GetIndices()

int const * nimble::ReductionClique_t::GetIndices ( )

inline

  {
    return indices.get();
  }

GetMPICommWorldRanks()

std::vector< int > nimble::ReductionClique_t::GetMPICommWorldRanks ( )

inline

  {
    int my_mpi_comm_world_rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &my_mpi_comm_world_rank);
    int clique_comm_size;
    MPI_Comm_size(clique_comm, &clique_comm_size);
    std::vector<int> mpi_comm_world_ranks(clique_comm_size);
    MPI_Allgather(&my_mpi_comm_world_rank, 1, MPI_INT, mpi_comm_world_ranks.data(), 1, MPI_INT, clique_comm);
    std::sort(mpi_comm_world_ranks.begin(), mpi_comm_world_ranks.end());
    return mpi_comm_world_ranks;
  }

GetNumIndices()

int nimble::ReductionClique_t::GetNumIndices ( )

inline

  {
    return n_indices;
  }

Iallreduce_completedQ()

bool nimble::ReductionClique_t::Iallreduce_completedQ ( )

inline

  {
    if (exists_active_asyncreduce_request) {
      int flag = 0;
      MPI_Test(&Iallreduce_request, &flag, MPI_STATUS_IGNORE);
      // flag is set to true if the allreduce has completed
      return flag != 0;
    } else {
      NIMBLE_ABORT(
          "Iallreduce_completedQ() was called "
          "without an active asynchronous reduce request.");
    }
  }

okayfieldsizeQ()

bool nimble::ReductionClique_t::okayfieldsizeQ ( int field_size )

inline

  {
    return field_size * n_indices <= buffersize;
  }

operator=()

ReductionClique_t & nimble::ReductionClique_t::operator= ( ReductionClique_t && source )

default

pack() [1/2]

template<int field_size>

void nimble::ReductionClique_t::pack ( double * source )

inline

  {
    double* destscan  = sendbuffer.get();
    int *   index_ptr = indices.get(), *index_ptr_end = index_ptr + n_indices;
    for (; index_ptr < index_ptr_end; ++index_ptr) {
      double* sourcescan = source + (*index_ptr) * field_size;
      for (int j = 0; j < field_size; ++j) {
        *destscan = *sourcescan;
        ++destscan;
        ++sourcescan;
      }
    }
  }

pack() [2/2]

template<int field_size, class Lookup>

void nimble::ReductionClique_t::pack ( Lookup & source )

inline

  {
    double* destscan = sendbuffer.get();
 
    for (int index : quanta::arrayview_t<int>(indices.get(), n_indices)) {
      for (int j = 0; j < field_size; ++j) { *destscan++ = source(index, j); }
    }
  }

reduce()

template<int field_size, class Lookup>

void nimble::ReductionClique_t::reduce ( Lookup && data )

inline

  {
    EnsureDataSafety(field_size);
    pack<field_size>(data);
    MPI_Allreduce(sendbuffer.get(), recvbuffer.get(), n_indices * field_size, MPI_DOUBLE, MPI_SUM, clique_comm);
    unpack<field_size>(data);
  }

resizebuffer()

void nimble::ReductionClique_t::resizebuffer ( int newbuffersize )

inline

  {
    sendbuffer.reset(new double[newbuffersize]);
    recvbuffer.reset(new double[newbuffersize]);
    buffersize = newbuffersize;
  }

unpack() [1/2]

template<int field_size>

void nimble::ReductionClique_t::unpack ( double * dest )

inline

  {
    double* sourcescan = recvbuffer.get();
    int *   index_ptr = indices.get(), *index_ptr_end = index_ptr + n_indices;
    for (; index_ptr < index_ptr_end; ++index_ptr) {
      double* destscan = dest + (*index_ptr) * field_size;
      for (int j = 0; j < field_size; ++j) {
        *destscan = *sourcescan;
        ++destscan;
        ++sourcescan;
      }
    }
  }

unpack() [2/2]

template<int field_size, class Lookup>

void nimble::ReductionClique_t::unpack ( Lookup & dest )

inline

  {
    double* sourcescan = recvbuffer.get();
    for (int index : quanta::arrayview_t<int>(indices.get(), n_indices)) {
      for (int j = 0; j < field_size; ++j) { dest(index, j) = *sourcescan++; }
    }
  }

Member Data Documentation

buffersize

int nimble::ReductionClique_t::buffersize

clique_comm

MPI_Comm nimble::ReductionClique_t::clique_comm

exists_active_asyncreduce_request

bool nimble::ReductionClique_t::exists_active_asyncreduce_request = false

Iallreduce_request

MPI_Request nimble::ReductionClique_t::Iallreduce_request

indices

std::unique_ptr<int[]> nimble::ReductionClique_t::indices

n_indices

int nimble::ReductionClique_t::n_indices

recvbuffer

std::unique_ptr<double[]> nimble::ReductionClique_t::recvbuffer

sendbuffer

std::unique_ptr<double[]> nimble::ReductionClique_t::sendbuffer

---

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

• src/nimble.mpi.rank_clique_reducer.h