 |
deal.II version GIT relicensing-2287-g6548a49e0a 2024-12-20 18:30:00+00:00
|
Loading...
Searching...
No Matches
|
deal.II version GIT relicensing-2287-g6548a49e0a 2024-12-20 18:30:00+00:00
|
#include <deal.II/base/mpi.h>
Public Member Functions | |
| template<typename W , typename G > | |
| Future (W &&wait_operation, G &&get_and_cleanup_operation) | |
| Future (const Future &)=delete | |
| Future (Future &&) noexcept=default | |
| ~Future () | |
| Future & | operator= (const Future &)=delete |
| Future & | operator= (Future &&) noexcept=default |
| void | wait () |
| T | get () |
Private Attributes | |
| std::function< void()> | wait_function |
| std::function< T()> | get_and_cleanup_function |
| bool | is_done |
| bool | get_was_called |
An object that acts like a std::future object except that it does not encode the operation of waiting for an operation to finish that may be happening on a different thread, but for an "immediate" MPI operation such as MPI_Isend or MPI_Irecv. An object of this kind is returned, for example, by the isend() and irecv() functions in this namespace.
If the operation being waited for produces a result (such as a receive operation, then the produced result is returned by the get() function and its type is indicated by the template argument T. If the operation does not produce a result (such as waiting for a send operation to complete), then T=void is the right choice for the template argument.
Immediate MPI operations are typically associated with two additional actions. The first is that one has to be able to wait for them to finish. In many cases, this is done using a call to MPI_Wait that is given an MPI_Request object (in the case of send operations) or a call to MPI_Probe or a variant of this function (in the case of receive operations). The wait operation may be called more than once and would immediately return once the first one has succeeded.
Secondly, immediate MPI operations often require clean-up actions that must be executed once the operation has finished. An example is releasing a buffer in which data has been stored (for an immediate send operation), or allocating a receive buffer, calling the MPI function that puts the received data into this buffer, calling the unpacking function for the data received, and releasing the receive buffer (for an immediate receive operation).
This class models these two steps by taking two constructor arguments that correspond to these two operations. It ensures that upon destruction of the current object, both the wait and clean-up functions are called. Because the clean-up function can only be called once, objects of the current class can not be copied, but they can be moved.
| Utilities::MPI::Future< T >::Future | ( | W && | wait_operation, |
| G && | get_and_cleanup_operation | ||
| ) |
Constructor. Take both the wait and clean-up functions mentioned in the class documentation as arguments.
|
delete |
Copy constructor. This operation is not possible, as explained in the class documentation, and consequently the constructor is deleted.
|
defaultnoexcept |
Move constructor.
| Utilities::MPI::Future< T >::~Future | ( | ) |
Destructor.
|
delete |
Copy operator. This operation is not possible, as explained in the class documentation, and consequently the operator is deleted.
|
defaultnoexcept |
Move operator.
| void Utilities::MPI::Future< T >::wait | ( | ) |
Wait for the operation to complete. This function can safely be called more than once. It will wait for the operation to complete the first time it is called; because the operation will have completed once it has been called for the first time, it will immediately return if called again at a later time.
| T Utilities::MPI::Future< T >::get | ( | ) |
Wait for the operation to complete and return the object the operation produces (if T is not equal to void).
Like for std::future, this function can only be called once because the class does not store the object produced. (It can not store the object being produced because returning it from this function would require the ability to copy it; however, not all objects can be copied, whereas all useful objects can be moved.)
|
private |
|
private |
|
private |
|
private |
1.9.8