resiliency

The contents of this module can be included with the header hpx/modules/resiliency.hpp. These headers may be used by user-code but are not guaranteed stable (neither header location nor contents). You are using these at your own risk. If you wish to use non-public functionality from a module we strongly suggest only including the module header hpx/modules/resiliency.hpp, not the particular header in which the functionality you would like to use is defined. See Public API for a list of names that are part of the public HPX API.

Header hpx/resiliency/async_replay.hpp

namespace hpx
namespace resiliency
namespace experimental

Functions

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

Header hpx/resiliency/async_replay_executor.hpp

namespace hpx
namespace resiliency
namespace experimental

Functions

template<typename Executor, typename Pred, typename F, typename ...Ts>
decltype(auto) tag_invoke(async_replay_validate_t, Executor &&exec, std::size_t n, Pred &&pred, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
decltype(auto) tag_invoke(async_replay_t, Executor &&exec, std::size_t n, F &&f, Ts&&... ts)

Header hpx/resiliency/async_replicate.hpp

namespace hpx
namespace resiliency
namespace experimental

Functions

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

Header hpx/resiliency/async_replicate_executor.hpp

namespace hpx
namespace resiliency
namespace experimental

Functions

template<typename Executor, typename Vote, typename Pred, typename F, typename ...Ts>
decltype(auto) tag_invoke(async_replicate_vote_validate_t, Executor &&exec, std::size_t n, Vote &&vote, Pred &&pred, F &&f, Ts&&... ts)
template<typename Executor, typename Vote, typename F, typename ...Ts>
decltype(auto) tag_invoke(async_replicate_vote_t, Executor &&exec, std::size_t n, Vote &&vote, F &&f, Ts&&... ts)
template<typename Executor, typename Pred, typename F, typename ...Ts>
decltype(auto) tag_invoke(async_replicate_validate_t, Executor &&exec, std::size_t n, Pred &&pred, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
decltype(auto) tag_invoke(async_replicate_t, Executor &&exec, std::size_t n, F &&f, Ts&&... ts)

Header hpx/resiliency/config.hpp

Header hpx/resiliency/replay_executor.hpp

namespace hpx
namespace resiliency
namespace experimental

Functions

template<typename BaseExecutor, typename Validate>
replay_executor<BaseExecutor, typename std::decay<Validate>::type> make_replay_executor(BaseExecutor &exec, std::size_t n, Validate &&validate)
template<typename BaseExecutor>
replay_executor<BaseExecutor, detail::replay_validator> make_replay_executor(BaseExecutor &exec, std::size_t n)
template<typename BaseExecutor, typename Validate>
class replay_executor
#include <replay_executor.hpp>

Public Types

template<>
using execution_category = typename BaseExecutor::execution_category
template<>
using executor_parameters_type = typename BaseExecutor::executor_parameters_type
template<>
using future_type = typename hpx::parallel::execution::executor_future<BaseExecutor, Result>::type

Public Functions

template<typename F>
replay_executor(BaseExecutor &exec, std::size_t n, F &&f)
bool operator==(replay_executor const &rhs) const
bool operator!=(replay_executor const &rhs) const
replay_executor const &context() const
template<typename F, typename ...Ts>
decltype(auto) async_execute(F &&f, Ts&&... ts) const
template<typename F, typename S, typename ...Ts>
decltype(auto) bulk_async_execute(F &&f, S const &shape, Ts&&... ts) const

Public Static Attributes

constexpr int num_spread = 4
constexpr int num_tasks = 128

Private Members

BaseExecutor &exec_
std::size_t replay_count_
Validate validator_

Header hpx/resiliency/replicate_executor.hpp

namespace hpx
namespace resiliency
namespace experimental

Functions

template<typename BaseExecutor, typename Voter, typename Validate>
replicate_executor<BaseExecutor, typename std::decay<Voter>::type, typename std::decay<Validate>::type> make_replicate_executor(BaseExecutor &exec, std::size_t n, Voter &&voter, Validate &&validate)
template<typename BaseExecutor, typename Validate>
replicate_executor<BaseExecutor, detail::replicate_voter, typename std::decay<Validate>::type> make_replicate_executor(BaseExecutor &exec, std::size_t n, Validate &&validate)
template<typename BaseExecutor>
replicate_executor<BaseExecutor, detail::replicate_voter, detail::replicate_validator> make_replicate_executor(BaseExecutor &exec, std::size_t n)
template<typename BaseExecutor, typename Vote, typename Validate>
class replicate_executor
#include <replicate_executor.hpp>

Public Types

template<>
using execution_category = typename BaseExecutor::execution_category
template<>
using executor_parameters_type = typename BaseExecutor::executor_parameters_type
template<>
using future_type = typename hpx::parallel::execution::executor_future<BaseExecutor, Result>::type

Public Functions

template<typename V, typename F>
replicate_executor(BaseExecutor &exec, std::size_t n, V &&v, F &&f)
bool operator==(replicate_executor const &rhs) const
bool operator!=(replicate_executor const &rhs) const
replicate_executor const &context() const
template<typename F, typename ...Ts>
decltype(auto) async_execute(F &&f, Ts&&... ts) const
template<typename F, typename S, typename ...Ts>
decltype(auto) bulk_async_execute(F &&f, S const &shape, Ts&&... ts) const

Public Static Attributes

constexpr int num_spread = 4
constexpr int num_tasks = 128

Private Members

BaseExecutor &exec_
std::size_t replicate_count_
Vote voter_
Validate validator_

Header hpx/resiliency/resiliency.hpp

Header hpx/resiliency/resiliency_cpos.hpp

namespace hpx
namespace resiliency
namespace experimental
struct async_replay_t : public hpx::functional::tag<async_replay_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching given function f repeatedly. Repeat launching on error exactly n times (except if abort_replay_exception is thrown).

struct async_replay_validate_t : public hpx::functional::tag<async_replay_validate_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f. repeatedly. 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).

struct async_replicate_t : public hpx::functional::tag<async_replicate_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f exactly n times concurrently. Verify the result of those invocations by checking for exception. Return the first valid result.

struct async_replicate_validate_t : public hpx::functional::tag<async_replicate_validate_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f exactly n times concurrently. Verify the result of those invocations using the given predicate pred. Return the first valid result.

struct async_replicate_vote_t : public hpx::functional::tag<async_replicate_vote_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f exactly n times concurrently. 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.

struct async_replicate_vote_validate_t : public hpx::functional::tag<async_replicate_vote_validate_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f exactly n times concurrently. 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.

struct dataflow_replay_t : public hpx::resiliency::experimental::tag_deferred<dataflow_replay_t, async_replay_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f. repeatedly. Repeat launching on error exactly n times.

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

struct dataflow_replay_validate_t : public hpx::resiliency::experimental::tag_deferred<dataflow_replay_validate_t, async_replay_validate_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f. repeatedly. 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.

struct dataflow_replicate_t : public hpx::resiliency::experimental::tag_deferred<dataflow_replicate_t, async_replicate_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f exactly n times concurrently. Return the first valid result.

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

struct dataflow_replicate_validate_t : public hpx::resiliency::experimental::tag_deferred<dataflow_replicate_validate_t, async_replicate_validate_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f exactly n times concurrently. 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.

struct dataflow_replicate_vote_t : public hpx::resiliency::experimental::tag_deferred<dataflow_replicate_vote_t, async_replicate_vote_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f exactly n times concurrently. 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.

struct dataflow_replicate_vote_validate_t : public hpx::resiliency::experimental::tag_deferred<dataflow_replicate_vote_validate_t, async_replicate_vote_validate_t>
#include <resiliency_cpos.hpp>

Customization point for asynchronously launching the given function f exactly n times concurrently. 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 Tag, typename BaseTag>
struct tag_deferred : public hpx::functional::tag<Tag>
#include <resiliency_cpos.hpp>

Friends

template<typename ...Args>
auto tag_invoke(Tag, Args&&... args)

Header 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
namespace experimental

Functions

unsigned int major_version()
unsigned int minor_version()
unsigned int subminor_version()
unsigned long full_version()
std::string full_version_str()