async_distributed

The contents of this module can be included with the header hpx/modules/async_distributed.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/async_distributed.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/async.hpp

Header hpx/async_distributed/applier/applier.hpp

Header hpx/async_distributed/applier/apply.hpp

namespace hpx

Functions

template<typename Action, typename ...Ts>
bool apply_p(naming::id_type const &id, threads::thread_priority priority, Ts&&... vs)

template<typename Action, typename Client, typename Stub, typename ...Ts>
bool apply_p(components::client_base<Client, Stub> const &c, threads::thread_priority priority, Ts&&... vs)

template<typename Action, typename DistPolicy, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, bool>::type apply_p(DistPolicy const &policy, threads::thread_priority priority, Ts&&... vs)

template<typename Action, typename ...Ts>
bool apply(naming::id_type const &id, Ts&&... vs)

template<typename Action, typename Client, typename Stub, typename ...Ts>
bool apply(components::client_base<Client, Stub> const &c, Ts&&... vs)

template<typename Action, typename DistPolicy, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, bool>::type apply(DistPolicy const &policy, Ts&&... vs)

template<typename Action, typename Continuation, typename ...Ts>
std::enable_if<traits::is_continuation<Continuation>::value, bool>::type apply_p(Continuation &&c, naming::id_type const &gid, threads::thread_priority priority, Ts&&... vs)

template<typename Action, typename Continuation, typename Client, typename Stub, typename ...Ts>
std::enable_if<traits::is_continuation<Continuation>::value, bool>::type apply_p(Continuation &&cont, components::client_base<Client, Stub> const &c, threads::thread_priority priority, Ts&&... vs)

template<typename Action, typename Continuation, typename DistPolicy, typename ...Ts>
std::enable_if<traits::is_continuation<Continuation>::value && traits::is_distribution_policy<DistPolicy>::value, bool>::type apply_p(Continuation &&c, DistPolicy const &policy, threads::thread_priority priority, Ts&&... vs)

template<typename Action, typename Continuation, typename ...Ts>
std::enable_if<traits::is_continuation<Continuation>::value, bool>::type apply(Continuation &&c, naming::id_type const &gid, Ts&&... vs)

template<typename Action, typename Continuation, typename Client, typename Stub, typename ...Ts>
std::enable_if<traits::is_continuation<Continuation>::value, bool>::type apply(Continuation &&cont, components::client_base<Client, Stub> const &c, Ts&&... vs)

template<typename Action, typename Continuation, typename DistPolicy, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value && traits::is_continuation<Continuation>::value, bool>::type apply(Continuation &&c, DistPolicy const &policy, Ts&&... vs)

template<typename Action, typename ...Ts>
bool apply_c_p(naming::id_type const &contgid, naming::id_type const &gid, threads::thread_priority priority, Ts&&... vs)

template<typename Action, typename ...Ts>
bool apply_c(naming::id_type const &contgid, naming::id_type const &gid, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename ...Ts>
bool apply_c(hpx::actions::basic_action<Component, Signature, Derived>, naming::id_type const &contgid, naming::id_type const &gid, Ts&&... vs)

Header hpx/async_distributed/applier/apply_callback.hpp

namespace hpx

Functions

template<typename Action, typename Callback, typename ...Ts>
bool apply_p_cb(naming::id_type const &gid, threads::thread_priority priority, Callback &&cb, Ts&&... vs)

template<typename Action, typename Callback, typename ...Ts>
bool apply_cb(naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename Callback, typename ...Ts>
bool apply_cb(hpx::actions::basic_action<Component, Signature, Derived>, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Action, typename DistPolicy, typename Callback, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, bool>::type apply_p_cb(DistPolicy const &policy, threads::thread_priority priority, Callback &&cb, Ts&&... vs)

template<typename Action, typename DistPolicy, typename Callback, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, bool>::type apply_cb(DistPolicy const &policy, Callback &&cb, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename DistPolicy, typename Callback, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, bool>::type apply_cb(hpx::actions::basic_action<Component, Signature, Derived>, DistPolicy const &policy, Callback &&cb, Ts&&... vs)

template<typename Action, typename Continuation, typename Callback, typename ...Ts>
bool apply_p_cb(Continuation &&c, naming::address &&addr, naming::id_type const &gid, threads::thread_priority priority, Callback &&cb, Ts&&... vs)

template<typename Action, typename Continuation, typename Callback, typename ...Ts>
bool apply_p_cb(Continuation &&c, naming::id_type const &gid, threads::thread_priority priority, Callback &&cb, Ts&&... vs)

template<typename Action, typename Continuation, typename Callback, typename ...Ts>
bool apply_cb(Continuation &&c, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Component, typename Continuation, typename Signature, typename Derived, typename Callback, typename ...Ts>
bool apply_cb(Continuation &&c, hpx::actions::basic_action<Component, Signature, Derived>, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Action, typename Continuation, typename DistPolicy, typename Callback, typename ...Ts>
std::enable_if<traits::is_continuation<Continuation>::value && traits::is_distribution_policy<DistPolicy>::value, bool>::type apply_p_cb(Continuation &&c, DistPolicy const &policy, threads::thread_priority priority, Callback &&cb, Ts&&... vs)

template<typename Action, typename Continuation, typename DistPolicy, typename Callback, typename ...Ts>
std::enable_if<traits::is_continuation<Continuation>::value && traits::is_distribution_policy<DistPolicy>::value, bool>::type apply_cb(Continuation &&c, DistPolicy const &policy, Callback &&cb, Ts&&... vs)

template<typename Component, typename Continuation, typename Signature, typename Derived, typename DistPolicy, typename Callback, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, bool>::type apply_cb(Continuation &&c, hpx::actions::basic_action<Component, Signature, Derived>, DistPolicy const &policy, Callback &&cb, Ts&&... vs)

template<typename Action, typename Callback, typename ...Ts>
bool apply_c_p_cb(naming::id_type const &contgid, naming::id_type const &gid, threads::thread_priority priority, Callback &&cb, Ts&&... vs)

template<typename Action, typename Callback, typename ...Ts>
bool apply_c_cb(naming::id_type const &contgid, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Action, typename Callback, typename ...Ts>
bool apply_c_p_cb(naming::id_type const &contgid, naming::address &&addr, naming::id_type const &gid, threads::thread_priority priority, Callback &&cb, Ts&&... vs)

template<typename Action, typename Callback, typename ...Ts>
bool apply_c_cb(naming::id_type const &contgid, naming::address &&addr, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

namespace functional

Functions

template<typename Action, typename Callback, typename ...Ts>
apply_c_p_cb_impl<Action, typename util::decay<Callback>::type, typename util::decay<Ts>::type...> apply_c_p_cb(naming::id_type const &contid, naming::address &&addr, naming::id_type const &id, threads::thread_priority p, Callback &&cb, Ts&&... vs)

template<typename Action, typename Callback, typename ...Ts>
struct apply_c_p_cb_impl

#include <apply_callback.hpp>

Public Types

typedef util::tuple<Ts...> tuple_type

Public Functions

template<typename ...Ts_>
apply_c_p_cb_impl(naming::id_type const &contid, naming::address &&addr, naming::id_type const &id, threads::thread_priority p, Callback &&cb, Ts_&&... vs)

apply_c_p_cb_impl(apply_c_p_cb_impl &&rhs)

apply_c_p_cb_impl &operator=(apply_c_p_cb_impl &&rhs)

void operator()()

Protected Functions

template<std::size_t... Is>
void apply_action(util::index_pack<Is...>)

Private Members

naming::id_type contid_

naming::address addr_

naming::id_type id_

threads::thread_priority p_

Callback cb_

tuple_type args_

Header hpx/async_distributed/applier/apply_continue.hpp

namespace hpx

Functions

template<typename Action, typename Cont, typename ...Ts>
bool apply_continue(Cont &&cont, naming::id_type const &gid, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename Cont, typename ...Ts>
bool apply_continue(hpx::actions::basic_action<Component, Signature, Derived>, Cont &&cont, naming::id_type const &gid, Ts&&... vs)

template<typename Action, typename ...Ts>
bool apply_continue(naming::id_type const &cont, naming::id_type const &gid, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename ...Ts>
bool apply_continue(hpx::actions::basic_action<Component, Signature, Derived>, naming::id_type const &cont, naming::id_type const &gid, Ts&&... vs)

Header hpx/async_distributed/applier/apply_continue_callback.hpp

namespace hpx

Functions

template<typename Action, typename Cont, typename Callback, typename ...Ts>
bool apply_continue_cb(Cont &&cont, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename Cont, typename Callback, typename ...Ts>
bool apply_continue_cb(hpx::actions::basic_action<Component, Signature, Derived>, Cont &&cont, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Action, typename Callback, typename ...Ts>
bool apply_continue_cb(naming::id_type const &cont, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename Callback, typename ...Ts>
bool apply_continue_cb(hpx::actions::basic_action<Component, Signature, Derived>, naming::id_type const &cont, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

Header hpx/async_distributed/applier/apply_continue_fwd.hpp

Header hpx/async_distributed/applier/apply_helper.hpp

namespace hpx

Functions

bool is_pre_startup()

Header hpx/async_distributed/applier/bind_naming_wrappers.hpp

namespace hpx

namespace applier

Functions

bool bind_gid_local(naming::gid_type const&, naming::address const&, error_code &ec = throws)

void unbind_gid_local(naming::gid_type const&, error_code &ec = throws)

bool bind_range_local(naming::gid_type const&, std::size_t, naming::address const&, std::size_t, error_code &ec = throws)

void unbind_range_local(naming::gid_type const&, std::size_t, error_code &ec = throws)

Header hpx/async_distributed/applier/register_apply_colocated.hpp

Defines

HPX_REGISTER_APPLY_COLOCATED_DECLARATION(Action, Name)

HPX_REGISTER_APPLY_COLOCATED(action, name)

Header hpx/async_distributed/applier/trigger.hpp

namespace hpx

namespace applier

Functions

template<typename Arg0>
void trigger(naming::id_type const &k, Arg0 &&arg0)

void trigger(naming::id_type const &k)

void trigger_error(naming::id_type const &k, std::exception_ptr const &e)

void trigger_error(naming::id_type const &k, std::exception_ptr &&e)

Header hpx/async_distributed/applier_fwd.hpp

namespace hpx

namespace applier

Functions

applier &get_applier()

The function get_applier returns a reference to the (thread specific) applier instance.

applier *get_applier_ptr()

The function get_applier returns a pointer to the (thread specific) applier instance. The returned pointer is NULL if the current thread is not known to HPX or if the runtime system is not active.

namespace applier

The namespace applier contains all definitions needed for the class hpx::applier::applier and its related functionality. This namespace is part of the HPX core module.

Header hpx/async_distributed/apply.hpp

Header hpx/async_distributed/async.hpp

namespace hpx

Functions

template<typename Action, typename F, typename ...Ts>
auto async(F &&f, Ts&&... ts)

Header hpx/async_distributed/async_callback.hpp

namespace hpx

Functions

template<typename Action, typename F, typename ...Ts>
auto async_cb(F &&f, Ts&&... ts)

template<typename F, typename ...Ts>
auto async_cb(F &&f, Ts&&... ts)

Header hpx/async_distributed/async_callback_fwd.hpp

Header hpx/async_distributed/async_continue.hpp

namespace hpx

Functions

template<typename Action, typename Cont, typename ...Ts>
lcos::future<typename traits::promise_local_result<typename detail::result_of_async_continue<Action, Cont>::type>::type> async_continue(Cont &&cont, naming::id_type const &gid, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename Cont, typename ...Ts>
lcos::future<typename traits::promise_local_result<typename detail::result_of_async_continue<Derived, Cont>::type>::type> async_continue(hpx::actions::basic_action<Component, Signature, Derived>, Cont &&cont, naming::id_type const &gid, Ts&&... vs)

template<typename Action, typename Cont, typename DistPolicy, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, lcos::future<typename traits::promise_local_result<typename detail::result_of_async_continue<Action, Cont>::type>::type>>::type async_continue(Cont &&cont, DistPolicy const &policy, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename Cont, typename DistPolicy, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, lcos::future<typename traits::promise_local_result<typename detail::result_of_async_continue<Derived, Cont>::type>::type>>::type async_continue(hpx::actions::basic_action<Component, Signature, Derived>, Cont &&cont, DistPolicy const &policy, Ts&&... vs)

Header hpx/async_distributed/async_continue_callback.hpp

namespace hpx

Functions

template<typename Action, typename Cont, typename Callback, typename ...Ts>
lcos::future<typename traits::promise_local_result<typename detail::result_of_async_continue<Action, Cont>::type>::type> async_continue_cb(Cont &&cont, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename Cont, typename Callback, typename ...Ts>
lcos::future<typename traits::promise_local_result<typename detail::result_of_async_continue<Derived, Cont>::type>::type> async_continue_cb(hpx::actions::basic_action<Component, Signature, Derived>, Cont &&cont, naming::id_type const &gid, Callback &&cb, Ts&&... vs)

template<typename Action, typename Cont, typename DistPolicy, typename Callback, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, lcos::future<typename traits::promise_local_result<typename detail::result_of_async_continue<Action, Cont>::type>::type>>::type async_continue_cb(Cont &&cont, DistPolicy const &policy, Callback &&cb, Ts&&... vs)

template<typename Component, typename Signature, typename Derived, typename Cont, typename DistPolicy, typename Callback, typename ...Ts>
std::enable_if<traits::is_distribution_policy<DistPolicy>::value, lcos::future<typename traits::promise_local_result<typename detail::result_of_async_continue<Derived, Cont>::type>::type>>::type async_continue_cb(hpx::actions::basic_action<Component, Signature, Derived>, Cont &&cont, DistPolicy const &policy, Callback &&cb, Ts&&... vs)

Header hpx/async_distributed/async_continue_callback_fwd.hpp

Header hpx/async_distributed/async_continue_fwd.hpp

Header hpx/async_distributed/dataflow.hpp

namespace hpx

Functions

template<typename Action, typename T0, typename ...Ts, typename Enable = typename std::enable_if<traits::is_action<Action>::value>::type>
auto dataflow(T0 &&t0, Ts&&... ts)

template<typename Action, typename Allocator, typename T0, typename ...Ts, typename Enable = typename std::enable_if<traits::is_action<Action>::value>::type>
auto dataflow_alloc(Allocator const &alloc, T0 &&t0, Ts&&... ts)

Header hpx/async_distributed/sync.hpp

namespace hpx

Functions

template<typename Action, typename F, typename ...Ts>
auto sync(F &&f, Ts&&... ts)

Header hpx/modules/async_distributed.hpp