basic_execution

#include <compatibility/hpx/util/register_locks.hpp>

#include <hpx/basic_execution.hpp>

#include <hpx/basic_execution/this_thread.hpp>

namespace hpx

namespace basic_execution

namespace this_thread

Functions

hpx::basic_execution::agent_ref agent()

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

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

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

template <typename Rep, typename Period>
void sleep_for(std::chrono::duration<Rep, Period> const &sleep_duration, char const *desc = "hpx::basic_execution::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::basic_execution::this_thread::sleep_for")

struct reset_agent

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_

#include <hpx/basic_execution/context_base.hpp>

namespace hpx

namespace basic_execution

struct context_base

Public Functions

virtual ~context_base()

virtual resource_base const &resource() const = 0

#include <hpx/basic_execution/agent_base.hpp>

namespace hpx

namespace basic_execution

struct agent_base

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

#include <hpx/basic_execution/register_locks.hpp>

namespace hpx

namespace util

Functions

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

bool unregister_lock(void const *)

void verify_no_locks()

void force_error_on_lock()

void enable_lock_detection()

void ignore_lock(void const *)

void reset_ignored(void const *)

void ignore_all_locks()

void reset_ignored_all()

struct ignore_all_while_checking

Public Functions

ignore_all_while_checking()

template <typename Lock, typename Enable>
struct ignore_while_checking

Public Functions

ignore_while_checking(void const *)

#include <hpx/basic_execution/agent_ref.hpp>

namespace hpx

namespace basic_execution

class agent_ref

Public Functions

constexpr agent_ref()

constexpr agent_ref(agent_base *impl)

constexpr agent_ref(agent_ref const&)

HPX_CXX14_CONSTEXPR agent_ref& hpx::basic_execution::agent_ref::operator=(agent_ref const &)

constexpr agent_ref(agent_ref&&)

HPX_CXX14_CONSTEXPR agent_ref& hpx::basic_execution::agent_ref::operator=(agent_ref &&)

constexpr operator bool() const

void reset(agent_base *impl = nullptr)

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

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

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

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

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

template <typename Rep, typename Period>
void sleep_for(std::chrono::duration<Rep, Period> const &sleep_duration, char const *desc = "hpx::basic_execution::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::basic_execution::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&)

#include <hpx/basic_execution/resource_base.hpp>

namespace hpx

namespace basic_execution

struct resource_base

#include <resource_base.hpp>

TODO: implement, this is currently just a dummy.

Public Functions

virtual ~resource_base()