hpx/agas_base/server/locality_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_locality_namespace_gid()
hpx::id_type bootstrap_locality_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 locality_namespace_service_name = "locality/"
struct locality_namespace : public components::fixed_component_base<locality_namespace>

Public Types

using mutex_type = hpx::spinlock
using base_type = components::fixed_component_base<locality_namespace>
using component_type = std::int32_t
using partition_type = hpx::tuple<parcelset::endpoints_type, std::uint32_t>
using partition_table_type = std::map<std::uint32_t, partition_type>

Public Functions

locality_namespace(primary_namespace *primary)
void finalize()
void register_server_instance(char const *servicename, error_code &ec = throws)
void unregister_server_instance(error_code &ec = throws)
std::uint32_t allocate(parcelset::endpoints_type const &endpoints, std::uint64_t count, std::uint32_t num_threads, naming::gid_type suggested_prefix)
parcelset::endpoints_type resolve_locality(naming::gid_type const &locality)
void free(naming::gid_type const &locality)
std::vector<std::uint32_t> localities()
std::uint32_t get_num_localities()
std::vector<std::uint32_t> get_num_threads()
std::uint32_t get_num_overall_threads()

Public Members

counter_data counter_data_

Private Members

mutex_type mutex_
std::string instance_name_
partition_table_type partitions_
std::uint32_t prefix_counter_
primary_namespace *primary_
struct counter_data

Public Types

typedef hpx::spinlock mutex_type

Public Functions

HPX_NON_COPYABLE(counter_data)
counter_data()
std::int64_t get_allocate_count(bool)
std::int64_t get_resolve_locality_count(bool)
std::int64_t get_free_count(bool)
std::int64_t get_localities_count(bool)
std::int64_t get_num_localities_count(bool)
std::int64_t get_num_threads_count(bool)
std::int64_t get_resolved_localities_count(bool)
std::int64_t get_overall_count(bool)
std::int64_t get_allocate_time(bool)
std::int64_t get_resolve_locality_time(bool)
std::int64_t get_free_time(bool)
std::int64_t get_localities_time(bool)
std::int64_t get_num_localities_time(bool)
std::int64_t get_num_threads_time(bool)
std::int64_t get_resolved_localities_time(bool)
std::int64_t get_overall_time(bool)
void increment_allocate_count()
void increment_resolve_locality_count()
void increment_free_count()
void increment_localities_count()
void increment_num_localities_count()
void increment_num_threads_count()
void enable_all()

Public Members

api_counter_data allocate_
api_counter_data resolve_locality_
api_counter_data free_
api_counter_data localities_
api_counter_data num_localities_
api_counter_data num_threads_
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_