havoqgt::mpi::mailbox_routed< TMsg > Class Template Reference

#include <mailbox.hpp>

Collaboration diagram for havoqgt::mpi::mailbox_routed< TMsg >:

Classes
class	msg_buffer
class	twod_router

Public Types
typedef TMsg	message_type

Public Member Functions
	mailbox_routed (MPI_Comm _mpi_comm, int _mpi_tag)
	~mailbox_routed ()
void	send_tree_fast (int raw_dest, const TMsg &_raw_msg)
void	send_tree_parent (const TMsg &_raw_msg)
void	send_tree_children (const TMsg &_raw_msg)
void	route_fast_path (uint32_t dest, const routed_msg_type &_msg)
template<typename OutputIterator >
void	bcast (TMsg _raw_msg, OutputIterator _oitr)
void	bcast_to_targets (TMsg _msg)
void	check_for_starvation ()
template<typename OutputIterator >
void	send (int raw_dest, const TMsg &_raw_msg, OutputIterator _oitr, bool fast=true)
template<typename OutputIterator >
void	receive (OutputIterator _oitr, bool aggregsive=false)
bool	is_idle ()
void	flush_buffers_if_idle ()
int	comm_rank () const
int	comm_size () const

Private Types
typedef TMsg	routed_msg_type

Private Member Functions
msg_buffer	allocate_msg_buffer ()
void	free_msg_buffer (void *_ptr)
void	post_isend (int index)
bool	cleanup_pending_isend_requests_index (size_t index)
void	cleanup_pending_isend_requests (bool force_aggressive=false)
void	post_new_irecv (void *_buff)

Private Attributes
MPI_Comm	m_mpi_comm
	MPI configuration. More...
int	m_mpi_tag
int	m_mpi_rank
int	m_mpi_size
size_t	m_pending_partial_buffers
size_t	m_num_pending_isend
size_t	m_last_recv_count
std::vector< void * >	m_vec_free_buffers
std::vector< msg_buffer >	m_buffer_per_rank
std::vector< std::list< boost::tuple< MPI_Request, void *, std::list< size_t >::iterator > > >	m_list_isend_request_per_rank
std::list< size_t >	m_list_isends
std::list< std::pair< MPI_Request, void * > >	m_list_irecv_request
twod_router	m_2d_comm
std::vector< std::list< size_t >::iterator >	m_pending_iterator_per_rank
std::list< size_t >	m_list_pending
int	m_tree_parent
int	m_tree_child1
int	m_tree_child2
bool	m_receiving
uint64_t	m_mpi_send_counter
uint64_t	m_tree_send_counter
uint64_t	m_route_counter
uint64_t	m_send_counter
uint64_t	m_recv_counter

Detailed Description

template<typename TMsg>
class havoqgt::mpi::mailbox_routed< TMsg >

Definition at line 75 of file mailbox.hpp.

Member Typedef Documentation

template<typename TMsg>

typedef TMsg havoqgt::mpi::mailbox_routed< TMsg >::message_type

Definition at line 158 of file mailbox.hpp.

template<typename TMsg>

typedef TMsg havoqgt::mpi::mailbox_routed< TMsg >::routed_msg_type

private

Definition at line 88 of file mailbox.hpp.

Constructor & Destructor Documentation

template<typename TMsg>

havoqgt::mpi::mailbox_routed< TMsg >::mailbox_routed ( MPI_Comm  _mpi_comm, int  _mpi_tag  )

inline

Definition at line 160 of file mailbox.hpp.

                               :
              m_mpi_comm(_mpi_comm),
              m_mpi_tag(_mpi_tag) {
    m_pending_partial_buffers = 0;
    m_num_pending_isend = 0;

    m_last_recv_count = 0;

    //statistics
    m_mpi_send_counter  = 0;
    m_tree_send_counter = 0;
    m_route_counter     = 0;
    m_send_counter      = 0;
    m_recv_counter      = 0;

    m_receiving = false;


    CHK_MPI(MPI_Comm_rank(m_mpi_comm, &m_mpi_rank) );
    CHK_MPI(MPI_Comm_size(m_mpi_comm, &m_mpi_size) );

    //Allocate buffer slots for each rank.
    //This does not acutally allocate the buffer's memory
    m_buffer_per_rank.resize(m_mpi_size);
    m_list_isend_request_per_rank.resize(m_mpi_size);
    m_pending_iterator_per_rank.resize(m_mpi_size,m_list_pending.end());


    for(size_t i=0; i<get_environment().mailbox_num_irecv(); ++i) {
      void* irecv_buff = NULL;
      int ret = posix_memalign(&irecv_buff, 32,
                     get_environment().mailbox_aggregation() * sizeof(routed_msg_type));
      if(ret !=0) {
        perror("posix_memalign-irecv"); exit(-1);
      }
      post_new_irecv(irecv_buff);
    }
    m_2d_comm = twod_router(m_mpi_rank, m_mpi_size);

    m_tree_parent = m_mpi_rank / 2;
    m_tree_child1 = (m_mpi_rank * 2) + 1;
    m_tree_child2 = (m_mpi_rank * 2) + 2;
  }

template<typename TMsg>

havoqgt::mpi::mailbox_routed< TMsg >::~mailbox_routed ( )

inline

Definition at line 205 of file mailbox.hpp.

                    {
    assert(m_pending_partial_buffers == 0);
    while(m_num_pending_isend > 0) {
      cleanup_pending_isend_requests(true);
    }
    while(!m_list_irecv_request.empty()) {
      CHK_MPI( MPI_Cancel( &(m_list_irecv_request.front().first) ) );
      free(m_list_irecv_request.front().second);
      m_list_irecv_request.pop_front();
    }
    for(size_t i=0; i<m_vec_free_buffers.size(); ++i) {
      free(m_vec_free_buffers[i]);
    }

    if(get_environment().mailbox_print_stats()) {
      uint64_t g_mpi_send_counter  = mpi_all_reduce(m_mpi_send_counter, std::plus<uint64_t>(), MPI_COMM_WORLD);
      uint64_t g_tree_send_counter = mpi_all_reduce(m_tree_send_counter, std::plus<uint64_t>(), MPI_COMM_WORLD);
      uint64_t g_route_counter     = mpi_all_reduce(m_route_counter, std::plus<uint64_t>(), MPI_COMM_WORLD);
      uint64_t g_send_counter      = mpi_all_reduce(m_send_counter, std::plus<uint64_t>(), MPI_COMM_WORLD);
      uint64_t g_recv_counter      = mpi_all_reduce(m_recv_counter, std::plus<uint64_t>(), MPI_COMM_WORLD);
      if(m_mpi_rank == 0) {
        std::cout << "******************  Mailbox Statistics ********************" << std::endl;
        std::cout << "routed message size = " << sizeof(TMsg) << std::endl;
        std::cout << "mpi_send_counter  = " << g_mpi_send_counter  << std::endl;
        std::cout << "tree_send_counter = " << g_tree_send_counter << std::endl;
        std::cout << "route_counter     = " << g_route_counter     << std::endl;
        std::cout << "send_counter      = " << g_send_counter      << std::endl;
        std::cout << "recv_counter      = " << g_recv_counter      << std::endl;
        std::cout << "Average send size = " << double(g_send_counter + g_route_counter) / double(g_mpi_send_counter) << std::endl;
        std::cout << "***********************************************************" << std::endl;
      }
    }

    CHK_MPI( MPI_Barrier( m_mpi_comm ) );
  }

Member Function Documentation

template<typename TMsg>

msg_buffer havoqgt::mpi::mailbox_routed< TMsg >::allocate_msg_buffer ( )

inlineprivate

Definition at line 424 of file mailbox.hpp.

                                   {
    if(m_vec_free_buffers.empty()) {
      void* buff = NULL;
      int ret = posix_memalign(&buff, 32,
                      get_environment().mailbox_aggregation() * sizeof(routed_msg_type));
      if(ret !=0) {
        perror("posix_memalign"); exit(-1);
      }
      m_vec_free_buffers.push_back(buff);
    }
    msg_buffer to_return(m_vec_free_buffers.back());
    m_vec_free_buffers.pop_back();
    return to_return;
  }

Here is the caller graph for this function:

template<typename TMsg>

template<typename OutputIterator >

void havoqgt::mpi::mailbox_routed< TMsg >::bcast ( TMsg  _raw_msg, OutputIterator  _oitr  )

inline

Definition at line 288 of file mailbox.hpp.

                                                  {
    assert(_raw_msg.get_bcast());
    _raw_msg.set_dest(m_mpi_size+1);
    for(uint32_t i=0; i<m_2d_comm.bcast_proxies().size(); ++i) {
      uint32_t proxy_rank = m_2d_comm.bcast_proxies()[i];
      if(proxy_rank == uint32_t(m_mpi_rank)) {
        bcast_to_targets(_raw_msg);
      } else {
        route_fast_path(proxy_rank, _raw_msg);
      }
    }
    if(m_receiving) return;   //prevent receive recursion @todo, make this a function called wait
    do {
      cleanup_pending_isend_requests();
      receive(_oitr);
    } while(m_num_pending_isend > get_environment().mailbox_num_isend());
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::bcast_to_targets ( TMsg  _msg )

inline

Definition at line 306 of file mailbox.hpp.

                                   {
    assert(_msg.get_bcast());
    for(uint32_t i=0; i<m_2d_comm.bcast_targets().size(); ++i) {
      uint32_t target = m_2d_comm.bcast_targets()[i];
      _msg.set_dest(target);
      route_fast_path(target, _msg);
    }
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::check_for_starvation ( )

inline

Definition at line 318 of file mailbox.hpp.

                              {
    /*if(!m_list_pending.empty()) {
      size_t to_check = m_list_pending.front();
      size_t size = m_send_ticket_per_rank.size();
      //size_t to_check = ++m_fair_checker % size;
      if(m_send_counter > m_send_ticket_per_rank[to_check] + size) {
        post_isend(to_check);
      }
    }*/
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::cleanup_pending_isend_requests ( bool  force_aggressive = false )

inlineprivate

If the number of current pending isends is less than user desired, just check the next fair bit. If the number is greater than desired, aggregsively check all bits.

Definition at line 504 of file mailbox.hpp.

                                                                     {
    while(!m_list_isends.empty()) {
      bool found = cleanup_pending_isend_requests_index(m_list_isends.front());
      if(!found) break;
    }
  }

Here is the caller graph for this function:

template<typename TMsg>

bool havoqgt::mpi::mailbox_routed< TMsg >::cleanup_pending_isend_requests_index ( size_t  index )

inlineprivate

Definition at line 481 of file mailbox.hpp.

                                                          {
    bool to_return = false;
    if(m_list_isend_request_per_rank[index].empty()) return true;
    while(!m_list_isend_request_per_rank[index].empty()) {
      int flag(0);
      MPI_Request* request_ptr = &(m_list_isend_request_per_rank[index].front().get<0>());
      CHK_MPI( MPI_Test( request_ptr, &flag, MPI_STATUS_IGNORE) );
      if(flag) {
        free_msg_buffer(m_list_isend_request_per_rank[index].front().get<1>());
        m_list_isends.erase(m_list_isend_request_per_rank[index].front().get<2>());
        m_list_isend_request_per_rank[index].pop_front();
        --m_num_pending_isend;
        to_return = true;
      } else {
        break;
      }
    }
    return to_return;
  }

Here is the caller graph for this function:

template<typename TMsg>

int havoqgt::mpi::mailbox_routed< TMsg >::comm_rank ( ) const

inline

Definition at line 419 of file mailbox.hpp.

{ return m_mpi_rank; }

Here is the caller graph for this function:

template<typename TMsg>

int havoqgt::mpi::mailbox_routed< TMsg >::comm_size ( ) const

inline

Definition at line 420 of file mailbox.hpp.

{ return m_mpi_size; }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::flush_buffers_if_idle ( )

inline

Definition at line 410 of file mailbox.hpp.

                               {
    if(!m_list_pending.empty()) {
      size_t index = m_list_pending.front();
      if(m_num_pending_isend < 1 && !m_buffer_per_rank[index].empty()) {
        post_isend(index);
      }
    }
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::free_msg_buffer ( void *  _ptr )

inlineprivate

Definition at line 439 of file mailbox.hpp.

                                   {
    m_vec_free_buffers.push_back(_ptr);
  }

Here is the caller graph for this function:

template<typename TMsg>

bool havoqgt::mpi::mailbox_routed< TMsg >::is_idle ( )

inline

Definition at line 405 of file mailbox.hpp.

                 {
    cleanup_pending_isend_requests();
    return m_pending_partial_buffers == 0 && m_num_pending_isend == 0;
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::post_isend ( int  index )

inlineprivate

Definition at line 443 of file mailbox.hpp.

                             {
    if(m_buffer_per_rank[index].empty()) return;
    m_mpi_send_counter++;
    int dest = index;
    bool was_first_pending = false;
    if(m_pending_iterator_per_rank[dest] != m_list_pending.end()) {
      if(m_pending_iterator_per_rank[dest] == m_list_pending.begin()) {
        was_first_pending = true;
      }
      m_list_pending.erase(m_pending_iterator_per_rank[dest]);
      m_pending_iterator_per_rank[dest] = m_list_pending.end();
    }

    m_list_isends.push_back(index);
    boost::tuple<MPI_Request, void*,std::list<size_t>::iterator> isend_req_tuple;
    MPI_Request* request_ptr = &(isend_req_tuple.get<0>());
    isend_req_tuple.get<1>() = m_buffer_per_rank[index].get_ptr();
    isend_req_tuple.get<2>() = --m_list_isends.end();
    void* buffer_ptr = m_buffer_per_rank[index].get_ptr();
    int size_in_bytes = m_buffer_per_rank[index].size_in_bytes();

    CHK_MPI( MPI_Isend( buffer_ptr, size_in_bytes, MPI_BYTE, dest,
                        m_mpi_tag, m_mpi_comm, request_ptr) );

    --m_pending_partial_buffers;
    m_buffer_per_rank[index].clear();
    //int flag(0);
    //CHK_MPI( MPI_Test( request_ptr, &flag, MPI_STATUS_IGNORE) );
    //if(!flag) {
    m_list_isend_request_per_rank[index].push_back(isend_req_tuple);
    ++m_num_pending_isend;
    //}
    cleanup_pending_isend_requests();
    if(!was_first_pending/* && m_tree_parent != index && m_tree_child1 != index && m_tree_child2 != index*/) {
      post_isend(m_list_pending.front());
    }
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::post_new_irecv ( void *  _buff )

inlineprivate

Definition at line 511 of file mailbox.hpp.

                                   {
    std::pair<MPI_Request, void*> irecv_req;
    irecv_req.second = _buff;
    MPI_Request* request_ptr = &(irecv_req.first);
    int num_bytes = get_environment().mailbox_aggregation() * sizeof(routed_msg_type);
    CHK_MPI( MPI_Irecv( _buff, num_bytes, MPI_BYTE, MPI_ANY_SOURCE,
                        m_mpi_tag, m_mpi_comm, request_ptr) );
    m_list_irecv_request.push_back(irecv_req);
  }

Here is the caller graph for this function:

template<typename TMsg>

template<typename OutputIterator >

void havoqgt::mpi::mailbox_routed< TMsg >::receive ( OutputIterator  _oitr, bool  aggregsive = false  )

inline

Definition at line 364 of file mailbox.hpp.

                                                            {
    m_receiving = true;
    m_last_recv_count = 0;
    int flag(0);
    //do {
      if(!m_list_irecv_request.empty()) {
        std::pair<MPI_Request, void* > pair_req = m_list_irecv_request.front();
        m_list_irecv_request.pop_front();
        MPI_Request* request_ptr = &(pair_req.first);
        MPI_Status status;
        CHK_MPI( MPI_Test( request_ptr, &flag, &status) );
        if(flag) {
          routed_msg_type* recv_ptr = static_cast<routed_msg_type*> (
                           pair_req.second );
          int count(0);
          CHK_MPI( MPI_Get_count(&status, MPI_BYTE, &count) );
          for(size_t i=0; i<count/sizeof(routed_msg_type); ++i) {
            if(recv_ptr[i].dest() == uint32_t(m_mpi_rank) /*|| recv_ptr[i].is_tree_op()*/) {
              *_oitr = recv_ptr[i];//.msg;
              ++_oitr;
              ++m_recv_counter;
            } else if(recv_ptr[i].get_bcast()) {
              bcast_to_targets(recv_ptr[i]);
            } else if(recv_ptr[i].is_intercept()) {
              if( _oitr.intercept(recv_ptr[i]) ) {
                route_fast_path(recv_ptr[i].dest(), recv_ptr[i]);
              }
            } else {
              route_fast_path(recv_ptr[i].dest(), recv_ptr[i]);
            }
          }
          post_new_irecv(recv_ptr);
        } else {
          m_list_irecv_request.push_front(pair_req);
        }
      }
    //} while(flag);
    m_receiving = false;
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::route_fast_path ( uint32_t  dest, const routed_msg_type &  _msg  )

inline

Definition at line 271 of file mailbox.hpp.

                                                                   {
    ++m_route_counter;
    if(!m_buffer_per_rank[dest].is_init()) {
      m_buffer_per_rank[dest] = allocate_msg_buffer();
      ++m_pending_partial_buffers;
      m_list_pending.push_back(dest);
      m_pending_iterator_per_rank[dest] = --m_list_pending.end();
    }
    size_t size = m_buffer_per_rank[dest].push_back(_msg);

    if(size == get_environment().mailbox_aggregation() ) {
      post_isend(dest);
      check_for_starvation();
    }
  }

Here is the caller graph for this function:

template<typename TMsg>

template<typename OutputIterator >

void havoqgt::mpi::mailbox_routed< TMsg >::send ( int  raw_dest, const TMsg &  _raw_msg, OutputIterator  _oitr, bool  fast = true  )

inline

Definition at line 330 of file mailbox.hpp.

                                                                                      {
    ++m_send_counter;
    assert(raw_dest >= 0 && raw_dest < m_mpi_size);
    //++m_last_recv_count;
    assert(raw_dest != m_mpi_rank); // just dont send to self!
    //routed_msg_type msg(raw_dest, _raw_msg);
    routed_msg_type msg = _raw_msg; //@todo fixme
    int dest = m_2d_comm.proxy_rank(raw_dest);
    if(dest == m_mpi_rank) dest = raw_dest;
    if(!m_buffer_per_rank[dest].is_init()) {
      m_buffer_per_rank[dest] = allocate_msg_buffer();
      ++m_pending_partial_buffers;
      m_list_pending.push_back(dest);
      m_pending_iterator_per_rank[dest] = --m_list_pending.end();
    }
    size_t size = m_buffer_per_rank[dest].push_back(msg);

    if(size == get_environment().mailbox_aggregation() ) {
      post_isend(dest);
      check_for_starvation();
      if(m_receiving) return;   //prevent receive recursion
      do {
        //cleanup_pending_isend_requests_index(dest);
        cleanup_pending_isend_requests();
        receive(_oitr);
      //} while(m_list_isend_request_per_rank[dest].size() > 1);
      } while(m_num_pending_isend > get_environment().mailbox_num_isend());
    }
    //if(m_last_recv_count > 128) {
    //  receive(_oitr);
    //}
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::send_tree_children ( const TMsg &  _raw_msg )

inline

Definition at line 262 of file mailbox.hpp.

                                                {
    if(m_tree_child1 < m_mpi_size) {
      send_tree_fast(m_tree_child1, _raw_msg);
      if(m_tree_child2 < m_mpi_size) {
        send_tree_fast(m_tree_child2, _raw_msg);
      }
    }
  }

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::send_tree_fast ( int  raw_dest, const TMsg &  _raw_msg  )

inline

Definition at line 241 of file mailbox.hpp.

                                                          {
    ++m_tree_send_counter;
    routed_msg_type msg(raw_dest, _raw_msg);
    if(!m_buffer_per_rank[raw_dest].is_init()) {
      m_buffer_per_rank[raw_dest] = allocate_msg_buffer();
      ++m_pending_partial_buffers;
      m_list_pending.push_back(raw_dest);
      m_pending_iterator_per_rank[raw_dest] = --m_list_pending.end();
    }
    size_t size = m_buffer_per_rank[raw_dest].push_back(msg);

    if(size >= get_environment().mailbox_tree_aggregation() ) {
      post_isend(raw_dest);
      check_for_starvation();
    }
  }

Here is the caller graph for this function:

template<typename TMsg>

void havoqgt::mpi::mailbox_routed< TMsg >::send_tree_parent ( const TMsg &  _raw_msg )

inline

Definition at line 258 of file mailbox.hpp.

                                              {
    send_tree_fast(m_tree_parent, _raw_msg);
  }

Member Data Documentation

template<typename TMsg>

twod_router havoqgt::mpi::mailbox_routed< TMsg >::m_2d_comm

private

Definition at line 541 of file mailbox.hpp.

template<typename TMsg>

std::vector<msg_buffer> havoqgt::mpi::mailbox_routed< TMsg >::m_buffer_per_rank

private

Definition at line 533 of file mailbox.hpp.

template<typename TMsg>

size_t havoqgt::mpi::mailbox_routed< TMsg >::m_last_recv_count

private

Definition at line 530 of file mailbox.hpp.

template<typename TMsg>

std::list< std::pair<MPI_Request, void*> > havoqgt::mpi::mailbox_routed< TMsg >::m_list_irecv_request

private

Definition at line 539 of file mailbox.hpp.

template<typename TMsg>

std::vector< std::list< boost::tuple<MPI_Request, void*, std::list<size_t>::iterator > > > havoqgt::mpi::mailbox_routed< TMsg >::m_list_isend_request_per_rank

private

Definition at line 536 of file mailbox.hpp.

template<typename TMsg>

std::list<size_t> havoqgt::mpi::mailbox_routed< TMsg >::m_list_isends

private

Definition at line 538 of file mailbox.hpp.

template<typename TMsg>

std::list<size_t> havoqgt::mpi::mailbox_routed< TMsg >::m_list_pending

private

Definition at line 545 of file mailbox.hpp.

template<typename TMsg>

MPI_Comm havoqgt::mpi::mailbox_routed< TMsg >::m_mpi_comm

private

MPI configuration.

Definition at line 523 of file mailbox.hpp.

template<typename TMsg>

int havoqgt::mpi::mailbox_routed< TMsg >::m_mpi_rank

private

Definition at line 525 of file mailbox.hpp.

template<typename TMsg>

uint64_t havoqgt::mpi::mailbox_routed< TMsg >::m_mpi_send_counter

private

Definition at line 554 of file mailbox.hpp.

template<typename TMsg>

int havoqgt::mpi::mailbox_routed< TMsg >::m_mpi_size

private

Definition at line 526 of file mailbox.hpp.

template<typename TMsg>

int havoqgt::mpi::mailbox_routed< TMsg >::m_mpi_tag

private

Definition at line 524 of file mailbox.hpp.

template<typename TMsg>

size_t havoqgt::mpi::mailbox_routed< TMsg >::m_num_pending_isend

private

Definition at line 529 of file mailbox.hpp.

template<typename TMsg>

std::vector< std::list<size_t>::iterator > havoqgt::mpi::mailbox_routed< TMsg >::m_pending_iterator_per_rank

private

Definition at line 543 of file mailbox.hpp.

template<typename TMsg>

size_t havoqgt::mpi::mailbox_routed< TMsg >::m_pending_partial_buffers

private

Definition at line 528 of file mailbox.hpp.

template<typename TMsg>

bool havoqgt::mpi::mailbox_routed< TMsg >::m_receiving

private

Definition at line 551 of file mailbox.hpp.

template<typename TMsg>

uint64_t havoqgt::mpi::mailbox_routed< TMsg >::m_recv_counter

private

Definition at line 558 of file mailbox.hpp.

template<typename TMsg>

uint64_t havoqgt::mpi::mailbox_routed< TMsg >::m_route_counter

private

Definition at line 556 of file mailbox.hpp.

template<typename TMsg>

uint64_t havoqgt::mpi::mailbox_routed< TMsg >::m_send_counter

private

Definition at line 557 of file mailbox.hpp.

template<typename TMsg>

int havoqgt::mpi::mailbox_routed< TMsg >::m_tree_child1

private

Definition at line 548 of file mailbox.hpp.

template<typename TMsg>

int havoqgt::mpi::mailbox_routed< TMsg >::m_tree_child2

private

Definition at line 549 of file mailbox.hpp.

template<typename TMsg>

int havoqgt::mpi::mailbox_routed< TMsg >::m_tree_parent

private

Definition at line 547 of file mailbox.hpp.

template<typename TMsg>

uint64_t havoqgt::mpi::mailbox_routed< TMsg >::m_tree_send_counter

private

Definition at line 555 of file mailbox.hpp.

template<typename TMsg>

std::vector<void*> havoqgt::mpi::mailbox_routed< TMsg >::m_vec_free_buffers

private

Definition at line 532 of file mailbox.hpp.

---

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

• include/havoqgt/mailbox.hpp