channel.h

Go to the documentation of this file.

#ifndef CHANNEL_INCLUDED
#define CHANNEL_INCLUDED

#include "configure.h"
#include "defs.h"

#include <cstdio>
#include <valarray>
#include <vector>
#include <cassert>

#include "communicator.h"

static const int max_dimension = 4;

class Channel {
 public:
  typedef char                          element_type;
  typedef std::valarray<element_type>   container_type;
  enum channel_mode { SEND, RECV };
 private:

  /*
  element_type* m_buf;
  //  container_type m_buf;
  static std::vector<container_type> m_buf_send;
  static std::vector<container_type> m_buf_recv;
  */
  static std::vector<container_type> m_buf;
  int m_count;
  int m_ibuf;

  struct bgnet_IDs
  {
    int fifoID;
    int sendBufID;
    int sendOffset;
    int size;
    int destRank;
    int groupID;
    int recvBufID;
    int recvOffset;
    int counterID;
  };

  bgnet_IDs                m_bgnet_ids;
  std::valarray<bgnet_IDs> m_bgnet_ids_thread;

  static int m_set_id;  

 public:

  Channel();
  Channel(const int count);
  Channel(const int count, const int tag, const channel_mode mode);
  virtual ~Channel();

  int start();
  int wait();

  static void increment_channel_set_id();

  void set_thread(int, const std::valarray<int>&,
                  const std::valarray<int>&, const std::valarray<int>&);
  int start_thread(int);
  int wait_thread(int);

  inline element_type& operator[](unsigned int idx)
  {
    return m_buf[m_ibuf][idx];
  }

  //  inline element_type operator[] (unsigned int idx) const { return m_buf[idx]; }

  inline const element_type *ptr()
  {
    return &m_buf[m_ibuf][0];
  }

  inline const element_type *ptr(int offset)
  {
    return &m_buf[m_ibuf][offset];
  }

  friend class Communicator_impl;
};

#endif /* CHANNEL_INCLUDED */