naming_base

The contents of this module can be included with the header hpx/modules/naming_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/naming_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_ADDRESS_VERSION
namespace hpx
namespace naming
struct address

Public Types

using component_type = naming::component_type
using address_type = naming::address_type

Public Functions

constexpr address()
constexpr address(gid_type const &l, component_type t = component_invalid)
address(gid_type const &l, component_type t, void *lva)
constexpr address(gid_type const &l, component_type t, address_type a)
address(void *lva, component_type t = component_invalid)
constexpr address(address_type a)
constexpr operator bool() const

Public Members

gid_type locality_
component_type type_ = component_invalid
address_type address_ = 0

Public Static Attributes

constexpr const component_type component_invalid = -1

Private Functions

template<typename Archive>
void save(Archive &ar, unsigned int version) const
template<typename Archive>
void load(Archive &ar, unsigned int version)
HPX_SERIALIZATION_SPLIT_MEMBER()

Friends

friend hpx::naming::hpx::serialization::access

address (local virtual address)

friend constexpr bool operator==(address const &lhs, address const &rhs)

Defines

HPX_GIDTYPE_VERSION
template<>
struct hash<hpx::naming::gid_type>

Public Functions

std::size_t operator()(::hpx::naming::gid_type const &gid) const
namespace hpx
namespace naming

Functions

gid_type operator+(gid_type const &lhs, gid_type const &rhs)
gid_type operator-(gid_type const &lhs, gid_type const &rhs)
void save(serialization::output_archive &ar, gid_type const&, unsigned int)
void load(serialization::input_archive &ar, gid_type&, unsigned int version)
gid_type get_gid_from_locality_id(std::uint32_t locality_id)
std::uint32_t get_locality_id_from_gid(std::uint64_t msb)
std::uint32_t get_locality_id_from_gid(gid_type const &id)
gid_type get_locality_from_gid(gid_type const &id)
bool is_locality(gid_type const &gid)
std::uint64_t replace_locality_id(std::uint64_t msb, std::uint32_t locality_id)
gid_type replace_locality_id(gid_type const &gid, std::uint32_t locality_id)
constexpr bool refers_to_virtual_memory(std::uint64_t msb)
constexpr bool refers_to_virtual_memory(gid_type const &gid)
constexpr bool refers_to_local_lva(gid_type const &gid)
gid_type replace_component_type(gid_type const &gid, std::uint32_t type)
std::ostream &operator<<(std::ostream &os, gid_type const &id)

Variables

constexpr const gid_type invalid_gid = {}
struct gid_type
#include <gid_type.hpp>

Global identifier for components across the HPX system.

Subclassed by hpx::naming::detail::id_type_impl

Public Types

using size_type = gid_type
using difference_type = gid_type
using mutex_type = gid_type

Public Functions

constexpr gid_type()
constexpr gid_type(std::uint64_t lsb_id)
gid_type(std::uint64_t msb_id, std::uint64_t lsb_id)
constexpr gid_type(gid_type const &rhs)
constexpr gid_type(gid_type &&rhs)
~gid_type()
gid_type &operator=(std::uint64_t lsb_id)
gid_type &operator=(gid_type const &rhs)
gid_type &operator=(gid_type &&rhs)
constexpr operator bool() const
gid_type &operator++()
gid_type operator++(int)
gid_type &operator--()
gid_type operator--(int)
gid_type operator+=(gid_type const &rhs)
gid_type operator+=(std::uint64_t rhs)
gid_type operator-=(gid_type const &rhs)
gid_type operator-=(std::uint64_t rhs)
constexpr std::uint64_t get_msb() const
constexpr void set_msb(std::uint64_t msb)
constexpr std::uint64_t get_lsb() const
constexpr void set_lsb(std::uint64_t lsb)
void set_lsb(void *lsb)
std::string to_string() const
void lock()
bool try_lock()
void unlock()
mutex_type &get_mutex() const

Public Static Attributes

constexpr std::uint64_t credit_base_mask = 0x1full
constexpr std::uint16_t credit_shift = 24
constexpr std::uint64_t credit_mask = credit_base_mask << credit_shift
constexpr std::uint64_t was_split_mask = 0x80000000ull
constexpr std::uint64_t has_credits_mask = 0x40000000ull
constexpr std::uint64_t is_locked_mask = 0x20000000ull
constexpr std::uint64_t locality_id_mask = 0xffffffff00000000ull
constexpr std::uint16_t locality_id_shift = 32
constexpr std::uint64_t virtual_memory_mask = 0x3fffffull
constexpr std::uint64_t dont_cache_mask = 0x800000ull
constexpr std::uint64_t is_migratable = 0x400000ull
constexpr std::uint64_t dynamically_assigned = 0x1ull
constexpr std::uint64_t component_type_base_mask = 0xfffffull
constexpr std::uint64_t component_type_shift = 1ull
constexpr std::uint64_t component_type_mask = component_type_base_mask << component_type_shift
constexpr std::uint64_t credit_bits_mask = credit_mask | was_split_mask | has_credits_mask
constexpr std::uint64_t internal_bits_mask = credit_bits_mask | is_locked_mask | dont_cache_mask | is_migratable
constexpr std::uint64_t special_bits_mask = locality_id_mask | internal_bits_mask | component_type_mask

Private Types

using spinlock_pool = util::spinlock_pool<gid_type>

Private Functions

bool acquire_lock()
void relinquish_lock()
constexpr bool is_locked() const

Private Members

std::uint64_t id_msb_ = 0
std::uint64_t id_lsb_ = 0

Friends

gid_type operator+(gid_type const &lhs, gid_type const &rhs)
gid_type operator+(gid_type const &lhs, std::uint64_t rhs)
gid_type operator-(gid_type const &lhs, gid_type const &rhs)
gid_type operator-(gid_type const &lhs, std::uint64_t rhs)
gid_type operator&(gid_type const &lhs, std::uint64_t rhs)
bool operator==(gid_type const &lhs, gid_type const &rhs)
bool operator!=(gid_type const &lhs, gid_type const &rhs)
bool operator<(gid_type const &lhs, gid_type const &rhs)
bool operator>=(gid_type const &lhs, gid_type const &rhs)
bool operator<=(gid_type const &lhs, gid_type const &rhs)
bool operator>(gid_type const &lhs, gid_type const &rhs)
std::ostream &operator<<(std::ostream &os, gid_type const &id)
void save(serialization::output_archive &ar, gid_type const&, unsigned int)
void load(serialization::input_archive &ar, gid_type&, unsigned int version)
namespace std
template<>
struct hash<hpx::naming::gid_type>

Public Functions

std::size_t operator()(::hpx::naming::gid_type const &gid) const
template<>
struct get_remote_result<naming::id_type, naming::gid_type>

Public Static Functions

static naming::id_type call(naming::gid_type const &rhs)
template<>
struct promise_local_result<naming::gid_type>

Public Types

typedef naming::id_type type
template<>
struct get_remote_result<std::vector<naming::id_type>, std::vector<naming::gid_type>>

Public Static Functions

static std::vector<naming::id_type> call(std::vector<naming::gid_type> const &rhs)
template<>
struct promise_local_result<std::vector<naming::gid_type>>

Public Types

typedef std::vector<naming::id_type> type
namespace hpx
namespace naming

Functions

std::ostream &operator<<(std::ostream &os, id_type const &id)
char const *get_management_type_name(id_type::management_type m)
id_type get_id_from_locality_id(std::uint32_t locality_id)
std::uint32_t get_locality_id_from_id(id_type const &id)
id_type get_locality_from_id(id_type const &id)
bool is_locality(id_type const &id)
bool operator!=(id_type const &lhs, id_type const &rhs)
bool operator<=(id_type const &lhs, id_type const &rhs)
bool operator>(id_type const &lhs, id_type const &rhs)
bool operator>=(id_type const &lhs, id_type const &rhs)

Variables

const id_type invalid_id = id_type()
struct id_type

Public Types

enum management_type

Values:

unknown_deleter = -1
unmanaged = 0

unmanaged GID

managed = 1

managed GID

managed_move_credit = 2

managed GID which will give up all credits when sent

Public Functions

constexpr id_type()
id_type(std::uint64_t lsb_id, management_type t)
id_type(gid_type const &gid, management_type t)
id_type(std::uint64_t msb_id, std::uint64_t lsb_id, management_type t)
id_type(id_type const &o)
id_type(id_type &&o)
id_type &operator=(id_type const &o)
id_type &operator=(id_type &&o)
gid_type const &get_gid()
gid_type const &get_gid() const
id_type::management_type get_management_type() const
id_type &operator++()
id_type operator++(int)
operator bool() const
std::uint64_t get_msb() const
void set_msb(std::uint64_t msb)
std::uint64_t get_lsb() const
void set_lsb(std::uint64_t lsb)
void set_lsb(void *lsb)
void make_unmanaged() const
hpx::intrusive_ptr<detail::id_type_impl> &impl()
hpx::intrusive_ptr<detail::id_type_impl> const &impl() const

Private Members

hpx::intrusive_ptr<detail::id_type_impl> gid_

Friends

bool operator==(id_type const &lhs, id_type const &rhs)
bool operator!=(id_type const &lhs, id_type const &rhs)
bool operator<(id_type const &lhs, id_type const &rhs)
bool operator<=(id_type const &lhs, id_type const &rhs)
bool operator>(id_type const &lhs, id_type const &rhs)
bool operator>=(id_type const &lhs, id_type const &rhs)
std::ostream &operator<<(std::ostream &os, id_type const &id)
namespace traits
template<>
struct get_remote_result<naming::id_type, naming::gid_type>

Public Static Functions

static naming::id_type call(naming::gid_type const &rhs)
template<>
struct get_remote_result<std::vector<naming::id_type>, std::vector<naming::gid_type>>

Public Static Functions

static std::vector<naming::id_type> call(std::vector<naming::gid_type> const &rhs)
template<>
struct promise_local_result<naming::gid_type>

Public Types

typedef naming::id_type type
template<>
struct promise_local_result<std::vector<naming::gid_type>>

Public Types

typedef std::vector<naming::id_type> type
namespace hpx
namespace naming

Typedefs

using component_type = std::int32_t
using address_type = std::uint64_t

Variables

constexpr std::uint32_t invalid_locality_id = ~static_cast<std::uint32_t>(0)
constexpr std::int32_t component_invalid = -1
namespace hpx
namespace naming

Functions

id_type unmanaged(id_type const &id)

The helper function hpx::unmanaged can be used to generate a global identifier which does not participate in the automatic garbage collection.

Return

This function returns a new global id referencing the same object as the parameter id. The only difference is that the returned global identifier does not participate in the automatic garbage collection.

Note

This function allows to apply certain optimizations to the process of memory management in HPX. It however requires the user to take full responsibility for keeping the referenced objects alive long enough.

Parameters
  • id: [in] The id to generated the unmanaged global id from This parameter can be itself a managed or a unmanaged global id.