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