basic_execution

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

#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/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/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/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&)
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::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/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 <compatibility/hpx/util/register_locks.hpp>