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 <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);
 
 private:
  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)
  //  Channel_impl(void *buf)
  //    : m_buf(0),
  //    m_ptr(reinterpret_cast<element_type *>(buf))
  //  { }
 
  // use default destructor
  // ~Channel_impl();       //!< destructor
 
  inline element_type& operator[](unsigned int idx) { return m_ptr[idx]; }
  inline element_type operator[](unsigned int idx) const { return m_ptr[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_ptr);
  }
 
  int send_init(int count, int idir, int ipm, void *buf)
  {
    m_ptr = (element_type *)buf;
    return 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_ptr);
  }
 
  int recv_init(int count, int idir, int ipm, void *buf)
  {
    m_ptr = (element_type *)buf;
    return 0;
  }
 
 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();
  }
 
  int start();                  
  int wait();                   
 
 private:
  int append(); 
};
#endif /* _CHANNEL_H_ */