TIMPI Namespace Reference

Namespaces
	detail

Classes
struct	Attributes
struct	BuildStandardTypeVector
struct	BuildStandardTypeVector< 0 >
struct	casting_compare
struct	CheckAllFixedTypes
struct	CheckAllFixedTypes< Head >
class	Communicator
	Encapsulates the MPI_Comm object. More...
struct	data_type
class	DataPlusInt
	Types combined with an int. More...
class	DataType
	Encapsulates the MPI_Datatype. More...
struct	FillDisplacementArray
struct	FillDisplacementArray< 0 >
struct	InnermostType
struct	InnermostType< std::list< T, A > >
struct	InnermostType< std::map< K, T, C, A > >
struct	InnermostType< std::multimap< K, T, C, A > >
struct	InnermostType< std::multiset< T, C, A > >
struct	InnermostType< std::set< T, C, A > >
struct	InnermostType< std::unordered_map< K, T, C, A > >
struct	InnermostType< std::unordered_multimap< K, T, C, A > >
struct	InnermostType< std::unordered_multiset< T, C, A > >
struct	InnermostType< std::unordered_set< T, C, A > >
struct	InnermostType< std::vector< T, A > >
class	ManageOp
class	ManageType
struct	MaybeADataType
struct	MaybeADataType< false >
class	MessageTag
	Encapsulates the MPI tag integers. More...
class	NotADataType
	StandardType<T>'s which do not define a way to MPI_Type T should inherit from this class. More...
class	OpFunction
	Templated class to provide the appropriate MPI reduction operations for use with built-in C types or simple C++ constructions. More...
class	OpFunction< std::pair< T, U > >
class	OpFunction< TIMPI_DEFAULT_SCALAR_TYPE >
struct	PostWaitCopyBuffer
struct	PostWaitDeleteBuffer
struct	PostWaitDereferenceSharedPtr
struct	PostWaitDereferenceTag
struct	PostWaitFreeBuffer
struct	PostWaitUnpackBuffer
struct	PostWaitUnpackNestedBuffer
struct	PostWaitWork
	An abstract base class that can be subclassed to allow other code to perform work after a MPI_Wait succeeds. More...
class	Request
	Encapsulates the MPI_Request. More...
class	SemiPermanent
	The SemiPermanent "class" is basically just a place for a destructor vtable. More...
class	StandardType
	Templated class to provide the appropriate MPI datatype for use with built-in C types or simple C++ constructions. More...
class	StandardType< std::array< T, N >, typename std::enable_if< StandardType< T >::is_fixed_type >::type >
class	StandardType< std::complex< T > >
class	StandardType< std::pair< T1, T2 >, typename std::enable_if< StandardType< typename std::remove_const< T1 >::type >::is_fixed_type &&StandardType< T2 >::is_fixed_type >::type >
class	StandardType< std::set< T > >
class	StandardType< std::tuple< Types... >, typename std::enable_if< CheckAllFixedTypes< Types... >::is_fixed_type >::type >
class	StandardType< TIMPI_DEFAULT_SCALAR_TYPE >
struct	standardtype_dependent_false
class	Status
	Encapsulates the MPI_Status struct. More...
struct	status
class	TIMPIInit
	The TIMPIInit class, when constructed, initializes any dependent libraries (e.g. More...

Typedefs
typedef uint8_t	processor_id_type
typedef MPI_Info	info
	Info object used by some MPI-3 methods. More...
typedef MPI_Datatype	data_type
	Data types for communication. More...
typedef MPI_Aint	DispType
typedef MPI_Request	request
	Request object for non-blocking I/O. More...
typedef MPI_Status	status
	Status object for querying messages. More...
typedef MPI_Count	CountType

Functions
template<typename datum , typename MapToVectors , typename GatherFunctor , typename ActionFunctor >
void	pull_parallel_vector_data (const Communicator &comm, const MapToVectors &queries, GatherFunctor &gather_data, const ActionFunctor &act_on_data, const datum *example)
	Send query vectors, receive and answer them with vectors of data, then act on those answers. More...
template<typename datum , typename A , typename MapToVectors , typename GatherFunctor , typename ActionFunctor >
void	pull_parallel_vector_data (const Communicator &comm, const MapToVectors &queries, GatherFunctor &gather_data, ActionFunctor &act_on_data, const std::vector< datum, A > *example)
template<typename MapToContainers , typename ActionFunctor , typename Context >
void	push_parallel_packed_range (const Communicator &comm, MapToContainers &&data, Context *context, const ActionFunctor &act_on_data)
template<typename datum , typename MapToVectors , typename GatherFunctor , typename ActionFunctor >
void	pull_parallel_vector_data (const Communicator &comm, const MapToVectors &queries, GatherFunctor &gather_data, ActionFunctor &act_on_data, const datum *)
	TIMPI_INT_TYPE (char)
	TIMPI_INT_TYPE (signed char)
	TIMPI_INT_TYPE (unsigned char)
	TIMPI_INT_TYPE (short int)
	TIMPI_INT_TYPE (unsigned short int)
	TIMPI_INT_TYPE (int)
	TIMPI_INT_TYPE (long)
	TIMPI_INT_TYPE (unsigned long long)
	TIMPI_FLOAT_TYPE (float)
	TIMPI_FLOAT_TYPE (double)
	TIMPI_FLOAT_TYPE (long double)
	TIMPI_FLOAT_TYPE (TIMPI_DEFAULT_SCALAR_TYPE)
template<typename T , typename C , typename A >
	TIMPI_CONTAINER_TYPE (std::set< T TIMPI_ATTRIBUTES_COMMA C TIMPI_ATTRIBUTES_COMMA A >)
template<typename T , typename A >
	TIMPI_CONTAINER_TYPE (std::vector< T TIMPI_ATTRIBUTES_COMMA A >)
	TIMPI_PARALLEL_INTEGER_OPS (char)
	TIMPI_PARALLEL_INTEGER_OPS (signed char)
	TIMPI_PARALLEL_INTEGER_OPS (unsigned char)
	TIMPI_PARALLEL_INTEGER_OPS (short int)
	TIMPI_PARALLEL_INTEGER_OPS (unsigned short int)
	TIMPI_PARALLEL_INTEGER_OPS (int)
	TIMPI_PARALLEL_INTEGER_OPS (long)
	TIMPI_PARALLEL_INTEGER_OPS (unsigned long long)
	TIMPI_PARALLEL_FLOAT_OPS (float)
	TIMPI_PARALLEL_FLOAT_OPS (double)
	TIMPI_PARALLEL_FLOAT_OPS (long double)
	TIMPI_PARALLEL_FLOAT_OPS (TIMPI_DEFAULT_SCALAR_TYPE)
template<typename Context , typename Iter >
std::size_t	packed_range_size (const Context *context, Iter range_begin, const Iter range_end)
	Helper function for range packing. More...
template<typename Context , typename buffertype , typename Iter >
Iter	pack_range (const Context *context, Iter range_begin, const Iter range_end, std::vector< buffertype > &buffer, std::size_t approx_buffer_size)
	Helper function for range packing. More...
template<typename Context , typename buffertype , typename OutputIter , typename T >
OutputIter	unpack_range (const std::vector< buffertype > &buffer, Context *context, OutputIter out_iter, const T *)
	Helper function for range unpacking. More...
template<typename Context , typename buffertype , typename OutputIter , typename T >
OutputIter	unpack_range (const typename std::vector< buffertype > &buffer, Context *context, OutputIter out_iter, const T *output_type)
	Decode a range of potentially-variable-size objects from a data array. More...
template<typename T >
data_type	dataplusint_type ()
	Templated function to return the appropriate MPI datatype for use with built-in C types when combined with an int, or MPI_DATATYPE_NULL for types which have no predefined datatype. More...
template<>
data_type	dataplusint_type< short int > ()
template<>
data_type	dataplusint_type< int > ()
template<>
data_type	dataplusint_type< long > ()
template<>
data_type	dataplusint_type< float > ()
template<>
data_type	dataplusint_type< double > ()
template<>
data_type	dataplusint_type< long double > ()
template<typename T >
std::pair< data_type, std::unique_ptr< StandardType< std::pair< T, int > > > >	dataplusint_type_acquire ()
Status	wait (Request &r)
	Wait for a non-blocking send or receive to finish. More...
void	wait (std::vector< Request > &r)
	Wait for all non-blocking operations to finish. More...
std::size_t	waitany (std::vector< Request > &r)
	Wait for at least one non-blocking operation to finish. More...
template<typename T >
StandardType< T >	build_standard_type (const T *example=nullptr)
template<typename T , typename A >
StandardType< typename InnermostType< T >::type >	build_standard_type (const std::vector< T, A > *example=nullptr)
	TIMPI_STANDARD_TYPE (char, MPI_CHAR)
	TIMPI_STANDARD_TYPE (signed char, MPI_SIGNED_CHAR)
	TIMPI_STANDARD_TYPE (unsigned char, MPI_UNSIGNED_CHAR)
	TIMPI_STANDARD_TYPE (short int, MPI_SHORT)
	TIMPI_STANDARD_TYPE (unsigned short int, MPI_UNSIGNED_SHORT)
	TIMPI_STANDARD_TYPE (int, MPI_INT)
	TIMPI_STANDARD_TYPE (unsigned int, MPI_UNSIGNED)
	TIMPI_STANDARD_TYPE (long, MPI_LONG)
	TIMPI_STANDARD_TYPE (long long, MPI_LONG_LONG_INT)
	TIMPI_STANDARD_TYPE (unsigned long, MPI_UNSIGNED_LONG)
	TIMPI_STANDARD_TYPE (unsigned long long, MPI_UNSIGNED_LONG_LONG)
	TIMPI_STANDARD_TYPE (float, MPI_FLOAT)
	TIMPI_STANDARD_TYPE (double, MPI_DOUBLE)
	TIMPI_STANDARD_TYPE (long double, MPI_LONG_DOUBLE)
	TIMPI_STANDARD_TYPE (TIMPI_DEFAULT_SCALAR_TYPE,)
void	report_here (const char *file, int line, const char *date, const char *time)
void	report_error (const char *file, int line, const char *date, const char *time)
template<class ... Args>
void	ignore (const Args &...)
template<class ... Args>
void	timpi_ignore (const Args &...)
template<typename Tnew , typename Told >
Tnew	cast_int (Told oldvar)
void	timpi_version_stdout ()
std::string	timpi_version_string ()
int	get_timpi_version ()
template<typename MapToVectors , typename ActionFunctor , typename std::enable_if< std::is_base_of< DataType, StandardType< typename InnermostType< typename std::remove_const< typename std::remove_reference< MapToVectors >::type::mapped_type::value_type >::type >::type >>::value, int >::type = 0>
void	push_parallel_vector_data (const Communicator &comm, MapToVectors &&data, const ActionFunctor &act_on_data)
	Send and receive and act on vectors of data. More...
template<typename MapToVectors , typename ActionFunctor , typename Context >
void	push_parallel_packed_range (const Communicator &comm, MapToVectors &&data, Context *context, const ActionFunctor &act_on_data)
	Send and receive and act on vectors of data. More...

Variables
DIE A HORRIBLE DEATH HERE typedef MPI_Comm	communicator
	Communicator object for talking with subsets of processors. More...
const unsigned int	any_source
	Processor id meaning "Accept from any source". More...
const MessageTag	any_tag = MessageTag(MPI_ANY_TAG)
	Default message tag ids. More...
const MessageTag	no_tag = MessageTag(0)

Typedef Documentation

CountType

typedef int TIMPI::CountType

Definition at line 47 of file status.h.

data_type

typedef MPI_Datatype TIMPI::data_type

Data types for communication.

Definition at line 33 of file data_type.h.

DispType

typedef int TIMPI::DispType

Definition at line 216 of file parallel_implementation.h.

info

typedef int TIMPI::info

Info object used by some MPI-3 methods.

Definition at line 79 of file communicator.h.

processor_id_type

typedef uint64_t TIMPI::processor_id_type

Definition at line 54 of file communicator.h.

request

typedef unsigned int TIMPI::request

Request object for non-blocking I/O.

Definition at line 41 of file request.h.

status

typedef MPI_Status TIMPI::status

Status object for querying messages.

Definition at line 44 of file status.h.

Function Documentation

build_standard_type() [1/2]

template<typename T >

StandardType<T> TIMPI::build_standard_type

(

const T *

example = nullptr

)

Definition at line 181 of file standard_type.h.

Referenced by build_standard_type(), and push_parallel_vector_data().

{
  StandardType<T> returnval(example);
  return returnval;
}

build_standard_type() [2/2]

template<typename T , typename A >

StandardType<typename InnermostType<T>::type> TIMPI::build_standard_type

(

const std::vector< T, A > *

example = nullptr

)

Definition at line 195 of file standard_type.h.

References build_standard_type().

{
  const T * inner_example = (example && !example->empty()) ? &(*example)[0] : nullptr;
  return build_standard_type(inner_example);
}

cast_int()

template<typename Tnew , typename Told >

Tnew TIMPI::cast_int ( Told  oldvar )

inline

Definition at line 297 of file timpi_assert.h.

{
  timpi_assert_equal_to
    (oldvar, static_cast<Told>(static_cast<Tnew>(oldvar)));

  return(static_cast<Tnew>(oldvar));
}

dataplusint_type()

template<typename T >

data_type TIMPI::dataplusint_type ( )

inline

Templated function to return the appropriate MPI datatype for use with built-in C types when combined with an int, or MPI_DATATYPE_NULL for types which have no predefined datatype.

Definition at line 81 of file parallel_implementation.h.

{ return MPI_DATATYPE_NULL; }

dataplusint_type< double >()

template<>

data_type TIMPI::dataplusint_type< double > ( )

inline

Definition at line 193 of file parallel_implementation.h.

{ return MPI_DOUBLE_INT; }

dataplusint_type< float >()

template<>

data_type TIMPI::dataplusint_type< float > ( )

inline

Definition at line 190 of file parallel_implementation.h.

{ return MPI_FLOAT_INT; }

dataplusint_type< int >()

template<>

data_type TIMPI::dataplusint_type< int > ( )

inline

Definition at line 184 of file parallel_implementation.h.

{ return MPI_2INT; }

dataplusint_type< long >()

template<>

data_type TIMPI::dataplusint_type< long > ( )

inline

Definition at line 187 of file parallel_implementation.h.

{ return MPI_LONG_INT; }

dataplusint_type< long double >()

template<>

data_type TIMPI::dataplusint_type< long double > ( )

inline

Definition at line 196 of file parallel_implementation.h.

{ return MPI_LONG_DOUBLE_INT; }

dataplusint_type< short int >()

template<>

data_type TIMPI::dataplusint_type< short int > ( )

inline

Definition at line 181 of file parallel_implementation.h.

{ return MPI_SHORT_INT; }

dataplusint_type_acquire()

template<typename T >

std::pair<data_type, std::unique_ptr<StandardType<std::pair<T,int> > > > TIMPI::dataplusint_type_acquire ( )

inline

Definition at line 201 of file parallel_implementation.h.

{
  std::pair<data_type, std::unique_ptr<StandardType<std::pair<T,int>>>> return_val;
  return_val.first = dataplusint_type<T>();
  if (return_val.first == MPI_DATATYPE_NULL)
    {
      return_val.second.reset(new StandardType<std::pair<T,int>>());
      return_val.first = *return_val.second;
    }
  return return_val;
}

get_timpi_version()

int TIMPI::get_timpi_version

(

)

Definition at line 53 of file timpi_version.C.

Referenced by testVersionNumber(), and timpi_version_string().

  {
    /* Note: return format follows the versioning convention xx.yy.zz where

       xx = major version number
       yy = minor version number
       zz = micro version number

       For example:
       v.   0.23  -> 002300 = 2300
       v   0.23.1 -> 002301 = 2301
       v. 10.23.2 -> 102302         */

    int major_version = 0;
    int minor_version = 0;
    int micro_version = 0;

#ifdef TIMPI_MAJOR_VERSION
    major_version = TIMPI_MAJOR_VERSION;
#endif

#ifdef TIMPI_MINOR_VERSION
    minor_version = TIMPI_MINOR_VERSION;
#endif

#ifdef TIMPI_MICRO_VERSION
    micro_version = TIMPI_MICRO_VERSION;
#endif

    return major_version*10000 + minor_version*100 + micro_version;
  }

ignore()

template<class ... Args>

void TIMPI::ignore ( const Args &  ... )

inline

Definition at line 54 of file timpi_assert.h.

Referenced by TIMPI::DataType::DataType(), TIMPI::Communicator::maxloc(), TIMPI::Communicator::minloc(), TIMPI::Communicator::probe(), and TIMPI::Status::size().

{ }

pack_range()

template<typename Context , typename buffertype , typename Iter >

Iter TIMPI::pack_range ( const Context *  context, Iter  range_begin, const Iter  range_end, typename std::vector< buffertype > &  buffer, std::size_t  approx_buffer_size = 1000000  )

inline

Helper function for range packing.

Encode a range of potentially-variable-size objects to a data array.

The data will be buffered in vectors with lengths that do not exceed the sum of approx_buffer_size and the size of an individual packed object.

Definition at line 1044 of file packing.h.

References libMesh::Parallel::Packing< T, Enable >::pack(), libMesh::Parallel::Packing< T, Enable >::packable_size(), and libMesh::Parallel::Packing< T, Enable >::packed_size().

Referenced by TIMPI::Communicator::nonblocking_send_packed_range(), TIMPI::Communicator::send_packed_range(), and TIMPI::Communicator::send_receive_packed_range().

{
  typedef typename std::iterator_traits<Iter>::value_type T;

  // Count the total size of and preallocate buffer for efficiency.
  // Prepare to stop early if the buffer would be too large.
  std::size_t buffer_size = 0;
  Iter range_stop = range_begin;
  for (; range_stop != range_end && buffer_size < approx_buffer_size;
       ++range_stop)
    {
      std::size_t next_buffer_size =
        Packing<T>::packable_size(*range_stop, context);
      buffer_size += next_buffer_size;
    }
  buffer.reserve(buffer.size() + buffer_size);

  // Pack the objects into the buffer
  for (; range_begin != range_stop; ++range_begin)
    {
#ifndef NDEBUG
      std::size_t old_size = buffer.size();
#endif

      Packing<T>::pack
        (*range_begin, std::back_inserter(buffer), context);

#ifndef NDEBUG
      unsigned int my_packable_size =
        Packing<T>::packable_size(*range_begin, context);
      unsigned int my_packed_size =
        Packing<T>::packed_size (buffer.begin() + old_size);
      timpi_assert_equal_to (my_packable_size, my_packed_size);
      timpi_assert_equal_to (buffer.size(), old_size + my_packable_size);
#endif
    }

  return range_stop;
}

packed_range_size()

template<typename Context , typename Iter >

std::size_t TIMPI::packed_range_size ( const Context *  context, Iter  range_begin, const Iter  range_end  )

inline

Helper function for range packing.

Return the total buffer size needed to encode a range of potentially-variable-size objects to a data array.

Definition at line 1023 of file packing.h.

References libMesh::Parallel::Packing< T, Enable >::packable_size().

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

{
  typedef typename std::iterator_traits<Iter>::value_type T;

  std::size_t buffer_size = 0;
  for (Iter range_count = range_begin;
       range_count != range_end;
       ++range_count)
    {
      buffer_size += Packing<T>::packable_size(*range_count, context);
    }
  return buffer_size;
}

pull_parallel_vector_data() [1/3]

template<typename datum , typename MapToVectors , typename GatherFunctor , typename ActionFunctor >

void TIMPI::pull_parallel_vector_data	(	const Communicator &	comm,
		const MapToVectors &	queries,
		GatherFunctor &	gather_data,
		const ActionFunctor &	act_on_data,
		const datum *	example
	)

Send query vectors, receive and answer them with vectors of data, then act on those answers.

The queries map is indexed by processor ids as keys, and for each processor id in the map there should be a vector of query ids to send. For processors to which no data should be sent, there should be no map entry; this will avoid any unnecessary communication. Unless NDEBUG is enabled, TIMPI will assert that no empty map entries exist. In any case empty map entries will not be gathered or acted on.

Queries will be operated on by the queried processor by gather_data(processor_id_type pid, const std::vector<id> & ids, std::vector<datum> & data) where the ids are those sent by the querying processor pid.

Answer data from each query will be operated on by the querying processor by act_on_data(processor_id_type pid, const std::vector<id> & ids, std::vector<datum> && data); where the ids are those sent to the queried processor pid.

If a query vector exists for the local processor in the map, gather_data will be called on it directly, and act_on_data will be called on the response directly, without any network operations.

The example pointer may be null; it merely needs to be of the correct type. It's just here because function overloading in C++ is easy, whereas SFINAE is hard and partial template specialization of functions is impossible.

No guarantee about operation ordering is made - this function will attempt to act on data in the order in which it is received.

All receives and actions are completed before this function returns.

Referenced by testPull(), testPullImpl(), testPullPacked(), and testPullVecVecImpl().

pull_parallel_vector_data() [2/3]

template<typename datum , typename A , typename MapToVectors , typename GatherFunctor , typename ActionFunctor >

void TIMPI::pull_parallel_vector_data	(	const Communicator &	comm,
		const MapToVectors &	queries,
		GatherFunctor &	gather_data,
		ActionFunctor &	act_on_data,
		const std::vector< datum, A > *	example
	)

Definition at line 961 of file parallel_sync.h.

References any_source, TIMPI::Communicator::get_unique_tag(), TIMPI::Communicator::probe(), push_parallel_vector_data(), TIMPI::Communicator::rank(), TIMPI::Communicator::receive(), TIMPI::Communicator::send(), and wait().

{
  typedef typename MapToVectors::mapped_type query_type;

  // First index: order of creation, irrelevant
  std::vector<std::vector<std::vector<datum,A>>> response_data;
  std::vector<Request> response_requests;

  // We'll grab a tag so we can overlap request sends and receives
  // without confusing one for the other
  MessageTag tag = comm.get_unique_tag();

  auto gather_functor =
    [&comm, &gather_data, &act_on_data,
     &response_data, &response_requests, &tag]
    (processor_id_type pid, query_type query)
    {
      std::vector<std::vector<datum,A>> response;
      gather_data(pid, query, response);
      timpi_assert_equal_to(query.size(),
                              response.size());

      // Just act on data if the user requested a send-to-self
      if (pid == comm.rank())
        {
          act_on_data(pid, query, response);
        }
      else
        {
          Request sendreq;
          comm.send(pid, response, sendreq, tag);
          response_requests.push_back(sendreq);
          response_data.push_back(std::move(response));
        }
    };

  push_parallel_vector_data (comm, queries, gather_functor);

  // Every outgoing query should now have an incoming response.
  //
  // Post all of the receives.
  //
  // Use blocking API here since we can't use the pre-sized
  // non-blocking APIs with this data type.
  //
  // FIXME - implement Derek's API from #1684, switch to that!
  std::vector<Request> receive_requests;
  std::vector<processor_id_type> receive_procids;
  for (std::size_t i = 0,
       n_queries = queries.size() - queries.count(comm.rank());
       i != n_queries; ++i)
    {
      Status stat(comm.probe(any_source, tag));
      const processor_id_type
        proc_id = cast_int<processor_id_type>(stat.source());

      std::vector<std::vector<datum,A>> received_data;
      comm.receive(proc_id, received_data, tag);

      timpi_assert(queries.count(proc_id));
      auto & querydata = queries.at(proc_id);
      timpi_assert_equal_to(querydata.size(), received_data.size());
      act_on_data(proc_id, querydata, received_data);
    }

  wait(response_requests);
}

pull_parallel_vector_data() [3/3]

template<typename datum , typename MapToVectors , typename GatherFunctor , typename ActionFunctor >

void TIMPI::pull_parallel_vector_data	(	const Communicator &	comm,
		const MapToVectors &	queries,
		GatherFunctor &	gather_data,
		ActionFunctor &	act_on_data,
		const datum *
	)

Definition at line 867 of file parallel_sync.h.

References push_parallel_vector_data(), TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::size(), and TIMPI::Communicator::sync_type().

{
  typedef typename MapToVectors::mapped_type query_type;

  std::multimap<processor_id_type, std::vector<datum> >
    response_data;

#ifndef NDEBUG
  processor_id_type max_pid = 0;
  for (auto p : queries)
    max_pid = std::max(max_pid, p.first);

  // Our SENDRECEIVE implementation doesn't preserve ordering, but we
  // need ordering preserved for the multimap trick here to work.
  if (comm.sync_type() == Communicator::SENDRECEIVE &&
      max_pid > comm.size())
    timpi_not_implemented();
#endif

  auto gather_functor =
    [&gather_data, &response_data]
    (processor_id_type pid, query_type query)
    {
      auto new_data_it =
        response_data.emplace(pid, std::vector<datum>());
      gather_data(pid, query, new_data_it->second);
      timpi_assert_equal_to(query.size(), new_data_it->second.size());
    };

  push_parallel_vector_data (comm, queries, gather_functor);

  std::map<processor_id_type, unsigned int> responses_acted_on;

  const processor_id_type num_procs = comm.size();

  auto action_functor =
    [&act_on_data, &queries, &responses_acted_on,
#ifndef NDEBUG
     max_pid,
#endif
     num_procs
    ]
    (processor_id_type pid, const std::vector<datum> & data)
    {
      // We rely on responses coming in the same order as queries
      const unsigned int nth_query = responses_acted_on[pid]++;

      auto q_pid_its = queries.equal_range(pid);
      auto query_it = q_pid_its.first;

      // In an oversized pull we might not have any queries addressed
      // to the *base* pid, but only to pid+N*num_procs for some N>1
      // timpi_assert(query_it != q_pid_its.second);
      while (query_it == q_pid_its.second)
        {
          pid += num_procs;
          q_pid_its = queries.equal_range(pid);
          timpi_assert_less_equal(pid, max_pid);
          query_it = q_pid_its.first;
        }

      for (unsigned int i=0; i != nth_query; ++i)
        {
          query_it++;
          if (query_it == q_pid_its.second)
            {
              do
                {
                  pid += num_procs;
                  q_pid_its = queries.equal_range(pid);
                  timpi_assert_less_equal(pid, max_pid);
                } while (q_pid_its.first == q_pid_its.second);
              query_it = q_pid_its.first;
            }
        }

      act_on_data(pid, query_it->second, data);
    };

  push_parallel_vector_data (comm, response_data, action_functor);
}

push_parallel_packed_range() [1/2]

template<typename MapToVectors , typename ActionFunctor , typename Context >

void TIMPI::push_parallel_packed_range	(	const Communicator &	comm,
		MapToVectors &&	data,
		Context *	context,
		const ActionFunctor &	act_on_data
	)

Send and receive and act on vectors of data.

Similar to push_parallel_vector_data, except the vectors are packed and unpacked using the Parallel::Packing routines.

The data map is indexed by processor ids as keys, and for each processor id in the map there should be a vector of data to send. For processors to which no data should be sent, there should be no map entry; this will avoid any unnecessary communication. Unless NDEBUG is enabled, TIMPI will assert that no empty map entries exist. In any case empty map entries will not be acted on.

Data which is received from other processors will be operated on by act_on_data(processor_id_type pid, std::vector<datum> && data)

If data exists for the local processor in the map, it will be acted on directly, without any network operations. This also avoids packing and unpacking the data, so no side effects of those operations should be assumed.

No guarantee about operation ordering is made - this function will attempt to act on data in the order in which it is received.

All receives and actions are completed before this function returns.

If you wish to use move semantics within the data received in act_on_data, pass data itself as an rvalue reference.

Referenced by testPushPackedImpl(), testPushPackedImplMove(), and testPushPackedNested().

push_parallel_packed_range() [2/2]

template<typename MapToContainers , typename ActionFunctor , typename Context >

void TIMPI::push_parallel_packed_range	(	const Communicator &	comm,
		MapToContainers &&	data,
		Context *	context,
		const ActionFunctor &	act_on_data
	)

Definition at line 659 of file parallel_sync.h.

References TIMPI::Communicator::ALLTOALL_COUNTS, TIMPI::Communicator::NBX, TIMPI::Communicator::nonblocking_receive_packed_range(), TIMPI::Communicator::nonblocking_send_packed_range(), TIMPI::Communicator::packed_range_probe(), TIMPI::Communicator::possibly_receive_packed_range(), TIMPI::detail::push_parallel_alltoall_helper(), TIMPI::detail::push_parallel_nbx_helper(), TIMPI::detail::push_parallel_roundrobin_helper(), TIMPI::Communicator::send_receive_packed_range(), TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::sync_type(), and TIMPI::Request::wait().

{
  typedef typename std::remove_reference<MapToContainers>::type::mapped_type container_type;
  typedef typename container_type::value_type nonref_type;
  typename std::remove_const<nonref_type>::type * output_type = nullptr;

  switch (comm.sync_type()) {
  case Communicator::NBX:
    {
      auto send_functor = [&context, &comm](const processor_id_type dest_pid,
                                            const container_type & datum,
                                            Request & send_request,
                                            const MessageTag tag) {
        comm.nonblocking_send_packed_range(dest_pid, context, datum.begin(), datum.end(), send_request, tag);
      };

      auto possibly_receive_functor = [&context, &output_type, &comm](unsigned int & current_src_proc,
                                                                      container_type & current_incoming_data,
                                                                      Request & current_request,
                                                                      const MessageTag tag) {
        return comm.possibly_receive_packed_range(
            current_src_proc,
            context,
            std::inserter(current_incoming_data, current_incoming_data.end()),
            output_type,
            current_request,
            tag);
      };

      detail::push_parallel_nbx_helper
        (comm, data, send_functor, possibly_receive_functor, act_on_data);
    }
    break;
  case Communicator::ALLTOALL_COUNTS:
    {
      auto send_functor = [&context, &comm](const processor_id_type dest_pid,
                                            const container_type & datum,
                                            Request & send_request,
                                            const MessageTag tag) {
        comm.nonblocking_send_packed_range(dest_pid, context, datum.begin(), datum.end(), send_request, tag);
      };

      auto receive_functor = [&context, &output_type, &comm](unsigned int current_src_proc,
                                                             container_type & current_incoming_data,
                                                             const MessageTag tag) {
        bool flag = false;
        Status stat(comm.packed_range_probe<container_type>(current_src_proc, tag, flag));
        timpi_assert(flag);

        Request req;
        comm.nonblocking_receive_packed_range(current_src_proc, context,
          std::inserter(current_incoming_data, current_incoming_data.end()),
          output_type, req, stat, tag);
        req.wait();
      };

      detail::push_parallel_alltoall_helper
        (comm, data, send_functor, receive_functor, act_on_data);
    }
    break;
  case Communicator::SENDRECEIVE:
    {
      auto sendreceive_functor = [&context, &output_type, &comm]
        (const processor_id_type dest_pid,
         const container_type & data_to_send,
         const processor_id_type src_pid,
         container_type & received_data,
         const MessageTag tag) {
        comm.send_receive_packed_range(dest_pid, context,
                                       data_to_send.begin(),
                                       data_to_send.end(), src_pid,
                                       context,
                                       std::inserter(received_data,
                                                     received_data.end()),
                                       output_type, tag, tag);
      };

      detail::push_parallel_roundrobin_helper
        (comm, data, sendreceive_functor, act_on_data);
    }
    break;
  default:
    timpi_error_msg("Invalid sync_type setting " << comm.sync_type());
  }

}

push_parallel_vector_data()

template<typename MapToVectors , typename ActionFunctor , typename std::enable_if< std::is_base_of< DataType, StandardType< typename InnermostType< typename std::remove_const< typename std::remove_reference< MapToVectors >::type::mapped_type::value_type >::type >::type >>::value, int >::type = 0>

void TIMPI::push_parallel_vector_data	(	const Communicator &	comm,
		MapToVectors &&	data,
		const ActionFunctor &	act_on_data
	)

Send and receive and act on vectors of data.

The data map is indexed by processor ids as keys, and for each processor id in the map there should be a vector of data to send. For processors to which no data should be sent, there should be no map entry; this will avoid any unnecessary communication. Unless NDEBUG is enabled, TIMPI will assert that no empty map entries exist. In any case empty map entries will not be acted on.

Data which is received from other processors will be operated on by act_on_data(processor_id_type pid, std::vector<datum> && data)

If data exists for the local processor in the map, it will be acted on directly, without any network operations.

No guarantee about operation ordering is made - this function will attempt to act on data in the order in which it is received.

All receives and actions are completed before this function returns.

If you wish to use move semantics within the data received in act_on_data, pass data itself as an rvalue reference.

This overload should be automatically selected for data which has a StandardType specialization defined, so that we can directly send it without serializing it into buffers beforehand.

This overload should be automatically selected for data which has a Packing specialization defined, where we must serialize it into buffers before sending.

Definition at line 756 of file parallel_sync.h.

References TIMPI::Communicator::ALLTOALL_COUNTS, build_standard_type(), TIMPI::Communicator::NBX, TIMPI::Communicator::possibly_receive(), TIMPI::detail::push_parallel_alltoall_helper(), TIMPI::detail::push_parallel_nbx_helper(), TIMPI::detail::push_parallel_roundrobin_helper(), TIMPI::Communicator::receive(), TIMPI::Communicator::send(), TIMPI::Communicator::send_receive(), TIMPI::Communicator::SENDRECEIVE, and TIMPI::Communicator::sync_type().

Referenced by pull_parallel_vector_data(), testEmptyEntry(), testPush(), testPushImpl(), testPushMove(), testPushMultimapImpl(), testPushMultimapVecVecImpl(), testPushPackedDispatch(), testPushPackedFailureCase(), testPushPackedOneTuple(), and testPushVecVecImpl().

{
  typedef typename std::remove_reference<MapToVectors>::type::mapped_type container_type;
  typedef typename container_type::value_type nonref_type;
  typedef typename std::remove_const<nonref_type>::type nonconst_nonref_type;

  // We'll construct the StandardType once rather than inside a loop.
  // We can't pass in example data here, because we might have
  // data.empty() on some ranks, so we'll need StandardType to be able
  // to construct the user's data type without an example.
  auto type = build_standard_type(static_cast<nonconst_nonref_type *>(nullptr));

  switch (comm.sync_type()) {
  case Communicator::NBX:
    {
      auto send_functor = [&type, &comm](const processor_id_type dest_pid,
                                         const container_type & datum,
                                         Request & send_request,
                                         const MessageTag tag) {
        comm.send(dest_pid, datum, type, send_request, tag);
      };

      auto possibly_receive_functor = [&type, &comm](unsigned int & current_src_proc,
                                                     container_type & current_incoming_data,
                                                     Request & current_request,
                                                     const MessageTag tag) {
        return comm.possibly_receive(
            current_src_proc, current_incoming_data, type, current_request, tag);
      };

      detail::push_parallel_nbx_helper
        (comm, data, send_functor, possibly_receive_functor, act_on_data);
    }
    break;
  case Communicator::ALLTOALL_COUNTS:
    {
#ifdef TIMPI_HAVE_MPI // We should never hit these functors in serial
      auto send_functor = [&type, &comm](const processor_id_type dest_pid,
                                         const container_type & datum,
                                         Request & send_request,
                                         const MessageTag tag) {
        comm.send(dest_pid, datum, type, send_request, tag);
      };

      auto receive_functor = [&type, &comm](unsigned int current_src_proc,
                                            container_type & current_incoming_data,
                                            const MessageTag tag) {
        comm.receive(current_src_proc, current_incoming_data, type, tag);
      };
#else
      auto send_functor = [](const processor_id_type,
                             const container_type &,
                             Request &,
                             const MessageTag) {
        timpi_error(); // We should never hit these in serial
      };

      auto receive_functor = [](unsigned int,
                                container_type &,
                                const MessageTag) {
        timpi_error();
      };
#endif

      detail::push_parallel_alltoall_helper
        (comm, data, send_functor, receive_functor, act_on_data);
    }
    break;
  case Communicator::SENDRECEIVE:
    {
      auto sendreceive_functor = [&comm](const processor_id_type dest_pid,
                                         const container_type & data_to_send,
                                         const processor_id_type src_pid,
                                         container_type & received_data,
                                         const MessageTag tag) {
        comm.send_receive(dest_pid, data_to_send,
                          src_pid, received_data, tag, tag);
      };

      detail::push_parallel_roundrobin_helper
        (comm, data, sendreceive_functor, act_on_data);
    }
    break;
  default:
    timpi_error_msg("Invalid sync_type setting " << comm.sync_type());
  }
}

report_error()

void TIMPI::report_error	(	const char *	file,
		int	line,
		const char *	date,
		const char *	time
	)

Definition at line 43 of file timpi_assert.C.

References report_here().

{
  // It is possible to have an error *inside* report_error; e.g. when
  // we start using a TIMPI::print_trace.  Don't infinitely recurse.
  static bool reporting_error = false;
  if (reporting_error)
    {
      // I heard you like error reporting, so we put an error report
      // in report_error() so you can report errors from the report.
      std::cerr << "TIMPI encountered an error while attempting to report_error." << std::endl;
      return;
    }
  reporting_error = true;

  report_here(file, line, date, time);

  reporting_error = false;
}

report_here()

void TIMPI::report_here	(	const char *	file,
		int	line,
		const char *	date,
		const char *	time
	)

Definition at line 29 of file timpi_assert.C.

References TIMPI::Communicator::rank().

Referenced by report_error().

{
  std::ostringstream here_msg; // Build in one buffer to reduce interleaving
#ifdef TIMPI_HAVE_MPI
  TIMPI::Communicator commworld(MPI_COMM_WORLD);
  const std::size_t proc_id = commworld.rank();
  here_msg << "[" << proc_id << "] ";
#endif
  here_msg << file << ", line " << line << ", compiled "
           << date << " at " << time << std::endl;
  std::cerr << here_msg.str();
}

TIMPI_CONTAINER_TYPE() [1/2]

template<typename T , typename C , typename A >

TIMPI::TIMPI_CONTAINER_TYPE

(

std::set< T TIMPI_ATTRIBUTES_COMMA C TIMPI_ATTRIBUTES_COMMA A >

)

TIMPI_CONTAINER_TYPE() [2/2]

template<typename T , typename A >

TIMPI::TIMPI_CONTAINER_TYPE

(

std::vector< T TIMPI_ATTRIBUTES_COMMA A >

)

TIMPI_FLOAT_TYPE() [1/4]

TIMPI::TIMPI_FLOAT_TYPE

(

float

)

TIMPI_FLOAT_TYPE() [2/4]

TIMPI::TIMPI_FLOAT_TYPE

(

double

)

TIMPI_FLOAT_TYPE() [3/4]

TIMPI::TIMPI_FLOAT_TYPE

(

long

double

)

TIMPI_FLOAT_TYPE() [4/4]

TIMPI::TIMPI_FLOAT_TYPE

(

TIMPI_DEFAULT_SCALAR_TYPE

)

timpi_ignore()

template<class ... Args>

void TIMPI::timpi_ignore ( const Args &  ... )

inline

Definition at line 286 of file timpi_assert.h.

Referenced by TIMPI::StandardType< std::pair< T1, T2 >, typename std::enable_if< StandardType< typename std::remove_const< T1 >::type >::is_fixed_type &&StandardType< T2 >::is_fixed_type >::type >::StandardType(), TIMPI::StandardType< std::array< T, N >, typename std::enable_if< StandardType< T >::is_fixed_type >::type >::StandardType(), and TIMPI::StandardType< std::tuple< Types... >, typename std::enable_if< CheckAllFixedTypes< Types... >::is_fixed_type >::type >::StandardType().

{ }

TIMPI_INT_TYPE() [1/8]

TIMPI::TIMPI_INT_TYPE

(

char

)

TIMPI_INT_TYPE() [2/8]

TIMPI::TIMPI_INT_TYPE

(

signed

char

)

TIMPI_INT_TYPE() [3/8]

TIMPI::TIMPI_INT_TYPE

(

unsigned

char

)

TIMPI_INT_TYPE() [4/8]

TIMPI::TIMPI_INT_TYPE

(

short

int

)

TIMPI_INT_TYPE() [5/8]

TIMPI::TIMPI_INT_TYPE

(

unsigned short

int

)

TIMPI_INT_TYPE() [6/8]

TIMPI::TIMPI_INT_TYPE

(

int

)

TIMPI_INT_TYPE() [7/8]

TIMPI::TIMPI_INT_TYPE

(

long

)

TIMPI_INT_TYPE() [8/8]

TIMPI::TIMPI_INT_TYPE

(

unsigned long

long

)

TIMPI_PARALLEL_FLOAT_OPS() [1/4]

TIMPI::TIMPI_PARALLEL_FLOAT_OPS

(

float

)

TIMPI_PARALLEL_FLOAT_OPS() [2/4]

TIMPI::TIMPI_PARALLEL_FLOAT_OPS

(

double

)

TIMPI_PARALLEL_FLOAT_OPS() [3/4]

TIMPI::TIMPI_PARALLEL_FLOAT_OPS

(

long

double

)

TIMPI_PARALLEL_FLOAT_OPS() [4/4]

TIMPI::TIMPI_PARALLEL_FLOAT_OPS

(

TIMPI_DEFAULT_SCALAR_TYPE

)

TIMPI_PARALLEL_INTEGER_OPS() [1/8]

TIMPI::TIMPI_PARALLEL_INTEGER_OPS

(

char

)

TIMPI_PARALLEL_INTEGER_OPS() [2/8]

TIMPI::TIMPI_PARALLEL_INTEGER_OPS

(

signed

char

)

TIMPI_PARALLEL_INTEGER_OPS() [3/8]

TIMPI::TIMPI_PARALLEL_INTEGER_OPS

(

unsigned

char

)

TIMPI_PARALLEL_INTEGER_OPS() [4/8]

TIMPI::TIMPI_PARALLEL_INTEGER_OPS

(

short

int

)

TIMPI_PARALLEL_INTEGER_OPS() [5/8]

TIMPI::TIMPI_PARALLEL_INTEGER_OPS

(

unsigned short

int

)

TIMPI_PARALLEL_INTEGER_OPS() [6/8]

TIMPI::TIMPI_PARALLEL_INTEGER_OPS

(

int

)

TIMPI_PARALLEL_INTEGER_OPS() [7/8]

TIMPI::TIMPI_PARALLEL_INTEGER_OPS

(

long

)

TIMPI_PARALLEL_INTEGER_OPS() [8/8]

TIMPI::TIMPI_PARALLEL_INTEGER_OPS

(

unsigned long

long

)

TIMPI_STANDARD_TYPE() [1/15]

TIMPI::TIMPI_STANDARD_TYPE	(	char	,
		MPI_CHAR
	)

TIMPI_STANDARD_TYPE() [2/15]

TIMPI::TIMPI_STANDARD_TYPE	(	signed	char,
		MPI_SIGNED_CHAR
	)

TIMPI_STANDARD_TYPE() [3/15]

TIMPI::TIMPI_STANDARD_TYPE	(	unsigned	char,
		MPI_UNSIGNED_CHAR
	)

TIMPI_STANDARD_TYPE() [4/15]

TIMPI::TIMPI_STANDARD_TYPE	(	short	int,
		MPI_SHORT
	)

TIMPI_STANDARD_TYPE() [5/15]

TIMPI::TIMPI_STANDARD_TYPE	(	unsigned short	int,
		MPI_UNSIGNED_SHORT
	)

TIMPI_STANDARD_TYPE() [6/15]

TIMPI::TIMPI_STANDARD_TYPE	(	int	,
		MPI_INT
	)

TIMPI_STANDARD_TYPE() [7/15]

TIMPI::TIMPI_STANDARD_TYPE	(	unsigned	int,
		MPI_UNSIGNED
	)

TIMPI_STANDARD_TYPE() [8/15]

TIMPI::TIMPI_STANDARD_TYPE	(	long	,
		MPI_LONG
	)

TIMPI_STANDARD_TYPE() [9/15]

TIMPI::TIMPI_STANDARD_TYPE	(	long	long,
		MPI_LONG_LONG_INT
	)

TIMPI_STANDARD_TYPE() [10/15]

TIMPI::TIMPI_STANDARD_TYPE	(	unsigned	long,
		MPI_UNSIGNED_LONG
	)

TIMPI_STANDARD_TYPE() [11/15]

TIMPI::TIMPI_STANDARD_TYPE	(	unsigned long	long,
		MPI_UNSIGNED_LONG_LONG
	)

TIMPI_STANDARD_TYPE() [12/15]

TIMPI::TIMPI_STANDARD_TYPE	(	float	,
		MPI_FLOAT
	)

TIMPI_STANDARD_TYPE() [13/15]

TIMPI::TIMPI_STANDARD_TYPE	(	double	,
		MPI_DOUBLE
	)

TIMPI_STANDARD_TYPE() [14/15]

TIMPI::TIMPI_STANDARD_TYPE	(	long	double,
		MPI_LONG_DOUBLE
	)

TIMPI_STANDARD_TYPE() [15/15]

TIMPI::TIMPI_STANDARD_TYPE

(

TIMPI_DEFAULT_SCALAR_TYPE

)

timpi_version_stdout()

void TIMPI::timpi_version_stdout

(

)

Definition at line 26 of file timpi_version.C.

References timpi_version_string().

Referenced by main().

  {
    std::cout << timpi_version_string() << std::flush;
  }

timpi_version_string()

std::string TIMPI::timpi_version_string

(

)

Definition at line 31 of file timpi_version.C.

References get_timpi_version().

Referenced by testVersionString(), and timpi_version_stdout().

  {
    std::ostringstream oss;

    oss << "--------------------------------------------------------" << std::endl;
    oss << "TIMPI Package: Version = " << TIMPI_LIB_VERSION;
    oss << " (" << get_timpi_version() << ")" << std::endl << std::endl;

    oss << TIMPI_LIB_RELEASE << std::endl << std::endl;

    oss << "Build Date   = " << TIMPI_BUILD_DATE     << std::endl;
    oss << "Build Host   = " << TIMPI_BUILD_HOST     << std::endl;
    oss << "Build User   = " << TIMPI_BUILD_USER     << std::endl;
    oss << "Build Arch   = " << TIMPI_BUILD_ARCH     << std::endl;
    oss << "Build Rev    = " << TIMPI_BUILD_VERSION  << std::endl << std::endl;

    oss << "C++ Config   = " << TIMPI_CXX << " " << TIMPI_CXXFLAGS << std::endl;
    oss << "--------------------------------------------------------" << std::endl;

    return oss.str();
  }

unpack_range() [1/2]

template<typename Context , typename buffertype , typename OutputIter , typename T >

OutputIter TIMPI::unpack_range ( const typename std::vector< buffertype > &  buffer, Context *  context, OutputIter  out_iter, const T *  output_type  )

inline

Decode a range of potentially-variable-size objects from a data array.

We take out_iter by value for maximum compatibility, but we return it afterward for the use of code that needs to unpack multiple buffers to the same output iterator.

unpack_range() [2/2]

template<typename Context , typename buffertype , typename OutputIter , typename T >

OutputIter TIMPI::unpack_range ( const std::vector< buffertype > &  buffer, Context *  context, OutputIter  out_iter, const T *    )

inline

Helper function for range unpacking.

We take out_iter by value for maximum compatibility, but we return it afterward for the use of code that needs to unpack multiple buffers to the same output iterator.

Definition at line 1103 of file packing.h.

References libMesh::Parallel::Packing< T, Enable >::packed_size(), and libMesh::Parallel::Packing< T, Enable >::unpack().

Referenced by TIMPI::Communicator::receive_packed_range(), TIMPI::PostWaitUnpackBuffer< Container, Context, OutputIter, T >::run(), and TIMPI::Communicator::send_receive_packed_range().

{
  // Loop through the buffer and unpack each object, returning the
  // object pointer via the output iterator
  typename std::vector<buffertype>::const_iterator
    next_object_start = buffer.begin();

  while (next_object_start < buffer.end())
    {
      *out_iter++ = Packing<T>::unpack(next_object_start, context);
      next_object_start +=
        Packing<T>::packed_size(next_object_start);
    }

  // We should have used up the exact amount of data in the buffer
  timpi_assert (next_object_start == buffer.end());

  return out_iter;
}

wait() [1/2]

Status TIMPI::wait ( Request &  r )

inline

Wait for a non-blocking send or receive to finish.

Definition at line 135 of file request.h.

References TIMPI::Request::wait().

Referenced by pull_parallel_vector_data(), testIrecvSend(), testIsendRecv(), testRecvIsendSets(), and testRecvIsendVecVecs().

{ return r.wait(); }

wait() [2/2]

void TIMPI::wait

(

std::vector< Request > &

r

)

Wait for all non-blocking operations to finish.

Definition at line 213 of file request.C.

{
  for (auto & req : r)
    req.wait();
}

waitany()

std::size_t TIMPI::waitany

(

std::vector< Request > &

r

)

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.

References TIMPI::Request::_prior_request, TIMPI::Request::_request, TIMPI::Request::get(), TIMPI::Request::null_request, and TIMPI::Request::post_wait_work.

Referenced by testNonblockingWaitany().

{
  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;
}

Variable Documentation

any_source

const unsigned int TIMPI::any_source

Initial value:

=
  static_cast<unsigned int>(MPI_ANY_SOURCE)

Processor id meaning "Accept from any source".

Definition at line 84 of file communicator.h.

Referenced by TIMPI::Communicator::possibly_receive(), TIMPI::Communicator::probe(), pull_parallel_vector_data(), TIMPI::detail::push_parallel_alltoall_helper(), TIMPI::detail::push_parallel_nbx_helper(), TIMPI::Communicator::receive(), TIMPI::Communicator::send_receive(), and testNonblockingString().

any_tag

const MessageTag TIMPI::any_tag = MessageTag(MPI_ANY_TAG)

Default message tag ids.

Definition at line 114 of file message_tag.h.

communicator

typedef int TIMPI::communicator

Communicator object for talking with subsets of processors.

Definition at line 74 of file communicator.h.

no_tag

const MessageTag TIMPI::no_tag = MessageTag(0)

Definition at line 119 of file message_tag.h.