channel.h

Go to the documentation of this file.

 
/*
   std::vector version with the allocator templated
                            [5 May 2022 I.Kanamori]
 */
 
#ifndef CHANNEL_H_INCLUDED
#define CHANNEL_H_INCLUDED
 
#include <mpi.h>
#include <cassert>
#include <vector>
 
#include "lib/Communicator/communicator.h"
#include "aligned_allocator_impl.h"
 
 
// forward declaration
class ChannelSet;
 
 
class Channel_communicator {
 public:
  typedef char element_type;
  static constexpr int max_dimension = 8;
 
  Channel_communicator();          
  //  Channel_communicator(const int count);  //!< constructor with buffer size (count bytes)
  virtual ~Channel_communicator(); 
 
  int start();                     
  int wait();                      
 
  int send_init(int count, int idir, int ipm, void *buf);
  int recv_init(int count, int idir, int ipm, void *buf);
 
  MPI_Request& get_request() { return m_request; }
 
 private:
 
  MPI_Request m_request;  
  MPI_Status m_status;    
 
  // offsetted not to use some t
  static int send_num[8];
  static int recv_num[8];
 
  static constexpr int tag_offset = 1000;
 
  friend class Communicator_impl;
};
 
 
 
template<typename ALLOCATOR>
class Channel_impl {
 public:
  typedef typename Channel_communicator::element_type element_type;
  typedef ALLOCATOR                                   allocator_t;
  typedef std::vector<element_type, allocator_t>      container_type;
 
  Channel_impl() : m_buf(0), m_ptr(nullptr) { }                    
  //  Channel_impl(const int count) : m_buf(count), m_ptr(&m_buf[0]) { } //!< constructor with buffer size (count bytes)
  // use default destructor
  // virtual ~Channel_impl();       //!< destructor
 
  inline element_type& operator[](unsigned int idx) { return m_buf[idx]; }
  inline element_type operator[](unsigned int idx) const { return m_buf[idx]; }
  inline element_type *ptr() const { return m_ptr; }
 
  // communication
  int start() { return m_comm.start(); }  
  int wait() { return m_comm.wait(); }    
 
  int send_init(int count, int idir, int ipm)
  {
    m_buf.resize(count);
    m_ptr = &m_buf[0];
    return m_comm.send_init(count, idir, ipm, (void *)&m_buf[0]);
  }
 
  int recv_init(int count, int idir, int ipm)
  {
    m_buf.resize(count);
    m_ptr = &m_buf[0];
    return m_comm.recv_init(count, idir, ipm, (void *)&m_buf[0]);
  }
 
  MPI_Request& get_request() { return m_comm.get_request(); }
 
 private:
  container_type m_buf;        
  element_type *m_ptr;         
  Channel_communicator m_comm; 
};
 
 
// alias
template<typename T>
constexpr int alignment_size();
 
template<int ALIGNMENT>
using Channel_aligned = Channel_impl<aligned_allocator_impl<char, ALIGNMENT> >;
 
// instance with default allocator
using Cannel = Channel_impl<std::allocator<char> >;
 
 
 
class ChannelSet {
 public:
  ChannelSet(int nchannel = 8); 
 
  template<typename T>
  int append(Channel_impl<T>& c)   
  {
    return append(c.get_request());
  }
 
  int start();                  
  int wait();                   
 
 private:
  int append(const MPI_Request& r); 
 
  std::vector<MPI_Request> m_array; 
  std::vector<MPI_Status> m_status; 
  unsigned int m_nreq;              
};
#endif /* _CHANNEL_H_ */