havoqgt::mpi::high_edge_partitioner Class Reference

#include <edge_partitioner.hpp>

Public Member Functions
	high_edge_partitioner (int s, int r, std::map< uint64_t, std::deque< OverflowSendInfo >> *transfer_info)
int	operator() (std::pair< uint64_t, uint64_t > i, bool is_counting=true)

Private Attributes
const int	m_mpi_size
const int	m_mpi_rank
std::map< uint64_t, std::deque< OverflowSendInfo > > *	m_transfer_info

Detailed Description

Definition at line 119 of file edge_partitioner.hpp.

Constructor & Destructor Documentation

havoqgt::mpi::high_edge_partitioner::high_edge_partitioner ( int  s, int  r, std::map< uint64_t, std::deque< OverflowSendInfo >> *  transfer_info  )

inlineexplicit

Definition at line 121 of file edge_partitioner.hpp.

    : m_mpi_size(s)
    , m_mpi_rank(r)
    , m_transfer_info(transfer_info)
    /*, m_dof(dof)*/ { }

Member Function Documentation

int havoqgt::mpi::high_edge_partitioner::operator() ( std::pair< uint64_t, uint64_t >  i, bool  is_counting = true  )

inline

Determines where to send an edge. If the edge's destination is owned by another node, then the edge is sent to that node. Otherwise, it is sent to a node based on the transfer_info.

Parameters

is_counting

determines how to adjust the send_count variavles

Returns

the node to send the passed edge to.

Definition at line 136 of file edge_partitioner.hpp.

                                                                         {


    int dest = int(i.second % m_mpi_size);
    if (dest == m_mpi_rank) {
      // If the current node is the destination, then determine the destination
      // by examing the transfer_info object
      const uint64_t delegate_id = i.first;
      if (m_transfer_info->count(delegate_id) == 0) {
        return m_mpi_rank;
      }

      assert(m_transfer_info->at(delegate_id).size() > 0);

      if (is_counting) {
        // If it is counting then use the temp_to_send_count, which is reset
        // the next time this called with an edge with the same delegate_id and
        // is_counting is set to false.
        for (size_t j = 0; j < m_transfer_info->at(delegate_id).size(); j++) {
          if (m_transfer_info->at(delegate_id)[j].temp_to_send_count <
                m_transfer_info->at(delegate_id)[j].to_send_count) {
            (m_transfer_info->at(delegate_id)[j].temp_to_send_count)++;

            // If this has an edge to send, return the send_id
            return m_transfer_info->at(delegate_id)[j].to_send_id;
          }
        }
        return m_mpi_rank;
      } else {
        // Not counting, so update the edge counts
        dest = m_transfer_info->at(delegate_id).front().to_send_id;
        //m_dof->send_of_delegate(delegate_id, dest);

        const int to_send_count =
          m_transfer_info->at(delegate_id).front().to_send_count--;
        assert(m_transfer_info->at(delegate_id).front().to_send_count >= 0);

        // Cleanup, if no more edges for this destination then remove it.
        // If no more edges for this delaget remove it!
        if (m_transfer_info->at(delegate_id).front().to_send_count == 0) {
          m_transfer_info->at(delegate_id).pop_front();
          if (m_transfer_info->at(delegate_id).size() == 0) {
            m_transfer_info->erase(delegate_id);
          }
        } else {
          // Otherwise reset the temp variable
          m_transfer_info->at(delegate_id).front().temp_to_send_count = 0;
        }
      }  // else not counting

    } else {  // if dest == rank
      // m_dof->send_delegate(delegate_id, dest);
    }

    assert(dest >= 0);
    assert(dest != m_mpi_rank);
    return dest;
  }  // operator()

Member Data Documentation

const int havoqgt::mpi::high_edge_partitioner::m_mpi_rank

private

Definition at line 197 of file edge_partitioner.hpp.

const int havoqgt::mpi::high_edge_partitioner::m_mpi_size

private

Definition at line 196 of file edge_partitioner.hpp.

std::map<uint64_t, std::deque<OverflowSendInfo> >* havoqgt::mpi::high_edge_partitioner::m_transfer_info

private

Definition at line 198 of file edge_partitioner.hpp.

---

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

• include/havoqgt/impl/edge_partitioner.hpp