TIMPI::Request Class Reference

Encapsulates the MPI_Request. More...

#include <request.h>

Public Member Functions
	Request ()
	Request (const request &r)
	Request (const Request &other)
void	cleanup ()
Request &	operator= (const Request &other)
Request &	operator= (const request &r)
	~Request ()
request *	get ()
const request *	get () const
Status	wait ()
bool	test ()
bool	test (status &status)
void	add_prior_request (const Request &req)
void	add_post_wait_work (PostWaitWork *work)

Static Public Attributes
static const request	null_request = MPI_REQUEST_NULL

Private Attributes
request	_request
std::unique_ptr< Request >	_prior_request
std::pair< std::vector< PostWaitWork *>, unsigned int > *	post_wait_work

Friends
std::size_t	waitany (std::vector< Request > &)
	Wait for at least one non-blocking operation to finish. More...

Detailed Description

Encapsulates the MPI_Request.

Definition at line 67 of file request.h.

Constructor & Destructor Documentation

Request() [1/3]

TIMPI::Request::Request

(

)

Definition at line 48 of file request.C.

Referenced by add_prior_request(), operator=(), and Request().

                  :
  _request(null_request),
  post_wait_work(nullptr)
{}

Request() [2/3]

TIMPI::Request::Request

(

const request &

r

)

Definition at line 53 of file request.C.

                                   :
  _request(r),
  post_wait_work(nullptr)
{}

Request() [3/3]

TIMPI::Request::Request

(

const Request &

other

)

Definition at line 58 of file request.C.

References _prior_request, post_wait_work, and Request().

                                       :
  _request(other._request),
  post_wait_work(other.post_wait_work)
{
  if (other._prior_request.get())
    _prior_request = std::unique_ptr<Request>
      (new Request(*other._prior_request.get()));

  // operator= should behave like a shared pointer
  if (post_wait_work)
    post_wait_work->second++;
}

~Request()

TIMPI::Request::~Request

(

)

Definition at line 117 of file request.C.

References cleanup().

                   {
  this->cleanup();
}

Member Function Documentation

add_post_wait_work()

void TIMPI::Request::add_post_wait_work

(

PostWaitWork *

work

)

Definition at line 204 of file request.C.

References post_wait_work.

Referenced by TIMPI::Communicator::nonblocking_receive_packed_range(), TIMPI::Communicator::nonblocking_send_packed_range(), TIMPI::Communicator::possibly_receive(), TIMPI::Communicator::possibly_receive_packed_range(), TIMPI::Communicator::receive(), TIMPI::Communicator::send(), and TIMPI::Communicator::send_packed_range().

{
  if (!post_wait_work)
    post_wait_work = new
      std::pair<std::vector <PostWaitWork * >, unsigned int>
      (std::vector <PostWaitWork * >(), 1);
  post_wait_work->first.push_back(work);
}

add_prior_request()

void TIMPI::Request::add_prior_request

(

const Request &

req

)

Definition at line 190 of file request.C.

References _prior_request, and Request().

Referenced by TIMPI::Communicator::send_packed_range().

{
  // We're making a chain of prior requests, not a tree
  timpi_assert(!req._prior_request.get());

  Request * new_prior_req = new Request(req);

  // new_prior_req takes ownership of our existing _prior_request
  new_prior_req->_prior_request.reset(this->_prior_request.release());

  // Our _prior_request now manages the new resource we just set up
  this->_prior_request.reset(new_prior_req);
}

cleanup()

void TIMPI::Request::cleanup

(

)

Definition at line 71 of file request.C.

References post_wait_work.

Referenced by operator=(), and ~Request().

{
  if (post_wait_work)
    {
      // Decrement the use count
      post_wait_work->second--;

      if (!post_wait_work->second)
        {
#ifdef DEBUG
          // If we're done using this request, then we'd better have
          // done the work we waited for
          for (const auto & item : post_wait_work->first)
            timpi_assert(!item);
#endif
          delete post_wait_work;
          post_wait_work = nullptr;
        }
    }
}

get() [1/2]

request* TIMPI::Request::get ( )

inline

Definition at line 84 of file request.h.

References _request.

Referenced by TIMPI::Communicator::max(), TIMPI::Communicator::min(), TIMPI::Communicator::nonblocking_barrier(), TIMPI::Communicator::possibly_receive(), TIMPI::Communicator::receive(), TIMPI::Communicator::send(), TIMPI::Communicator::sum(), testNonblockingWaitany(), and TIMPI::waitany().

{ return &_request; }

get() [2/2]

const request* TIMPI::Request::get ( ) const

inline

Definition at line 86 of file request.h.

References _request.

{ return &_request; }

operator=() [1/2]

Request & TIMPI::Request::operator=

(

const Request &

other

)

Definition at line 92 of file request.C.

References _prior_request, _request, cleanup(), post_wait_work, and Request().

{
  this->cleanup();
  _request = other._request;
  post_wait_work = other.post_wait_work;

  if (other._prior_request.get())
    _prior_request = std::unique_ptr<Request>
      (new Request(*other._prior_request.get()));

  // operator= should behave like a shared pointer
  if (post_wait_work)
    post_wait_work->second++;

  return *this;
}

operator=() [2/2]

Request & TIMPI::Request::operator=

(

const request &

r

)

Definition at line 109 of file request.C.

References _request, cleanup(), and post_wait_work.

{
  this->cleanup();
  _request = r;
  post_wait_work = nullptr;
  return *this;
}

test() [1/2]

bool TIMPI::Request::test

(

)

Definition at line 153 of file request.C.

References _request, and null_request.

Referenced by TIMPI::detail::push_parallel_nbx_helper(), and testNonblockingTest().

{
#ifdef TIMPI_HAVE_MPI
  int val=0;

  timpi_call_mpi
    (MPI_Test (&_request, &val, MPI_STATUS_IGNORE));

  if (val)
    {
      timpi_assert          (_request == null_request);
      timpi_assert_equal_to (val, 1);
    }

  return val;
#else
  return true;
#endif
}

test() [2/2]

bool TIMPI::Request::test

(

status &

status

)

Definition at line 174 of file request.C.

References _request.

{
  int val=0;

  timpi_call_mpi
    (MPI_Test (&_request, &val, &stat));

  return val;
}

wait()

Status TIMPI::Request::wait

(

)

Definition at line 121 of file request.C.

References _prior_request, _request, and post_wait_work.

Referenced by TIMPI::detail::push_parallel_nbx_helper(), TIMPI::push_parallel_packed_range(), TIMPI::Communicator::send_receive_packed_range(), testNonblockingMax(), testNonblockingMin(), and TIMPI::wait().

{
  TIMPI_LOG_SCOPE("wait()", "Request");

  if (_prior_request.get())
    {
      _prior_request->wait();
      _prior_request.reset(nullptr);
    }

  Status stat {};
#ifdef TIMPI_HAVE_MPI
  timpi_call_mpi
    (MPI_Wait (&_request, stat.get()));
#endif
  if (post_wait_work)
    {
      for (auto & item : post_wait_work->first)
        {
          // The user should never try to give us non-existent work or try
          // to wait() twice.
          timpi_assert (item);
          item->run();
          delete item;
          item = nullptr;
        }
      post_wait_work->first.clear();
    }

  return stat;
}

Friends And Related Function Documentation

waitany

std::size_t waitany ( std::vector< Request > &  r )

friend

Wait for at least one non-blocking operation to finish.

Return the index of the request which completed.

Definition at line 219 of file request.C.

{
  timpi_assert(!r.empty());

  int r_size = cast_int<int>(r.size());
  std::vector<request> raw(r_size);
  int non_null = r_size;
  for (int i=0; i != r_size; ++i)
    {
      Request * root = &r[i];
      // If we have prior requests, we need to complete the first one
      // first
      while (root->_prior_request.get())
        root = root->_prior_request.get();
      raw[i] = *root->get();

      if (raw[i] != Request::null_request)
        non_null = std::min(non_null,i);
    }

  if (non_null == r_size)
    return std::size_t(-1);

  int index = non_null;

#ifdef TIMPI_HAVE_MPI
  bool only_priors_completed = false;
  Request * next;

  do
    {
      timpi_call_mpi
        (MPI_Waitany(r_size, raw.data(), &index, MPI_STATUS_IGNORE));

      timpi_assert_not_equal_to(index, MPI_UNDEFINED);

      timpi_assert_less(index, r_size);

      Request * completed = &r[index];
      next = completed;

      // If we completed a prior request, we're not really done yet,
      // so find the next in that line to try again.
      while (completed->_prior_request.get())
        {
          only_priors_completed = true;
          next = completed;
          completed = completed->_prior_request.get();
        }

      // MPI sets a completed MPI_Request to MPI_REQUEST_NULL; we want
      // to preserve that
      completed->_request = raw[index];

      // Do any post-wait work for the completed request
      if (completed->post_wait_work)
        for (auto & item : completed->post_wait_work->first)
          {
            // The user should never try to give us non-existent work or try
            // to wait() twice.
            timpi_assert (item);
            item->run();
            delete item;
            item = nullptr;
          }

      next->_prior_request.reset(nullptr);
      raw[index] = *next->get();

    } while(only_priors_completed);
#else
  r[index]._request = Request::null_request;
#endif

  return index;
}

Member Data Documentation

_prior_request

std::unique_ptr<Request> TIMPI::Request::_prior_request

private

Definition at line 116 of file request.h.

Referenced by add_prior_request(), operator=(), Request(), wait(), and TIMPI::waitany().

_request

request TIMPI::Request::_request

private

Definition at line 114 of file request.h.

Referenced by get(), operator=(), test(), wait(), and TIMPI::waitany().

null_request

const request TIMPI::Request::null_request = MPI_REQUEST_NULL

static

Definition at line 111 of file request.h.

Referenced by TIMPI::Communicator::max(), TIMPI::Communicator::min(), TIMPI::Communicator::sum(), test(), testNonblockingWaitany(), and TIMPI::waitany().

post_wait_work

std::pair<std::vector <PostWaitWork * >, unsigned int>* TIMPI::Request::post_wait_work

private

Definition at line 124 of file request.h.

Referenced by add_post_wait_work(), cleanup(), operator=(), Request(), wait(), and TIMPI::waitany().

---

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

• src/parallel/include/timpi/request.h
• src/parallel/src/request.C