hpx/agas_base/server/symbol_namespace.hpp

See Public API for a list of names and headers that are part of the public HPX API.

namespace hpx
namespace agas

Functions

naming::gid_type bootstrap_symbol_namespace_gid()
hpx::id_type bootstrap_symbol_namespace_id()
namespace server

AGAS’s primary namespace maps 128-bit global identifiers (GIDs) to resolved addresses.

The following is the canonical description of the partitioning of AGAS’s primary namespace.

|-----MSB------||------LSB-----|
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
|prefix||RC||----identifier----|

MSB        - Most significant bits (bit 64 to bit 127)
LSB        - Least significant bits (bit 0 to bit 63)
prefix     - Highest 32 bits (bit 96 to bit 127) of the MSB. Each
             locality is assigned a prefix. This creates a 96-bit
             address space for each locality.
RC         - Bit 88 to bit 92 of the MSB. This is the log2 of the number
             of reference counting credits on the GID.
             Bit 93 is used by the locking scheme for gid_types.
             Bit 94 is a flag which is set if the credit value is valid.
             Bit 95 is a flag that is set if a GID's credit count is
             ever split (e.g. if the GID is ever passed to another
             locality).
           - Bit 87 marks the gid such that it will not be stored in
             any of the AGAS caches. This is used mainly for ids
             which represent 'one-shot' objects (like promises).
identifier - Bit 64 to bit 86 of the MSB, and the entire LSB. The
             content of these bits depends on the component type of
             the underlying object. For all user-defined components,
             these bits contain a unique 88-bit number which is
             assigned sequentially for each locality. For
             \a hpx#components#component_runtime_support the high 24
             bits are zeroed and the low 64 bits hold the LVA of the
             component.
Note

The layout of the address space is implementation defined, and subject to change. Never write application code that relies on the internal layout of GIDs. AGAS only guarantees that all assigned GIDs will be unique.

The following address ranges are reserved. Some are either explicitly or implicitly protected by AGAS. The letter x represents a single-byte wild card.

00000000xxxxxxxxxxxxxxxxxxxxxxxx
    Historically unused address space reserved for future use.
xxxxxxxxxxxx0000xxxxxxxxxxxxxxxx
    Address space for LVA-encoded GIDs.
00000001xxxxxxxxxxxxxxxxxxxxxxxx
    Prefix of the bootstrap AGAS locality.
00000001000000010000000000000001
    Address of the primary_namespace component on the bootstrap AGAS
    locality.
00000001000000010000000000000002
    Address of the component_namespace component on the bootstrap AGAS
    locality.
00000001000000010000000000000003
    Address of the symbol_namespace component on the bootstrap AGAS
    locality.
00000001000000010000000000000004
    Address of the locality_namespace component on the bootstrap AGAS
    locality.

Variables

constexpr char const *const symbol_namespace_service_name = "symbol/"
struct symbol_namespace : public components::fixed_component_base<symbol_namespace>

Public Types

using mutex_type = hpx::spinlock
using base_type = components::fixed_component_base<symbol_namespace>
using iterate_names_return_type = std::map<std::string, naming::gid_type>
using gid_table_type = std::map<std::string, std::shared_ptr<naming::gid_type>>
using on_event_data_map_type = std::multimap<std::string, hpx::id_type>

Public Functions

symbol_namespace()
void finalize()
void register_server_instance(char const *servicename, std::uint32_t locality_id = naming::invalid_locality_id, error_code &ec = throws)
void unregister_server_instance(error_code &ec = throws)
bool bind(std::string key, naming::gid_type gid)
naming::gid_type resolve(std::string const &key)
naming::gid_type unbind(std::string const &key)
iterate_names_return_type iterate(std::string const &pattern)
bool on_event(std::string const &name, bool call_for_past_events, hpx::id_type lco)

Public Members

counter_data counter_data_

Public Static Functions

static void register_counter_types(error_code &ec = throws)
static void register_global_counter_types(error_code &ec = throws)

Private Members

mutex_type mutex_
gid_table_type gids_
std::string instance_name_
on_event_data_map_type on_event_data_
struct counter_data

Public Types

typedef hpx::spinlock mutex_type

Public Functions

HPX_NON_COPYABLE(counter_data)
counter_data()
std::int64_t get_bind_count(bool)
std::int64_t get_resolve_count(bool)
std::int64_t get_unbind_count(bool)
std::int64_t get_iterate_names_count(bool)
std::int64_t get_on_event_count(bool)
std::int64_t get_overall_count(bool)
std::int64_t get_bind_time(bool)
std::int64_t get_resolve_time(bool)
std::int64_t get_unbind_time(bool)
std::int64_t get_iterate_names_time(bool)
std::int64_t get_on_event_time(bool)
std::int64_t get_overall_time(bool)
void increment_bind_count()
void increment_resolve_count()
void increment_unbind_count()
void increment_iterate_names_count()
void increment_on_event_count()
void enable_all()

Public Members

api_counter_data bind_
api_counter_data resolve_
api_counter_data unbind_
api_counter_data iterate_names_
api_counter_data on_event_
struct api_counter_data

Public Functions

api_counter_data()

Public Members

std::atomic<std::int64_t> count_
std::atomic<std::int64_t> time_
bool enabled_