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

Variables

hpx::resiliency::experimental::async_replay_validate_t async_replay_validate

hpx::resiliency::experimental::async_replay_t async_replay

hpx::resiliency::experimental::dataflow_replay_validate_t dataflow_replay_validate

hpx::resiliency::experimental::dataflow_replay_t dataflow_replay

hpx::resiliency::experimental::async_replicate_vote_validate_t async_replicate_vote_validate

hpx::resiliency::experimental::async_replicate_vote_t async_replicate_vote

hpx::resiliency::experimental::async_replicate_validate_t async_replicate_validate

hpx::resiliency::experimental::async_replicate_t async_replicate

hpx::resiliency::experimental::dataflow_replicate_vote_validate_t dataflow_replicate_vote_validate

hpx::resiliency::experimental::dataflow_replicate_vote_t dataflow_replicate_vote

hpx::resiliency::experimental::dataflow_replicate_validate_t dataflow_replicate_validate

hpx::resiliency::experimental::dataflow_replicate_t dataflow_replicate

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()