timed_execution

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

namespace hpx
namespace parallel
namespace execution

Variables

hpx::parallel::execution::post_at_t post_at
hpx::parallel::execution::post_after_t post_after
hpx::parallel::execution::async_execute_at_t async_execute_at
hpx::parallel::execution::async_execute_after_t async_execute_after
hpx::parallel::execution::sync_execute_at_t sync_execute_at
hpx::parallel::execution::sync_execute_after_t sync_execute_after
struct async_execute_after_t : public hpx::functional::tag_fallback<async_execute_after_t>
#include <timed_execution_fwd.hpp>

Customization point of asynchronous execution agent creation supporting timed execution.

This asynchronously creates a single function invocation f() using the associated executor at the given point in time.

Return

f(ts…)’s result through a future

Note

This calls exec.async_execute_after(rel_time, f, ts…), if available, otherwise it emulates timed scheduling by delaying calling execution::async_execute() on the underlying non-time-scheduled execution agent.

Parameters

  • exec: [in] The executor object to use for scheduling of the function f.

  • rel_time: [in] The duration of time after which the given function should be scheduled to run.

  • f: [in] The function which will be scheduled using the given executor.

  • ts...: [in] Additional arguments to use to invoke f.

Private Functions

template<typename Executor, typename F, typename ...Ts>
decltype(auto) friend tag_fallback_dispatch(async_execute_after_t, Executor &&exec, hpx::chrono::steady_duration const &rel_time, F &&f, Ts&&... ts)
struct async_execute_at_t : public hpx::functional::tag_fallback<async_execute_at_t>
#include <timed_execution_fwd.hpp>

Customization point of asynchronous execution agent creation supporting timed execution.

This asynchronously creates a single function invocation f() using the associated executor at the given point in time.

Return

f(ts…)’s result through a future

Note

This calls exec.async_execute_at(abs_time, f, ts…), if available, otherwise it emulates timed scheduling by delaying calling execution::async_execute() on the underlying non-time-scheduled execution agent.

Parameters

  • exec: [in] The executor object to use for scheduling of the function f.

  • abs_time: [in] The point in time the given function should be scheduled at to run.

  • f: [in] The function which will be scheduled using the given executor.

  • ts...: [in] Additional arguments to use to invoke f.

Private Functions

template<typename Executor, typename F, typename ...Ts>
decltype(auto) friend tag_fallback_dispatch(async_execute_at_t, Executor &&exec, hpx::chrono::steady_time_point const &abs_time, F &&f, Ts&&... ts)
struct post_after_t : public hpx::functional::tag_fallback<post_after_t>
#include <timed_execution_fwd.hpp>

Customization point of asynchronous fire & forget execution agent creation supporting timed execution.

This asynchronously (fire & forget) creates a single function invocation f() using the associated executor at the given point in time.

Note

This calls exec.post_after(rel_time, f, ts…), if available, otherwise it emulates timed scheduling by delaying calling execution::post() on the underlying non-time-scheduled execution agent.

Parameters

  • exec: [in] The executor object to use for scheduling of the function f.

  • rel_time: [in] The duration of time after which the given function should be scheduled to run.

  • f: [in] The function which will be scheduled using the given executor.

  • ts...: [in] Additional arguments to use to invoke f.

Private Functions

template<typename Executor, typename F, typename ...Ts>
decltype(auto) friend tag_fallback_dispatch(post_after_t, Executor &&exec, hpx::chrono::steady_duration const &rel_time, F &&f, Ts&&... ts)
struct post_at_t : public hpx::functional::tag_fallback<post_at_t>
#include <timed_execution_fwd.hpp>

Customization point of asynchronous fire & forget execution agent creation supporting timed execution.

This asynchronously (fire & forget) creates a single function invocation f() using the associated executor at the given point in time.

Note

This calls exec.post_at(abs_time, f, ts…), if available, otherwise it emulates timed scheduling by delaying calling execution::post() on the underlying non-time-scheduled execution agent.

Parameters

  • exec: [in] The executor object to use for scheduling of the function f.

  • abs_time: [in] The point in time the given function should be scheduled at to run.

  • f: [in] The function which will be scheduled using the given executor.

  • ts...: [in] Additional arguments to use to invoke f.

Private Functions

template<typename Executor, typename F, typename ...Ts>
decltype(auto) friend tag_fallback_dispatch(post_at_t, Executor &&exec, hpx::chrono::steady_time_point const &abs_time, F &&f, Ts&&... ts)
struct sync_execute_after_t : public hpx::functional::tag_fallback<sync_execute_after_t>
#include <timed_execution_fwd.hpp>

Customization point of synchronous execution agent creation supporting timed execution.

This synchronously creates a single function invocation f() using the associated executor at the given point in time.

Return

f(ts…)’s result

Note

This calls exec.sync_execute_after(rel_time, f, ts…), if available, otherwise it emulates timed scheduling by delaying calling execution::sync_execute() on the underlying non-time-scheduled execution agent.

Parameters

  • exec: [in] The executor object to use for scheduling of the function f.

  • rel_time: [in] The duration of time after which the given function should be scheduled to run.

  • f: [in] The function which will be scheduled using the given executor.

  • ts...: [in] Additional arguments to use to invoke f.

Private Functions

template<typename Executor, typename F, typename ...Ts>
decltype(auto) friend tag_fallback_dispatch(sync_execute_after_t, Executor &&exec, hpx::chrono::steady_duration const &rel_time, F &&f, Ts&&... ts)
struct sync_execute_at_t : public hpx::functional::tag_fallback<sync_execute_at_t>
#include <timed_execution_fwd.hpp>

Customization point of synchronous execution agent creation supporting timed execution.

This synchronously creates a single function invocation f() using the associated executor at the given point in time.

Return

f(ts…)’s result

Note

This calls exec.sync_execute_at(abs_time, f, ts…), if available, otherwise it emulates timed scheduling by delaying calling execution::sync_execute() on the underlying non-time-scheduled execution agent.

Parameters

  • exec: [in] The executor object to use for scheduling of the function f.

  • abs_time: [in] The point in time the given function should be scheduled at to run.

  • f: [in] The function which will be scheduled using the given executor.

  • ts...: [in] Additional arguments to use to invoke f.

Private Functions

template<typename Executor, typename F, typename ...Ts>
decltype(auto) friend tag_fallback_dispatch(sync_execute_at_t, Executor &&exec, hpx::chrono::steady_time_point const &abs_time, F &&f, Ts&&... ts)
namespace hpx
namespace parallel
namespace execution

Typedefs

using sequenced_timed_executor = timed_executor<hpx::execution::sequenced_executor>
using parallel_timed_executor = timed_executor<hpx::execution::parallel_executor>
template<typename BaseExecutor>
struct timed_executor

Public Types

typedef std::decay<BaseExecutor>::type base_executor_type
typedef hpx::traits::executor_execution_category<base_executor_type>::type execution_category
typedef hpx::traits::executor_parameters_type<base_executor_type>::type parameters_type

Public Functions

timed_executor(hpx::chrono::steady_time_point const &abs_time)
timed_executor(hpx::chrono::steady_duration const &rel_time)
template<typename Executor>
timed_executor(Executor &&exec, hpx::chrono::steady_time_point const &abs_time)
template<typename Executor>
timed_executor(Executor &&exec, hpx::chrono::steady_duration const &rel_time)
template<typename F, typename ...Ts>
hpx::util::detail::invoke_deferred_result<F, Ts...>::type sync_execute(F &&f, Ts&&... ts)
template<typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> async_execute(F &&f, Ts&&... ts)
template<typename F, typename ...Ts>
void post(F &&f, Ts&&... ts)

Public Members

BaseExecutor exec_
std::chrono::steady_clock::time_point execute_at_
namespace hpx
namespace parallel
namespace execution

Typedefs

template<typename T>
using is_timed_executor_t = typename is_timed_executor<T>::type

Variables

template<typename T>HPX_INLINE_CONSTEXPR_VARIABLE bool hpx::parallel::execution::is_timed_executor_v=is_timed_executor<T>::value