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.

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

typedef void (*component_deleter_type)(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.

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.

component_type get_derived_type(component_type t)

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

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.

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>
void set_component_type(component_type type)
template<typename Component>
component_type get_component_type()
namespace naming

Functions

std::ostream &operator<<(std::ostream&, address const&)
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 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

typedef std::int32_t component_type
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 >