resiliency

#include <hpx/resiliency/async_replay.hpp>

namespace hpx

namespace resiliency

Functions

template<typename Pred, typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> async_replay_validate(std::size_t n, Pred &&pred, F &&f, Ts&&... ts)

Asynchronously launch given function f. Verify the result of those invocations using the given predicate pred. Repeat launching on error exactly n times (except if abort_replay_exception is thrown).

template<typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> async_replay(std::size_t n, F &&f, Ts&&... ts)

Asynchronously launch given function f. Repeat launching on error exactly n times (except if abort_replay_exception is thrown).

namespace functional

Functional version of hpx::resiliency::async_replay.

Functional version of hpx::resiliency::async_replicate_validate and hpx::resiliency::async_replicate

struct async_replay

Public Functions

template<typename F, typename ...Ts>
auto operator()(std::size_t n, F &&f, Ts&&... ts) const

struct async_replay_validate

Public Functions

template<typename Pred, typename F, typename ...Ts>
auto operator()(std::size_t n, Pred &&pred, F &&f, Ts&&... ts) const

#include <hpx/resiliency/force_linking.hpp>

namespace hpx

namespace resiliency

Functions

force_linking_helper &force_linking()

struct force_linking_helper

Public Members

unsigned int (*major_version)()

unsigned int (*minor_version)()

unsigned int (*subminor_version)()

unsigned long (*full_version)()

std::string (*full_version_str)()

#include <hpx/resiliency/dataflow_replay.hpp>

namespace hpx

namespace resiliency

Functions

template<typename Pred, typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> dataflow_replay_validate(std::size_t n, Pred &&pred, F &&f, Ts&&... ts)

Asynchronously launch given function f. Verify the result of those invocations using the given predicate pred. Repeat launching on error exactly n times.

Delay the invocation of f if any of the arguments to f are futures.

template<typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> dataflow_replay(std::size_t n, F &&f, Ts&&... ts)

Asynchronously launch given function f. Repeat launching on error exactly n times.

Delay the invocation of f if any of the arguments to f are futures.

#include <hpx/resiliency/resiliency.hpp>

#include <hpx/resiliency/dataflow_replicate.hpp>

namespace hpx

namespace resiliency

Functions

template<typename Vote, typename Pred, typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> dataflow_replicate_vote_validate(std::size_t n, Vote &&vote, Pred &&pred, F &&f, Ts&&... ts)

Launch given function f exactly n times. Run all the valid results against a user provided voting function. Return the valid output.

Delay the invocation of f if any of the arguments to f are futures.

template<typename Vote, typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> dataflow_replicate_vote(std::size_t n, Vote &&vote, F &&f, Ts&&... ts)

Launch given function f exactly n times. Run all the valid results against a user provided voting function. Return the valid output.

Delay the invocation of f if any of the arguments to f are futures.

template<typename Pred, typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> dataflow_replicate_validate(std::size_t n, Pred &&pred, F &&f, Ts&&... ts)

Launch given function f exactly n times. Verify the result of those invocations using the given predicate pred. Return the first valid result.

Delay the invocation of f if any of the arguments to f are futures.

template<typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> dataflow_replicate(std::size_t n, F &&f, Ts&&... ts)

Launch given function f exactly n times. Return the first valid result.

Delay the invocation of f if any of the arguments to f are futures.

#include <hpx/resiliency/config.hpp>

#include <hpx/resiliency/version.hpp>

Defines

HPX_RESILIENCY_VERSION_FULL

HPX_RESILIENCY_VERSION_MAJOR

HPX_RESILIENCY_VERSION_MINOR

HPX_RESILIENCY_VERSION_SUBMINOR

HPX_RESILIENCY_VERSION_DATE

namespace hpx

namespace resiliency

Functions

unsigned int major_version()

unsigned int minor_version()

unsigned int subminor_version()

unsigned long full_version()

std::string full_version_str()

#include <hpx/resiliency/async_replicate.hpp>

namespace hpx

namespace resiliency

Functions

template<typename Vote, typename Pred, typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> async_replicate_vote_validate(std::size_t n, Vote &&vote, Pred &&pred, F &&f, Ts&&... ts)

Asynchronously launch given function f exactly n times. Verify the result of those invocations using the given predicate pred. Run all the valid results against a user provided voting function. Return the valid output.

template<typename Vote, typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> async_replicate_vote(std::size_t n, Vote &&vote, F &&f, Ts&&... ts)

Asynchronously launch given function f exactly n times. Verify the result of those invocations using the given predicate pred. Run all the valid results against a user provided voting function. Return the valid output.

template<typename Pred, typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> async_replicate_validate(std::size_t n, Pred &&pred, F &&f, Ts&&... ts)

Asynchronously launch given function f exactly n times. Verify the result of those invocations using the given predicate pred. Return the first valid result.

template<typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> async_replicate(std::size_t n, F &&f, Ts&&... ts)

Asynchronously launch given function f exactly n times. Verify the result of those invocations by checking for exception. Return the first valid result.

namespace functional

Functional version of hpx::resiliency::async_replay.

Functional version of hpx::resiliency::async_replicate_validate and hpx::resiliency::async_replicate

struct async_replicate

Public Functions

template<typename F, typename ...Ts>
auto operator()(std::size_t n, F &&f, Ts&&... ts) const

struct async_replicate_validate

Public Functions

template<typename Pred, typename F, typename ...Ts>
auto operator()(std::size_t n, Pred &&pred, F &&f, Ts&&... ts) const

struct async_replicate_vote

Public Functions

template<typename Vote, typename F, typename ...Ts>
auto operator()(std::size_t n, Vote &&vote, F &&f, Ts&&... ts) const

struct async_replicate_vote_validate

Public Functions

template<typename Vote, typename Pred, typename F, typename ...Ts>
auto operator()(std::size_t n, Vote &&vote, Pred &&pred, F &&f, Ts&&... ts) const