hpx::future<id_type> primary_namespace::colocate(naming::gid_type id)
{
naming::id_type dest = naming::id_type(get_service_instance(id),
naming::id_type::unmanaged);
if (naming::get_locality_from_gid(dest.get_gid()) == hpx::get_locality())
{
return hpx::make_ready_future(server_->colocate(id));
}
server::primary_namespace::colocate_action action;
return hpx::async(action, std::move(dest), id);
}
future<bool> primary_namespace::bind_gid_async(
gva g, naming::gid_type id, naming::gid_type locality)
{
naming::id_type dest = naming::id_type(get_service_instance(id),
naming::id_type::unmanaged);
if (naming::get_locality_from_gid(dest.get_gid()) == hpx::get_locality())
{
return hpx::make_ready_future(server_->bind_gid(g, id, locality));
}
server::primary_namespace::bind_gid_action action;
return hpx::async(action, std::move(dest), g, id, locality);
}
future<std::pair<naming::id_type, naming::address>>
primary_namespace::begin_migration(naming::gid_type id)
{
naming::id_type dest = naming::id_type(get_service_instance(id),
naming::id_type::unmanaged);
if (naming::get_locality_from_gid(dest.get_gid()) == hpx::get_locality())
{
return hpx::make_ready_future(server_->begin_migration(id));
}
server::primary_namespace::begin_migration_action action;
return hpx::async(action, std::move(dest), id);
}
static naming::id_type symbol_namespace_locality(std::string const& key)
{
boost::uint32_t hash_value = 0;
if (key.size() < 2 || key[1] != '0' || key[0] != '/')
{
// keys starting with '/0' have to go to node 0
util::jenkins_hash hash;
hash_value = hash(key) % get_initial_num_localities();
}
return naming::id_type(get_service_instance(hash_value),
naming::id_type::unmanaged);
}
naming::address
primary_namespace::unbind_gid(std::uint64_t count, naming::gid_type id)
{
naming::id_type dest = naming::id_type(get_service_instance(id),
naming::id_type::unmanaged);
naming::gid_type stripped_id = naming::detail::get_stripped_gid(id);
if (naming::get_locality_from_gid(dest.get_gid()) == hpx::get_locality())
{
return server_->unbind_gid(count, stripped_id);
}
server::primary_namespace::unbind_gid_action action;
return action(std::move(dest), count, stripped_id);
}
naming::gid_type primary_namespace::get_service_instance(naming::gid_type const& dest,
error_code& ec)
{
std::uint32_t service_locality_id = naming::get_locality_id_from_gid(dest);
if (service_locality_id == naming::invalid_locality_id)
{
HPX_THROWS_IF(ec, bad_parameter,
"primary_namespace::get_service_instance",
boost::str(boost::format(
"can't retrieve a valid locality id from global address (%1%): "
) % dest));
return naming::gid_type();
}
return get_service_instance(service_locality_id);
}
future<std::int64_t> primary_namespace::increment_credit(
std::int64_t credits
, naming::gid_type lower
, naming::gid_type upper
)
{
naming::id_type dest = naming::id_type(get_service_instance(lower),
naming::id_type::unmanaged);
if (naming::get_locality_from_gid(dest.get_gid()) == hpx::get_locality())
{
return hpx::make_ready_future(
server_->increment_credit(credits, lower, upper));
}
server::primary_namespace::increment_credit_action action;
return hpx::async(action, std::move(dest), credits, lower, upper);
}
hpx::future<symbol_namespace::iterate_names_return_type>
symbol_namespace::iterate_async(std::string const& pattern) const
{
using return_type = server::symbol_namespace::iterate_names_return_type;
auto localities = hpx::find_all_localities();
std::vector<hpx::id_type> symbol_services;
symbol_services.reserve(localities.size());
for (auto const& locality : localities)
{
auto gid = get_service_instance(
naming::get_locality_id_from_id(locality));
symbol_services.push_back(hpx::id_type(gid, hpx::id_type::unmanaged));
}
hpx::future<std::vector<return_type> > f =
lcos::broadcast<iterate_action>(symbol_services, pattern);
return f.then(
[](hpx::future<std::vector<return_type> > && f)
{
std::vector<return_type> && data = f.get();
std::map<std::string, hpx::id_type> result;
for (auto && d : data)
{
for (auto && e : d)
{
bool has_credits = naming::detail::has_credits(e.second);
result[std::move(e.first)] =
hpx::id_type(std::move(e.second),
has_credits ?
naming::id_type::managed :
naming::id_type::unmanaged);
}
}
return result;
});
}
void primary_namespace::route(parcelset::parcel && p,
util::function_nonser<void(boost::system::error_code const&,
parcelset::parcel const&)> && f)
{
// compose request
naming::gid_type const& id = p.destination();
naming::id_type dest = naming::id_type(get_service_instance(id),
naming::id_type::unmanaged);
if (naming::get_locality_from_gid(dest.get_gid()) == hpx::get_locality())
{
hpx::apply(
&server::primary_namespace::route,
server_.get(),
std::move(p)
);
f(boost::system::error_code(), parcelset::parcel());
return;
}
server::primary_namespace::route_action action;
hpx::apply_cb(action, std::move(dest), std::move(f), std::move(p));
}
naming::id_type primary_namespace::gid() const
{
return naming::id_type(
get_service_instance(hpx::get_locality()),
naming::id_type::unmanaged);
}
static naming::gid_type get_service_instance(naming::id_type const& dest)
{
return get_service_instance(dest.get_gid());
}
