addressing_service.hpp#

Defined in header hpx/agas/addressing_service.hpp.

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

namespace hpx

namespace agas#

struct addressing_service#

Public Types

using component_id_type = components::component_type#

using iterate_names_return_type = std::map<std::string, hpx::id_type>#

using iterate_types_function_type = hpx::function<void(std::string const&, components::component_type), true>#

using mutex_type = hpx::spinlock #

using gva_cache_type = hpx::util::cache::lru_cache<gva_cache_key, gva, hpx::util::cache::statistics::local_full_statistics>#

using migrated_objects_table_type = std::set<naming::gid_type>#

using refcnt_requests_type = std::map<naming::gid_type, std::int64_t>#

using resolved_localities_type = std::map<naming::gid_type, parcelset::endpoints_type>#

Public Functions

HPX_NON_COPYABLE(addressing_service)#

explicit addressing_service(util::runtime_configuration const &ini_)#

~addressing_service() = default#

void bootstrap(parcelset::endpoints_type const &endpoints, util::runtime_configuration &rtcfg)#

void initialize(std::uint64_t rts_lva)#

void adjust_local_cache_size(std::size_t) const#: Adjust the size of the local AGAS Address resolution cache.

inline state get_status() const#

inline void set_status(state new_state)#

inline naming::gid_type const &get_local_locality(error_code& = throws) const#

void set_local_locality(naming::gid_type const &g)#

void register_console(parcelset::endpoints_type const &eps)#

inline bool is_bootstrap() const#

inline bool is_console() const#: Returns whether this addressing_service represents the console locality.

inline bool is_connecting() const#: Returns whether this addressing_service is connecting to a running application.

bool resolve_locally_known_addresses(naming::gid_type const &id, naming::address &addr) const#

void register_server_instances()#

void garbage_collect_non_blocking(error_code &ec = throws)#

void garbage_collect(error_code &ec = throws)#

inline server::primary_namespace &get_local_primary_namespace_service()#

inline naming::address::address_type get_primary_ns_lva() const#

inline naming::address::address_type get_symbol_ns_lva() const#

inline server::component_namespace *get_local_component_namespace_service() const#

inline server::locality_namespace *get_local_locality_namespace_service() const#

inline server::symbol_namespace &get_local_symbol_namespace_service() const#

inline naming::address::address_type get_runtime_support_lva() const#

std::uint64_t get_cache_entries(bool) const#

std::uint64_t get_cache_hits(bool) const#

std::uint64_t get_cache_misses(bool) const#

std::uint64_t get_cache_evictions(bool) const#

std::uint64_t get_cache_insertions(bool) const#

std::uint64_t get_cache_get_entry_count(bool reset) const#

std::uint64_t get_cache_insertion_entry_count(bool reset) const#

std::uint64_t get_cache_update_entry_count(bool reset) const#

std::uint64_t get_cache_erase_entry_count(bool reset) const#

std::uint64_t get_cache_get_entry_time(bool reset) const#

std::uint64_t get_cache_insertion_entry_time(bool reset) const#

std::uint64_t get_cache_update_entry_time(bool reset) const#

std::uint64_t get_cache_erase_entry_time(bool reset) const#

bool register_locality(parcelset::endpoints_type const &endpoints, naming::gid_type &prefix, std::uint32_t num_threads, error_code &ec = throws)#: Add a locality to the runtime.

parcelset::endpoints_type const &resolve_locality(naming::gid_type const &gid, error_code &ec = throws)#

Resolve a locality to its prefix.

Returns: Returns an empty vector if the locality is not registered.

bool has_resolved_locality(naming::gid_type const &gid)#

bool unregister_locality(naming::gid_type const &gid, error_code &ec = throws)#: Remove a locality from the runtime.

void remove_resolved_locality(naming::gid_type const &gid)#: remove given locality from locality cache

bool get_console_locality(naming::gid_type &locality, error_code &ec = throws)#

Get locality locality_id of the console locality.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

locality – [out] The locality_id value uniquely identifying the console locality. This is valid only, if the return value of this function is true.
try_cache – [in] If this is set to true the console is first tried to be found in the local cache. Otherwise this function will always query AGAS, even if the console locality_id is already known locally.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

This function returns true if a console locality_id exists and returns false otherwise.

bool get_localities(std::vector<naming::gid_type> &locality_ids, components::component_type type, error_code &ec = throws) const#

Query for the locality_ids of all known localities.

This function returns the locality_ids of all localities known to the AGAS server or all localities having a registered factory for a given component type.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise, it throws an instance of hpx::exception.

Parameters

locality_ids – [out] The vector will contain the prefixes of all localities registered with the AGAS server. The returned vector holds the prefixes representing the runtime_support components of these localities.
type – [in] The component type will be used to determine the set of prefixes having a registered factory for this component. The default value for this parameter is components::component_enum_type::invalid, which will return prefixes of all localities.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

inline bool get_localities(std::vector<naming::gid_type> &locality_ids, error_code &ec = throws) const#

hpx::future<std::uint32_t> get_num_localities_async(components::component_type type = to_int(hpx::components::component_enum_type::invalid)) const#

Query for the number of all known localities.

This function returns the number of localities known to the AGAS server or the number of localities having a registered factory for a given component type.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise, it throws an instance of hpx::exception.

Parameters

type – [in] The component type will be used to determine the set of prefixes having a registered factory for this component. The default value for this parameter is components::component_type::invalid, which will return prefixes of all localities.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

std::uint32_t get_num_localities(components::component_type type, error_code &ec = throws) const#

inline std::uint32_t get_num_localities(error_code &ec = throws) const#

hpx::future<std::uint32_t> get_num_overall_threads_async() const#

std::uint32_t get_num_overall_threads(error_code &ec = throws) const#

hpx::future<std::vector<std::uint32_t>> get_num_threads_async() const#

std::vector<std::uint32_t> get_num_threads(error_code &ec = throws) const#

components::component_type get_component_id(std::string const &name, error_code &ec = throws) const#

Return a unique id usable as a component type.

This function returns the component type id associated with the given component name. If this is the first request for this component name a new unique id will be created.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

name – [in] The component name (string) to get the component type for.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

The function returns the currently associated component type. Any error results in an exception thrown from this function.

void iterate_types(iterate_types_function_type const &f, error_code &ec = throws) const#

std::string get_component_type_name(components::component_type id, error_code &ec = throws) const#

inline components::component_type register_factory(naming::gid_type const &locality_id, std::string const &name, error_code &ec = throws) const#

This function allows to register a component factory for a given locality and component type.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

locality_id – [in] The locality value uniquely identifying the given locality the factory needs to be registered for.
name – [in] The component name (string) to register a factory for the given component type for.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

The function returns the currently associated component type. Any error results in an exception thrown from this function. The returned component type is the same as if the function get_component_id was called using the same component name.

components::component_type register_factory(std::uint32_t locality_id, std::string const &name, error_code &ec = throws) const#

bool get_id_range(std::uint64_t count, naming::gid_type &lower_bound, naming::gid_type &upper_bound, error_code &ec = throws)#

Get unique range of freely assignable global ids.

Every locality needs to be able to assign global ids to different components without having to consult the AGAS server for every id to generate. This function can be called to preallocate a range of ids usable for this purpose.

Note

This function assigns a range of global ids usable by the given locality for newly created components. Any of the returned global ids still has to be bound to a local address, either by calling bind or bind_range.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

l – [in] The locality the locality id needs to be generated for. Repeating calls using the same locality results in identical locality_id values.
count – [in] The number of global ids to be generated.
lower_bound – [out] The lower bound of the assigned id range. The returned value can be used as the first id to assign. This is valid only, if the return value of this function is true.
upper_bound – [out] The upper bound of the assigned id range. The returned value can be used as the last id to assign. This is valid only, if the return value of this function is true.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

This function returns true if a new range has been generated (it has been called for the first time for the given locality) and returns false if this locality already got a range assigned in an earlier call. Any error results in an exception thrown from this function.

inline bool bind_local(naming::gid_type const &id, naming::address const &addr, error_code &ec = throws)#

Bind a global address to a local address.

Every element in the HPX namespace has a unique global address (global id). This global address has to be associated with a concrete local address to be able to address an instance of a component using its global address.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Note

Binding a gid to a local address sets its global reference count to one.

Parameters

id – [in] The global address which has to be bound to the local address.
addr – [in] The local address to be bound to the global address.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

This function returns true, if this global id got associated with an local address. It returns false otherwise.

inline hpx::future<bool> bind_async(naming::gid_type const &id, naming::address const &addr, std::uint32_t locality_id)#

inline hpx::future<bool> bind_async(naming::gid_type const &id, naming::address const &addr, naming::gid_type const &locality)#

bool bind_range_local(naming::gid_type const &lower_id, std::uint64_t count, naming::address const &baseaddr, std::uint64_t offset, error_code &ec = throws)#

Bind unique range of global ids to given base address.

Every locality needs to be able to bind global ids to different components without having to consult the AGAS server for every id to bind. This function can be called to bind a range of consecutive global ids to a range of consecutive local addresses (separated by a given offset).

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Note

Binding a gid to a local address sets its global reference count to one.

Parameters

lower_id – [in] The lower bound of the assigned id range. The value can be used as the first id to assign.
count – [in] The number of consecutive global ids to bind starting at lower_id.
baseaddr – [in] The local address to bind to the global id given by lower_id. This is the base address for all additional local addresses to bind to the remaining global ids.
offset – [in] The offset to use to calculate the local addresses to be bound to the range of global ids.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

This function returns true, if the given range was successfully bound. It returns false otherwise.

hpx::future<bool> bind_range_async(naming::gid_type const &lower_id, std::uint64_t count, naming::address const &baseaddr, std::uint64_t offset, naming::gid_type const &locality)#

inline hpx::future<bool> bind_range_async(naming::gid_type const &lower_id, std::uint64_t count, naming::address const &baseaddr, std::uint64_t offset, std::uint32_t locality_id)#

inline bool unbind_local(naming::gid_type const &id, error_code &ec = throws)#

Unbind a global address.

Remove the association of the given global address with any local address, which was bound to this global address. Additionally it returns the local address which was bound at the time of this call.

Note

You can unbind only global ids bound using the function bind. Do not use this function to unbind any of the global ids bound using bind_range.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Note

This function will raise an error if the global reference count of the given gid is not zero!

Parameters

id – [in] The global address (id) for which the association has to be removed.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

The function returns true if the association has been removed, and it returns false if no association existed. Any error results in an exception thrown from this function.

inline bool unbind_local(naming::gid_type const &id, naming::address &addr, error_code &ec = throws)#

Unbind a global address.

Remove the association of the given global address with any local address, which was bound to this global address. Additionally it returns the local address which was bound at the time of this call.

Note

You can unbind only global ids bound using the function bind. Do not use this function to unbind any of the global ids bound using bind_range.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Note

This function will raise an error if the global reference count of the given gid is not zero!

Parameters

id – [in] The global address (id) for which the association has to be removed.
addr – [out] The local address which was associated with the given global address (id). This is valid only if the return value of this function is true.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

The function returns true if the association has been removed, and it returns false if no association existed. Any error results in an exception thrown from this function.

inline bool unbind_range_local(naming::gid_type const &lower_id, std::uint64_t count, error_code &ec = throws)#

Unbind the given range of global ids.

Note

You can unbind only global ids bound using the function bind_range. Do not use this function to unbind any of the global ids bound using bind.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Note

This function will raise an error if the global reference count of the given gid is not zero!

Parameters

lower_id – [in] The lower bound of the assigned id range. The value must the first id of the range as specified to the corresponding call to bind_range.
count – [in] The number of consecutive global ids to unbind starting at lower_id. This number must be identical to the number of global ids bound by the corresponding call to bind_range
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

bool unbind_range_local(naming::gid_type const &lower_id, std::uint64_t count, naming::address &addr, error_code &ec = throws)#

Unbind the given range of global ids.

Note

You can unbind only global ids bound using the function bind_range. Do not use this function to unbind any of the global ids bound using bind.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Note

This function will raise an error if the global reference count of the given gid is not zero!

Parameters

lower_id – [in] The lower bound of the assigned id range. The value must the first id of the range as specified to the corresponding call to bind_range.
count – [in] The number of consecutive global ids to unbind starting at lower_id. This number must be identical to the number of global ids bound by the corresponding call to bind_range
addr – [out] The local address which was associated with the given global address (id). This is valid only if the return value of this function is true.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

hpx::future<naming::address> unbind_range_async(naming::gid_type const &lower_id, std::uint64_t count = 1)#

inline bool is_local_address_cached(naming::gid_type const &id, error_code &ec = throws)#

Test whether the given address refers to a local object.

This function will test whether the given address refers to an object living on the locality of the caller.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

id – [in] The address to test.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

This function returns true if the passed address refers to an object which lives on the locality of the caller.

bool is_local_address_cached(naming::gid_type const &id, naming::address &addr, error_code &ec = throws)#

bool is_local_address_cached(naming::gid_type const &id, naming::address &addr, std::pair<bool, components::pinned_ptr> &r, hpx::move_only_function<std::pair<bool, components::pinned_ptr>(naming::address const&)> &&f, error_code &ec = throws)#

bool is_local_lva_encoded_address(std::uint64_t msb) const#

inline bool resolve_local(naming::gid_type const &id, naming::address &addr, error_code &ec = throws)#

Resolve a given global address (id) to its associated local address.

This function returns the local address which is currently associated with the given global address (id).

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

id – [in] The global address (id) for which the associated local address should be returned.
addr – [out] The local address which currently is associated with the given global address (id), this is valid only if the return value of this function is true.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

This function returns true if the global address has been resolved successfully (there exists an association to a local address) and the associated local address has been returned. The function returns false if no association exists for the given global address. Any error results in an exception thrown from this function.

inline bool resolve_local(hpx::id_type const &id, naming::address &addr, error_code &ec = throws)#

inline naming::address resolve_local(naming::gid_type const &id, error_code &ec = throws)#

inline naming::address resolve_local(hpx::id_type const &id, error_code &ec = throws)#

hpx::future_or_value<naming::address> resolve_async(naming::gid_type const &id)#

inline hpx::future_or_value<naming::address> resolve_async(hpx::id_type const &id)#

hpx::future_or_value<id_type> get_colocation_id_async(hpx::id_type const &id)#

bool resolve_full_local(naming::gid_type const &id, naming::address &addr, error_code &ec = throws)#

inline bool resolve_full_local(hpx::id_type const &id, naming::address &addr, error_code &ec = throws)#

inline naming::address resolve_full_local(naming::gid_type const &id, error_code &ec = throws)#

inline naming::address resolve_full_local(hpx::id_type const &id, error_code &ec = throws)#

hpx::future_or_value<naming::address> resolve_full_async(naming::gid_type const &id)#

inline hpx::future_or_value<naming::address> resolve_full_async(hpx::id_type const &id)#

bool resolve_cached(naming::gid_type const &id, naming::address &addr, error_code &ec = throws)#

inline bool resolve_cached(hpx::id_type const &id, naming::address &addr, error_code &ec = throws)#

inline bool resolve_local(naming::gid_type const *gids, naming::address *addrs, std::size_t size, hpx::detail::dynamic_bitset<> &locals, error_code &ec = throws)#

bool resolve_full_local(naming::gid_type const *gids, naming::address *addrs, std::size_t size, hpx::detail::dynamic_bitset<> &locals, error_code &ec = throws)#

bool resolve_cached(naming::gid_type const *gids, naming::address *addrs, std::size_t size, hpx::detail::dynamic_bitset<> &locals, error_code &ec = throws)#

hpx::future_or_value<std::int64_t> incref_async(naming::gid_type const &gid, std::int64_t credits = 1, hpx::id_type const &keep_alive = hpx::invalid_id)#

Increment the global reference count for the given id.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

gid – [in] The global address (id) for which the global reference count has to be incremented.
credits – [in] The number of reference counts to add for the given id.
keep_alive – [in] Id to keep alive (if valid)
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

Whether the operation was successful.

inline std::int64_t incref(naming::gid_type const &gid, std::int64_t credits = 1, error_code &ec = throws)#

void decref(naming::gid_type const &id, std::int64_t credits = 1, error_code &ec = throws)#

Decrement the global reference count for the given id.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

id – [in] The global address (id) for which the global reference count has to be decremented.
t – [out] If this was the last outstanding global reference for the given gid (the return value of this function is zero), t will be set to the component type of the corresponding element. Otherwise t will not be modified.
credits – [in] The number of reference counts to add for the given id.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

The global reference count after the decrement.

hpx::future<iterate_names_return_type> iterate_ids(std::string const &pattern) const#

Invoke the supplied hpx::function for every registered global name.

This function iterates over all registered global ids and returns every found entry matching the given name pattern. Any error results in an exception thrown (or reported) from this function.

Parameters: pattern – [in] pattern (possibly using wildcards) to match all existing entries against

bool register_name(std::string const &name, naming::gid_type const &id, error_code &ec = throws) const#

This function registers an association between a global name (string) and a global address (id) usable with one of the functions above (bind, unbind, and resolve).

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

name – [in] The global name (string) to be associated with the global address.
id – [in] The global address (id) to be associated with the global address.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

The function returns true if the global name was registered. It returns false if the global name is not registered.

hpx::future<bool> register_name_async(std::string const &name, hpx::id_type const &id) const#

bool register_name(std::string const &name, hpx::id_type const &id, error_code &ec = throws) const#

hpx::future<hpx::id_type> unregister_name_async(std::string const &name) const#

Unregister a global name (release any existing association)

This function releases any existing association of the given global name with a global address (id).

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

name – [in] The global name (string) for which any association with a global address (id) has to be released.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

The function returns true if an association of this global name has been released, and it returns false, if no association existed. Any error results in an exception thrown from this function.

hpx::id_type unregister_name(std::string const &name, error_code &ec = throws) const#

hpx::future<hpx::id_type> resolve_name_async(std::string const &name) const#

Query for the global address associated with a given global name.

This function returns the global address associated with the given global name.

This function returns true if it returned global address (id), which is currently associated with the given global name, and it returns false, if currently there is no association for this global name. Any error results in an exception thrown from this function.

Note

As long as ec is not pre-initialized to hpx::throws this function doesn’t throw but returns the result code using the parameter ec. Otherwise it throws an instance of hpx::exception.

Parameters

name – [in] The global name (string) for which the currently associated global address has to be retrieved.
ec – [in,out] this represents the error status on exit, if this is pre-initialized to hpx::throws the function will throw on error instead.

Returns

[out] The id currently associated with the given global name (valid only if the return value is true).

hpx::id_type resolve_name(std::string const &name, error_code &ec = throws) const#

future<hpx::id_type> on_symbol_namespace_event(std::string const &name, bool call_for_past_events = false) const#

Install a listener for a given symbol namespace event.

This function installs a listener for a given symbol namespace event. It returns a future which becomes ready as a result of the listener being triggered.

Note

The only event type which is currently supported is symbol_ns_bind, i.e. the listener is triggered whenever a global id is registered with the given name.

Parameters

name – [in] The global name (string) for which the given event should be triggered.
evt – [in] The event for which a listener should be installed.
call_for_past_events – [in, optional] Trigger the listener even if the given event has already happened in the past. The default for this parameter is false.

Returns

A future instance encapsulating the global id which is causing the registered listener to be triggered.

void update_cache_entry(naming::gid_type const &gid, gva const &gva, error_code &ec = throws)#: Warning

This function is for internal use only. It is dangerous and may break your code if you use it.

inline 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)#: Warning

This function is for internal use only. It is dangerous and may break your code if you use it.

bool get_cache_entry(naming::gid_type const &gid, gva &gva, naming::gid_type &idbase, error_code &ec = throws) const#: Warning

This function is for internal use only. It is dangerous and may break your code if you use it.

void remove_cache_entry(naming::gid_type const &id, error_code &ec = throws) const#: Warning

This function is for internal use only. It is dangerous and may break your code if you use it.

void clear_cache(error_code &ec = throws) const#: Warning

This function is for internal use only. It is dangerous and may break your code if you use it.

void start_shutdown(error_code &ec = throws)#

hpx::future<std::pair<hpx::id_type, naming::address>> begin_migration(hpx::id_type const &id)#

start/stop migration of an object

Returns: Current locality and address of the object to migrate

bool end_migration(hpx::id_type const &id)#

std::pair<bool, components::pinned_ptr> was_object_migrated(naming::gid_type const &gid, hpx::move_only_function<components::pinned_ptr()> &&f)#: Maintain list of migrated objects.

hpx::future<void> mark_as_migrated(naming::gid_type const &gid, hpx::move_only_function<std::pair<bool, hpx::future<void>>()> &&f, bool expect_to_be_marked_as_migrating)#: Mark the given object as being migrated (if the object is unpinned). Delay migration until the object is unpinned otherwise.

void unmark_as_migrated(naming::gid_type const &gid_, hpx::move_only_function<void()> &&f)#: Remove the given object from the table of migrated objects.

void pre_cache_endpoints(std::vector<parcelset::endpoints_type> const&)#

Public Members

mutable hpx::shared_mutex gva_cache_mtx_#

std::shared_ptr<gva_cache_type> gva_cache_#

mutable mutex_type migrated_objects_mtx_#

migrated_objects_table_type migrated_objects_table_#

mutable mutex_type console_cache_mtx_#

std::uint32_t console_cache_#

const std::size_t max_refcnt_requests_#

mutex_type refcnt_requests_mtx_#

std::size_t refcnt_requests_count_#

bool enable_refcnt_caching_#

std::shared_ptr<refcnt_requests_type> refcnt_requests_#

const service_mode service_type#

const runtime_mode runtime_type#

const bool caching_#

const bool range_caching_#

const threads::thread_priority action_priority_#

std::uint64_t rts_lva_#

std::unique_ptr<component_namespace> component_ns_#

std::unique_ptr<locality_namespace> locality_ns_#

symbol_namespace symbol_ns_#

primary_namespace primary_ns_#

std::atomic<hpx::state> state_#

naming::gid_type locality_#

mutable hpx::shared_mutex resolved_localities_mtx_#

resolved_localities_type resolved_localities_#

Public Static Functions

static std::int64_t synchronize_with_async_incref(std::int64_t old_credit, hpx::id_type const &id, std::int64_t compensated_credit)#

Protected Functions

void launch_bootstrap(parcelset::endpoints_type const &endpoints, util::runtime_configuration &rtcfg)#

naming::address resolve_full_postproc(naming::gid_type const &id, primary_namespace::resolved_type const&)#

bool bind_postproc(naming::gid_type const &id, gva const &g, future<bool> f)#

bool was_object_migrated_locked(naming::gid_type const &id)#: Maintain list of migrated objects.

Private Functions

void send_refcnt_requests(std::unique_lock<mutex_type> &l, error_code &ec = throws)#: Assumes that refcnt_requests_mtx_ is locked.

void send_refcnt_requests_non_blocking(std::unique_lock<mutex_type> &l, error_code &ec)#: Assumes that refcnt_requests_mtx_ is locked.

std::vector<hpx::future<std::vector<std::int64_t>>> send_refcnt_requests_async(std::unique_lock<mutex_type> &l)#: Assumes that refcnt_requests_mtx_ is locked.

void send_refcnt_requests_sync(std::unique_lock<mutex_type> &l, error_code &ec)#: Assumes that refcnt_requests_mtx_ is locked.

HPX master documentation

hpx/agas/addressing_service.hpp

hpx/agas/addressing_service.hpp#