components_base

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

namespace hpx
namespace agas

Functions

bool is_console()
bool register_name(launch::sync_policy, std::string const &name, naming::gid_type const &gid, error_code &ec = throws)
bool register_name(launch::sync_policy, std::string const &name, naming::id_type const &id, error_code &ec = throws)
hpx::future<bool> register_name(std::string const &name, naming::id_type const &id)
naming::id_type unregister_name(launch::sync_policy, std::string const &name, error_code &ec = throws)
hpx::future<naming::id_type> unregister_name(std::string const &name)
naming::id_type resolve_name(launch::sync_policy, std::string const &name, error_code &ec = throws)
hpx::future<naming::id_type> resolve_name(std::string const &name)
hpx::future<std::uint32_t> get_num_localities(naming::component_type type = naming::component_invalid)
std::uint32_t get_num_localities(launch::sync_policy, naming::component_type type, error_code &ec = throws)
std::uint32_t get_num_localities(launch::sync_policy, error_code &ec = throws)
std::string get_component_type_name(naming::component_type type, error_code &ec = throws)
hpx::future<std::vector<std::uint32_t>> get_num_threads()
std::vector<std::uint32_t> get_num_threads(launch::sync_policy, error_code &ec = throws)
hpx::future<std::uint32_t> get_num_overall_threads()
std::uint32_t get_num_overall_threads(launch::sync_policy, error_code &ec = throws)
std::uint32_t get_locality_id(error_code &ec = throws)
hpx::naming::gid_type get_locality()
std::vector<std::uint32_t> get_all_locality_ids(naming::component_type type, error_code &ec = throws)
std::vector<std::uint32_t> get_all_locality_ids(error_code &ec = throws)
bool is_local_address_cached(naming::gid_type const &gid, error_code &ec = throws)
bool is_local_address_cached(naming::gid_type const &gid, naming::address &addr, error_code &ec = throws)
bool is_local_address_cached(naming::id_type const &id, error_code &ec = throws)
bool is_local_address_cached(naming::id_type const &id, naming::address &addr, error_code &ec = throws)
void update_cache_entry(naming::gid_type const &gid, naming::address const &addr, std::uint64_t count = 0, std::uint64_t offset = 0, error_code &ec = throws)
bool is_local_lva_encoded_address(naming::gid_type const &gid)
bool is_local_lva_encoded_address(naming::id_type const &id)
hpx::future<naming::address> resolve(naming::id_type const &id)
naming::address resolve(launch::sync_policy, naming::id_type const &id, error_code &ec = throws)
bool resolve_local(naming::gid_type const &gid, naming::address &addr, error_code &ec = throws)
bool resolve_cached(naming::gid_type const &gid, naming::address &addr)
hpx::future<bool> bind(naming::gid_type const &gid, naming::address const &addr, std::uint32_t locality_id)
bool bind(launch::sync_policy, naming::gid_type const &gid, naming::address const &addr, std::uint32_t locality_id, error_code &ec = throws)
hpx::future<bool> bind(naming::gid_type const &gid, naming::address const &addr, naming::gid_type const &locality_)
bool bind(launch::sync_policy, naming::gid_type const &gid, naming::address const &addr, naming::gid_type const &locality_, error_code &ec = throws)
hpx::future<naming::address> unbind(naming::gid_type const &gid, std::uint64_t count = 1)
naming::address unbind(launch::sync_policy, naming::gid_type const &gid, std::uint64_t count = 1, error_code &ec = throws)
bool bind_gid_local(naming::gid_type const &gid, naming::address const &addr, error_code &ec = throws)
void unbind_gid_local(naming::gid_type const &gid, error_code &ec = throws)
bool bind_range_local(naming::gid_type const &gid, std::size_t count, naming::address const &addr, std::size_t offset, error_code &ec = throws)
void unbind_range_local(naming::gid_type const &gid, std::size_t count, error_code &ec = throws)
void garbage_collect_non_blocking(error_code &ec = throws)
void garbage_collect(error_code &ec = throws)
void garbage_collect_non_blocking(naming::id_type const &id, error_code &ec = throws)

Invoke an asynchronous garbage collection step on the given target locality.

void garbage_collect(naming::id_type const &id, error_code &ec = throws)

Invoke a synchronous garbage collection step on the given target locality.

naming::id_type get_console_locality(error_code &ec = throws)

Return an id_type referring to the console locality.

naming::gid_type get_next_id(std::size_t count, error_code &ec = throws)
void decref(naming::gid_type const &id, std::int64_t credits, error_code &ec = throws)
hpx::future<std::int64_t> incref(naming::gid_type const &gid, std::int64_t credits, naming::id_type const &keep_alive = naming::invalid_id)
std::int64_t incref(launch::sync_policy, naming::gid_type const &gid, std::int64_t credits = 1, naming::id_type const &keep_alive = naming::invalid_id, error_code &ec = throws)
std::int64_t replenish_credits(naming::gid_type &gid)
hpx::future<naming::id_type> get_colocation_id(naming::id_type const &id)
naming::id_type get_colocation_id(launch::sync_policy, naming::id_type const &id, error_code &ec = throws)
hpx::future<hpx::id_type> on_symbol_namespace_event(std::string const &name, bool call_for_past_events)
hpx::future<std::pair<naming::id_type, naming::address>> begin_migration(naming::id_type const &id)
bool end_migration(naming::id_type const &id)
hpx::future<void> mark_as_migrated(naming::gid_type const &gid, util::unique_function_nonser<std::pair<bool, hpx::future<void>>()> &&fbool expect_to_be_marked_as_migrating, )
std::pair<bool, components::pinned_ptr> was_object_migrated(naming::gid_type const &gid, util::unique_function_nonser<components::pinned_ptr()> &&f)
void unmark_as_migrated(naming::gid_type const &gid)
hpx::future<std::map<std::string, hpx::id_type>> find_symbols(std::string const &pattern = "*")
std::map<std::string, hpx::id_type> find_symbols(hpx::launch::sync_policy, std::string const &pattern = "*")
naming::component_type register_factory(std::uint32_t prefix, std::string const &name, error_code &ec = throws)
naming::component_type get_component_id(std::string const &name, error_code &ec = throws)
void destroy_component(naming::gid_type const &gid, naming::address const &addr)

Defines

HPX_DEFINE_COMPONENT_COMMANDLINE_OPTIONS(add_options_function)
HPX_REGISTER_COMMANDLINE_MODULE(add_options_function)
HPX_REGISTER_COMMANDLINE_MODULE_DYNAMIC(add_options_function)
namespace hpx
namespace components
struct component_commandline : public component_commandline_base
#include <component_commandline.hpp>

The component_startup_shutdown provides a minimal implementation of a component’s startup/shutdown function provider.

Public Functions

hpx::program_options::options_description add_commandline_options()

Return any additional command line options valid for this component.

Return

The module is expected to fill a options_description object with any additional command line options this component will handle.

Note

This function will be executed by the runtime system during system startup.

namespace commandline_options_provider

Functions

hpx::program_options::options_description add_commandline_options()

Defines

HPX_DEFINE_COMPONENT_STARTUP_SHUTDOWN(startup_, shutdown_)
HPX_REGISTER_STARTUP_SHUTDOWN_MODULE_(startup, shutdown)
HPX_REGISTER_STARTUP_SHUTDOWN_MODULE(startup, shutdown)
HPX_REGISTER_STARTUP_SHUTDOWN_MODULE_DYNAMIC(startup, shutdown)
HPX_REGISTER_STARTUP_MODULE(startup)
HPX_REGISTER_STARTUP_MODULE_DYNAMIC(startup)
HPX_REGISTER_SHUTDOWN_MODULE(shutdown)
HPX_REGISTER_SHUTDOWN_MODULE_DYNAMIC(shutdown)
namespace hpx
namespace components
template<bool(*)(startup_function_type &, bool &) Startup, bool(*)(shutdown_function_type &, bool &) Shutdown> hpx::components::component_startup_shutdown : public component_startup_shutdown_base
#include <component_startup_shutdown.hpp>

The component_startup_shutdown class provides a minimal implementation of a component’s startup/shutdown function provider.

Public Functions

bool get_startup_function(startup_function_type &startup, bool &pre_startup)

Return any startup function for this component.

Return

Returns true if the parameter startup has been successfully initialized with the startup function.

Parameters
  • startup: [in, out] The module is expected to fill this function object with a reference to a startup function. This function will be executed by the runtime system during system startup.

bool get_shutdown_function(shutdown_function_type &shutdown, bool &pre_shutdown)

Return any startup function for this component.

Return

Returns true if the parameter shutdown has been successfully initialized with the shutdown function.

Parameters
  • shutdown: [in, out] The module is expected to fill this function object with a reference to a startup function. This function will be executed by the runtime system during system startup.

Defines

HPX_DEFINE_GET_COMPONENT_TYPE(component)
HPX_DEFINE_GET_COMPONENT_TYPE_TEMPLATE(template_, component)
HPX_DEFINE_GET_COMPONENT_TYPE_STATIC(component, type)
HPX_DEFINE_COMPONENT_NAME(...)
HPX_DEFINE_COMPONENT_NAME_(...)
HPX_DEFINE_COMPONENT_NAME_2(Component, name)
HPX_DEFINE_COMPONENT_NAME_3(Component, name, base_name)
namespace hpx
namespace components

Typedefs

using component_deleter_type = void (*)(hpx::naming::gid_type const&, hpx::naming::address const&)

Enums

enum component_enum_type

Values:

component_invalid = naming::address::component_invalid
component_runtime_support = 0
component_plain_function = 1
component_base_lco = 2
component_base_lco_with_value_unmanaged = 3
component_base_lco_with_value = 4
component_latch = ((5 << 10) | component_base_lco_with_value)
component_barrier = ((6 << 10) | component_base_lco)
component_promise = ((7 << 10) | component_base_lco_with_value)
component_agas_locality_namespace = 8
component_agas_primary_namespace = 9
component_agas_component_namespace = 10
component_agas_symbol_namespace = 11
component_last
component_first_dynamic = component_last
component_upper_bound = 0xfffffL
enum factory_state_enum

Values:

factory_enabled = 0
factory_disabled = 1
factory_check = 2

Functions

bool &enabled(component_type type)
util::atomic_count &instance_count(component_type type)
component_deleter_type &deleter(component_type type)
bool enumerate_instance_counts(util::unique_function_nonser<bool(component_type)> const &f)
const std::string get_component_type_name(component_type type)

Return the string representation for a given component type id.

constexpr component_type get_base_type(component_type t)

The lower short word of the component type is the type of the component exposing the actions.

constexpr component_type get_derived_type(component_type t)

The upper short word of the component is the actual component type.

constexpr component_type derived_component_type(component_type derived, component_type base)

A component derived from a base component exposing the actions needs to have a specially formatted component type.

constexpr bool types_are_compatible(component_type lhs, component_type rhs)

Verify the two given component types are matching (compatible)

template<typename Component, typename Enable = void>
constexpr char const *get_component_name()
template<typename Component, typename Enable = void>
constexpr const char *get_component_base_name()
template<typename Component>
component_type get_component_type()
template<typename Component>
void set_component_type(component_type type)
namespace naming

Functions

std::ostream &operator<<(std::ostream&, address const&)
namespace hpx
namespace components

Typedefs

typedef component_base<Component> instead
template<typename Component>
using abstract_simple_component_base = abstract_component_base<Component>
template<typename Component, typename Derived>
class managed_component
#include <managed_component_base.hpp>

The managed_component template is used as a indirection layer for components allowing to gracefully handle the access to non-existing components.

Additionally it provides memory management capabilities for the wrapping instances, and it integrates the memory management with the AGAS service. Every instance of a managed_component gets assigned a global id. The provided memory management allocates the managed_component instances from a special heap, ensuring fast allocation and avoids a full network round trip to the AGAS service for each of the allocated instances.

Template Parameters
  • Component:

  • Derived:

namespace hpx
namespace util
class unique_id_ranges
#include <generate_unique_ids.hpp>

The unique_id_ranges class is a type responsible for generating unique ids for components, parcels, threads etc.

Public Functions

unique_id_ranges()
naming::gid_type get_id(std::size_t count = 1)

Generate next unique component id.

void set_range(naming::gid_type const &lower, naming::gid_type const &upper)

Private Types

enum [anonymous]

size of the id range returned by command_getidrange FIXME: is this a policy?

Values:

range_delta = 0x100000
typedef hpx::util::spinlock mutex_type

Private Members

mutex_type mtx_
naming::gid_type lower_

The range of available ids for components.

naming::gid_type upper_
template<typename Component>
struct get_lva<Component, typename std::enable_if<!traits::is_managed_component<Component>::value>::type>

Public Static Functions

static Component *call(naming::address_type lva)
template<typename Component>
struct get_lva<Component, typename std::enable_if<traits::is_managed_component<Component>::value && !std::is_const<Component>::value>::type>

Public Static Functions

static Component *call(naming::address_type lva)
template<typename Component>
struct get_lva<Component, typename std::enable_if<traits::is_managed_component<Component>::value && std::is_const<Component>::value>::type>

Public Static Functions

static Component *call(naming::address_type lva)
namespace hpx
template<typename Component, typename Enable = void>
struct get_lva
#include <get_lva.hpp>

The get_lva template is a helper structure allowing to convert a local virtual address as stored in a local address (returned from the function resolver_client::resolve) to the address of the component implementing the action.

The default implementation uses the template argument Component to deduce the type wrapping the component implementing the action. This is used to get the needed address.

Template Parameters
  • Component: This is the type of the component implementing the action to execute.

template<typename Component>
struct get_lva<Component, typename std::enable_if<!traits::is_managed_component<Component>::value>::type>

Public Static Functions

static Component *call(naming::address_type lva)
template<typename Component>
struct get_lva<Component, typename std::enable_if<traits::is_managed_component<Component>::value && !std::is_const<Component>::value>::type>

Public Static Functions

static Component *call(naming::address_type lva)
template<typename Component>
struct get_lva<Component, typename std::enable_if<traits::is_managed_component<Component>::value && std::is_const<Component>::value>::type>

Public Static Functions

static Component *call(naming::address_type lva)
template<typename Component>
struct create_helper<Component, typename std::enable_if<traits::component_decorates_action<Component>::value>::type>

Public Static Functions

static pinned_ptr call(naming::address_type lva)
namespace hpx
namespace components
class pinned_ptr

Public Functions

pinned_ptr()
pinned_ptr(pinned_ptr const &rhs)
pinned_ptr(pinned_ptr &&rhs)
pinned_ptr &operator=(pinned_ptr const &rhs)
pinned_ptr &operator=(pinned_ptr &&rhs)

Public Static Functions

template<typename Component>
static pinned_ptr create(naming::address_type lva)

Private Functions

template<typename Component>
pinned_ptr(naming::address_type lva, id<Component>)

Private Members

std::unique_ptr<detail::pinned_ptr_base> data_
template<typename Component, typename Enable = void>
struct create_helper

Public Static Functions

static pinned_ptr call(naming::address_type)
template<typename Component>
struct create_helper<Component, typename std::enable_if<traits::component_decorates_action<Component>::value>::type>

Public Static Functions

static pinned_ptr call(naming::address_type lva)
namespace hpx
namespace components
template<typename ServerComponent>
struct stub_base

Public Types

template<>
using server_component_type = ServerComponent

Public Static Functions

static components::component_type get_component_type()
namespace hpx
namespace components
template<typename Component>
class abstract_fixed_component_base : private hpx::traits::detail::fixed_component_tag

Public Types

template<>
using wrapping_type = fixed_component<Component>
template<>
using this_component_type = Component
template<>
using base_type_holder = Component

Public Functions

virtual ~abstract_fixed_component_base()

Public Static Functions

static constexpr component_type get_component_type()
static constexpr void set_component_type(component_type t)
namespace hpx
namespace components
template<typename BaseComponent, typename Mutex = lcos::local::spinlock>
struct abstract_base_migration_support : public BaseComponent
#include <abstract_migration_support.hpp>

This hook has to be inserted into the derivation chain of any abstract_component_base for it to support migration.

Public Types

template<>
using decorates_action = void

Public Functions

virtual ~abstract_base_migration_support()
virtual void pin() = 0
virtual bool unpin() = 0
virtual std::uint32_t pin_count() const = 0
virtual void mark_as_migrated() = 0
virtual hpx::future<void> mark_as_migrated(hpx::id_type const &to_migrate) = 0
virtual void on_migrated() = 0

Public Static Functions

template<typename F>
static threads::thread_function_type decorate_action(naming::address_type lva, F &&f)

Protected Functions

threads::thread_result_type thread_function(threads::thread_function_type &&f, components::pinned_ptr, threads::thread_restart_state state)

Private Types

template<>
using base_type = BaseComponent
template<>
using this_component_type = typename base_type::this_component_type
template<typename Derived, typename Base>
struct abstract_migration_support : public hpx::components::migration_support<Derived>, public Base
#include <abstract_migration_support.hpp>

This hook has to be inserted into the derivation chain of any component for it to support migration.

Public Types

template<>
using base_type = migration_support<Derived>
template<>
using abstract_base_type = Base
template<>
using wrapping_type = typename base_type::wrapping_type
template<>
using wrapped_type = typename base_type::wrapped_type
template<>
using type_holder = Derived
template<>
using base_type_holder = Base

Public Functions

template<typename ...Ts>
abstract_migration_support(Ts&&... ts)
~abstract_migration_support()
constexpr void finalize()
hpx::future<void> mark_as_migrated(hpx::id_type const &to_migrate)
void mark_as_migrated()
std::uint32_t pin_count() const
void pin()
bool unpin()
void on_migrated()
namespace hpx
namespace traits
template<typename Component, typename Enable>
struct component_heap_type

Public Types

template<>
using type = hpx::components::detail::simple_heap<Component>

Defines

HPX_REGISTER_COMPONENT_HEAP(Component)
namespace hpx
namespace components

Functions

template<typename Component>
Component::heap_type &component_heap()
namespace hpx
namespace components
namespace server

Functions

template<typename Component, typename ...Ts>
naming::gid_type create(Ts&&... ts)

Create a component and forward the passed parameters.

Create arrays of components using their default constructor.

template<typename Component, typename ...Ts>
naming::gid_type create_migrated(naming::gid_type const &gid, void **p, Ts&&... ts)
template<typename Component, typename ...Ts>
std::vector<naming::gid_type> bulk_create(std::size_t count, Ts&&... ts)

Create count components and forward the passed parameters.

namespace hpx
namespace components
namespace server

Functions

template<typename Component, typename ...Ts>
naming::gid_type construct(Ts&&... ts)
namespace hpx
namespace components
template<typename BaseComponent, typename Mutex = lcos::local::spinlock>
struct locking_hook : public BaseComponent
#include <locking_hook.hpp>

This hook can be inserted into the derivation chain of any component allowing to automatically lock all action invocations for any instance of the given component.

Public Types

template<>
using decorates_action = void

Public Functions

template<typename ...Arg>
locking_hook(Arg&&... arg)
locking_hook(locking_hook const &rhs)
locking_hook(locking_hook &&rhs)
locking_hook &operator=(locking_hook const &rhs)
locking_hook &operator=(locking_hook &&rhs)

Public Static Functions

template<typename F>
static threads::thread_function_type decorate_action(naming::address_type lva, F &&f)

Protected Types

template<>
using yield_decorator_type = util::function_nonser<threads::thread_arg_type(threads::thread_result_type)>

Protected Functions

threads::thread_result_type thread_function(threads::thread_function_type f, threads::thread_arg_type state)
threads::thread_arg_type yield_function(threads::thread_result_type state)

Private Types

template<>
using mutex_type = Mutex
template<>
using base_type = BaseComponent
template<>
using this_component_type = typename base_type::this_component_type

Private Members

mutex_type mtx_
struct decorate_wrapper

Public Functions

template<typename F, typename Enable = typename std::enable_if<!std::is_same<typename std::decay<F>::type, decorate_wrapper>::value>::type>
decorate_wrapper(F &&f)
template<>
~decorate_wrapper()
struct undecorate_wrapper

Public Functions

template<>
undecorate_wrapper()
template<>
~undecorate_wrapper()

Public Members

template<>
yield_decorator_type yield_decorator_
template<>
struct init<traits::construct_with_back_ptr>

Public Static Functions

template<typename Component, typename Managed>
static constexpr void call(Component*, Managed*)
template<typename Component, typename Managed, typename ...Ts>
static void call_new(Component *&component, Managed *this_, Ts&&... vs)
template<>
struct init<traits::construct_without_back_ptr>

Public Static Functions

template<typename Component, typename Managed>
static void call(Component *component, Managed *this_)
template<typename Component, typename Managed, typename ...Ts>
static void call_new(Component *&component, Managed *this_, Ts&&... vs)
template<>
struct destroy_backptr<traits::managed_object_is_lifetime_controlled>

Public Static Functions

template<typename BackPtr>
static void call(BackPtr *back_ptr)
template<>
struct destroy_backptr<traits::managed_object_controls_lifetime>

Public Static Functions

template<typename BackPtr>
static constexpr void call(BackPtr*)
template<>
struct manage_lifetime<traits::managed_object_is_lifetime_controlled>

Public Static Functions

template<typename Component>
static constexpr void call(Component*)
template<typename Component>
static void addref(Component *component)
template<typename Component>
static void release(Component *component)
template<>
struct manage_lifetime<traits::managed_object_controls_lifetime>

Public Static Functions

template<typename Component>
static void call(Component *component)
template<typename Component>
static constexpr void addref(Component*)
template<typename Component>
static constexpr void release(Component*)
namespace hpx
namespace components

Functions

template<typename Component, typename Derived>
void intrusive_ptr_add_ref(managed_component<Component, Derived> *p)
template<typename Component, typename Derived>
void intrusive_ptr_release(managed_component<Component, Derived> *p)
namespace detail_adl_barrier
template<>
struct destroy_backptr<traits::managed_object_controls_lifetime>

Public Static Functions

template<typename BackPtr>
static constexpr void call(BackPtr*)
template<>
struct destroy_backptr<traits::managed_object_is_lifetime_controlled>

Public Static Functions

template<typename BackPtr>
static void call(BackPtr *back_ptr)
template<>
struct init<traits::construct_with_back_ptr>

Public Static Functions

template<typename Component, typename Managed>
static constexpr void call(Component*, Managed*)
template<typename Component, typename Managed, typename ...Ts>
static void call_new(Component *&component, Managed *this_, Ts&&... vs)
template<>
struct init<traits::construct_without_back_ptr>

Public Static Functions

template<typename Component, typename Managed>
static void call(Component *component, Managed *this_)
template<typename Component, typename Managed, typename ...Ts>
static void call_new(Component *&component, Managed *this_, Ts&&... vs)
template<>
struct manage_lifetime<traits::managed_object_controls_lifetime>

Public Static Functions

template<typename Component>
static void call(Component *component)
template<typename Component>
static constexpr void addref(Component*)
template<typename Component>
static constexpr void release(Component*)
template<>
struct manage_lifetime<traits::managed_object_is_lifetime_controlled>

Public Static Functions

template<typename Component>
static constexpr void call(Component*)
template<typename Component>
static void addref(Component *component)
template<typename Component>
static void release(Component *component)
namespace hpx
namespace components
template<typename BaseComponent, typename Mutex = lcos::local::spinlock>
struct migration_support : public BaseComponent
#include <migration_support.hpp>

This hook has to be inserted into the derivation chain of any component for it to support migration.

Public Types

template<>
using decorates_action = void

Public Functions

template<typename ...Arg>
migration_support(Arg&&... arg)
~migration_support()
naming::gid_type get_base_gid(naming::gid_type const &assign_gid = naming::invalid_gid) const
void pin()
bool unpin()
std::uint32_t pin_count() const
void mark_as_migrated()
hpx::future<void> mark_as_migrated(hpx::id_type const &to_migrate)
constexpr void on_migrated()

This hook is invoked on the newly created object after the migration has been finished

Public Static Functions

static constexpr bool supports_migration()
template<typename F>
static threads::thread_function_type decorate_action(naming::address_type lva, F &&f)
static std::pair<bool, components::pinned_ptr> was_object_migrated(hpx::naming::gid_type const &id, naming::address_type lva)

Protected Functions

threads::thread_result_type thread_function(threads::thread_function_type &&f, components::pinned_ptr, threads::thread_restart_state state)

Private Types

template<>
using mutex_type = Mutex
template<>
using base_type = BaseComponent
template<>
using this_component_type = typename base_type::this_component_type

Private Members

mutex_type mtx_
std::uint32_t pin_count_
hpx::lcos::local::promise<void> trigger_migration_
bool was_marked_for_migration_
namespace hpx
namespace util
class one_size_heap_list

Subclassed by hpx::components::detail::wrapper_heap_list< Heap >

Public Types

using list_type = std::list<std::shared_ptr<util::wrapper_heap_base>>
using iterator = typename list_type::iterator
using const_iterator = typename list_type::const_iterator
using mutex_type = lcos::local::spinlock
using unique_lock_type = std::unique_lock<mutex_type>
using heap_parameters = wrapper_heap_base::heap_parameters

Public Functions

one_size_heap_list()
template<typename Heap>
one_size_heap_list(char const *class_name, heap_parameters parameters, Heap* = nullptr)
template<typename Heap>
one_size_heap_list(std::string const &class_name, heap_parameters parameters, Heap* = nullptr)
~one_size_heap_list()
void *alloc(std::size_t count = 1)
bool reschedule(void *p, std::size_t count)
void free(void *p, std::size_t count = 1)
bool did_alloc(void *p) const
std::string name() const

Public Members

std::shared_ptr<util::wrapper_heap_base> (*create_heap_)(char const*, std::size_t, heap_parameters)
const heap_parameters parameters_

Protected Attributes

mutex_type mtx_
list_type heap_list_

Private Members

const std::string class_name_

Private Static Functions

template<typename Heap>
static std::shared_ptr<util::wrapper_heap_base> create_heap(char const *name, std::size_t counter, heap_parameters parameters)

Defines

HPX_DEBUG_WRAPPER_HEAP
namespace hpx
namespace util
struct wrapper_heap_base

Subclassed by hpx::components::detail::wrapper_heap

Public Functions

virtual ~wrapper_heap_base()
virtual bool alloc(void **result, std::size_t count = 1) = 0
virtual bool did_alloc(void *p) const = 0
virtual void free(void *p, std::size_t count = 1) = 0
virtual naming::gid_type get_gid(util::unique_id_ranges &ids, void *p, components::component_type type) = 0
virtual std::size_t heap_count() const = 0
virtual std::size_t size() const = 0
virtual std::size_t free_size() const = 0
struct heap_parameters

Public Members

std::size_t capacity
std::size_t element_alignment
std::size_t element_size
namespace hpx
namespace traits
template<typename Action, typename Enable = void>
struct action_decorate_function

Public Static Functions

template<typename F>
static threads::thread_function_type call(naming::address_type lva, F &&f)

Public Static Attributes

constexpr bool value = has_decorates_action<Action>::value
template<typename Component, typename Enable = void>
struct component_decorate_function

Public Static Functions

template<typename F>
static threads::thread_function_type call(naming::address_type lva, F &&f)
namespace hpx
namespace traits
template<typename Component, typename Enable = void>
struct component_config_data

Public Static Functions

static char const *call()
namespace hpx
namespace traits
template<typename Component, typename Enable = void>
struct component_pin_support

Public Static Functions

static constexpr void pin(Component *p)
static constexpr bool unpin(Component *p)
static constexpr std::uint32_t pin_count(Component *p)
namespace hpx
namespace traits
template<typename Component, typename Enable = void>
struct component_supports_migration

Public Static Functions

static constexpr bool call()
namespace hpx
namespace components

Typedefs

using component_type = std::int32_t
namespace traits
template<typename Component, typename Enable = void>
struct component_type_database

Subclassed by hpx::traits::component_type_database< Component const, Enable >

Public Static Functions

static components::component_type get()
static void set(components::component_type)

Public Static Attributes

components::component_type value = components::component_type(-1)
namespace hpx
namespace traits
template<typename Component, typename Enable = void>
struct component_type_is_compatible

Public Static Functions

static bool call(naming::address const &addr)
namespace hpx
namespace traits
template<typename Component>
struct is_fixed_component : public std::integral_constant<bool, std::is_base_of<traits::detail::fixed_component_tag, Component>::value>

Subclassed by hpx::traits::is_fixed_component< Component const >

template<typename Component>
struct is_managed_component : public std::integral_constant<bool, std::is_base_of<traits::detail::managed_component_tag, Component>::value>

Subclassed by hpx::traits::is_managed_component< Component const >

template<typename Component>
struct managed_component_ctor_policy<Component, typename util::always_void<typename Component::has_managed_component_base>::type>

Public Types

template<>
using type = typename Component::ctor_policy
template<typename Component>
struct managed_component_dtor_policy<Component, typename util::always_void<typename Component::has_managed_component_base>::type>

Public Types

template<>
using type = typename Component::dtor_policy
namespace hpx
namespace traits
template<typename T, typename Enable = void>
struct managed_component_ctor_policy

Public Types

template<>
using type = construct_without_back_ptr
template<typename Component>
struct managed_component_ctor_policy<Component, typename util::always_void<typename Component::has_managed_component_base>::type>

Public Types

template<>
using type = typename Component::ctor_policy
template<typename T, typename Enable = void>
struct managed_component_dtor_policy

Public Types

template<>
using type = managed_object_controls_lifetime
template<typename Component>
struct managed_component_dtor_policy<Component, typename util::always_void<typename Component::has_managed_component_base>::type>

Public Types

template<>
using type = typename Component::dtor_policy