execution_base

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

namespace hpx

namespace execution_base

struct agent_base

#include <agent_base.hpp>

Public Functions

virtual ~agent_base()

virtual std::string description() const = 0

virtual context_base const &context() const = 0

virtual void yield(char const *desc) = 0

virtual void yield_k(std::size_t k, char const *desc) = 0

virtual void suspend(char const *desc) = 0

virtual void resume(char const *desc) = 0

virtual void abort(char const *desc) = 0

virtual void sleep_for(hpx::util::steady_duration const &sleep_duration, char const *desc) = 0

virtual void sleep_until(hpx::util::steady_time_point const &sleep_time, char const *desc) = 0

Header hpx/execution_base/agent_ref.hpp

namespace hpx

namespace execution_base

class agent_ref

#include <agent_ref.hpp>

Public Functions

constexpr agent_ref()

constexpr agent_ref(agent_base *impl)

constexpr agent_ref(agent_ref const&)

constexpr agent_ref &operator=(agent_ref const&)

constexpr agent_ref(agent_ref&&)

constexpr agent_ref &operator=(agent_ref&&)

constexpr operator bool() const

void reset(agent_base *impl = nullptr)

void yield(char const *desc = "hpx::execution_base::agent_ref::yield")

void yield_k(std::size_t k, char const *desc = "hpx::execution_base::agent_ref::yield_k")

void suspend(char const *desc = "hpx::execution_base::agent_ref::suspend")

void resume(char const *desc = "hpx::execution_base::agent_ref::resume")

void abort(char const *desc = "hpx::execution_base::agent_ref::abort")

template<typename Rep, typename Period>
void sleep_for(std::chrono::duration<Rep, Period> const &sleep_duration, char const *desc = "hpx::execution_base::agent_ref::sleep_for")

template<typename Clock, typename Duration>
void sleep_until(std::chrono::time_point<Clock, Duration> const &sleep_time, char const *desc = "hpx::execution_base::agent_ref::sleep_until")

agent_base &ref()

Private Functions

void sleep_for(hpx::util::steady_duration const &sleep_duration, char const *desc)

void sleep_until(hpx::util::steady_time_point const &sleep_time, char const *desc)

Private Members

agent_base *impl_

Friends

constexpr bool operator==(agent_ref const &lhs, agent_ref const &rhs)

constexpr bool operator!=(agent_ref const &lhs, agent_ref const &rhs)

std::ostream &operator<<(std::ostream&, agent_ref const&)

Header hpx/execution_base/context_base.hpp

namespace hpx

namespace execution_base

struct context_base

#include <context_base.hpp>

Public Functions

virtual ~context_base()

virtual resource_base const &resource() const = 0

Header hpx/execution_base/execution.hpp

namespace hpx

namespace parallel

namespace execution

struct parallel_execution_tag

#include <execution.hpp>

Function invocations executed by a group of parallel execution agents execute in unordered fashion. Any such invocations executing in the same thread are indeterminately sequenced with respect to each other.

Note

parallel_execution_tag is weaker than sequenced_execution_tag.

struct sequenced_execution_tag

#include <execution.hpp>

Function invocations executed by a group of sequential execution agents execute in sequential order.

struct unsequenced_execution_tag

#include <execution.hpp>

Function invocations executed by a group of vector execution agents are permitted to execute in unordered fashion when executed in different threads, and un-sequenced with respect to one another when executed in the same thread.

Note

unsequenced_execution_tag is weaker than parallel_execution_tag.

Header hpx/execution_base/register_locks.hpp

namespace hpx

namespace util

Functions

constexpr bool register_lock(void const*, util::register_lock_data* = nullptr)

constexpr bool unregister_lock(void const*)

constexpr void verify_no_locks()

constexpr void force_error_on_lock()

constexpr void enable_lock_detection()

constexpr void disable_lock_detection()

constexpr void trace_depth_lock_detection(std::size_t)

constexpr void ignore_lock(void const*)

constexpr void reset_ignored(void const*)

constexpr void ignore_all_locks()

constexpr void reset_ignored_all()

std::unique_ptr<held_locks_data> get_held_locks_data()

constexpr void set_held_locks_data(std::unique_ptr<held_locks_data>&&)

struct ignore_all_while_checking

#include <register_locks.hpp>

Public Functions

ignore_all_while_checking()

template<typename Lock, typename Enable>
struct ignore_while_checking

#include <register_locks.hpp>

Public Functions

ignore_while_checking(void const*)

Header hpx/execution_base/resource_base.hpp

namespace hpx

namespace execution_base

struct resource_base

#include <resource_base.hpp>

TODO: implement, this is currently just a dummy.

Public Functions

virtual ~resource_base()

Header hpx/execution_base/this_thread.hpp

namespace hpx

namespace execution_base

namespace this_thread

Functions

hpx::execution_base::agent_ref agent()

void yield(char const *desc = "hpx::execution_base::this_thread::yield")

void yield_k(std::size_t k, char const *desc = "hpx::execution_base::this_thread::yield_k")

void suspend(char const *desc = "hpx::execution_base::this_thread::suspend")

template<typename Rep, typename Period>
void sleep_for(std::chrono::duration<Rep, Period> const &sleep_duration, char const *desc = "hpx::execution_base::this_thread::sleep_for")

template<class Clock, class Duration>
void sleep_until(std::chrono::time_point<Clock, Duration> const &sleep_time, char const *desc = "hpx::execution_base::this_thread::sleep_for")

struct reset_agent

#include <this_thread.hpp>

Public Functions

reset_agent(detail::agent_storage*, agent_base &impl)

reset_agent(agent_base &impl)

~reset_agent()

Public Members

detail::agent_storage *storage_

agent_base *old_

namespace util

Functions

template<typename Predicate>
void yield_while(Predicate &&predicate, const char *thread_name = nullptr, bool allow_timed_suspension = true)