/// Register the id wrapped in the given future using the given base name.
///
/// The function registers the object the given future refers to using the
/// provided base name.
///
/// \param base_name [in] The base name for which to retrieve the
/// registered ids.
/// \param f [in] The future which should be registered using
/// the given base name.
/// \param sequence_nr [in, optional] The sequential number to use for the
/// registration of the id. This number has to be
/// unique system wide for each registration using the
/// same base name. The default is the current locality
/// identifier. Also, the sequence numbers have to be
/// consecutive starting from zero.
///
/// \returns A future representing the result of the registration operation
/// itself.
///
/// \note The operation will fail if the given sequence number is not
/// unique.
///
inline hpx::future<bool> register_with_basename(std::string const& base_name,
hpx::future<hpx::id_type> f, std::size_t sequence_nr = ~0U)
{
return f.then(
[=](hpx::future<hpx::id_type> && f) mutable
{
return register_with_basename(base_name, f.get(), sequence_nr);
});
}
barrier::barrier(std::string const& base_name, std::size_t num, std::size_t rank)
: node_(new (hpx::components::component_heap<wrapping_type>().alloc())
wrapping_type(new wrapped_type(base_name, num, rank)))
{
if ((*node_)->num_ >= (*node_)->cut_off_ || (*node_)->rank_ == 0)
register_with_basename(
base_name, node_->get_unmanaged_id(), (*node_)->rank_)
.get();
}
hpx::future<bool> register_with_basename(std::string const& base_name,
components::client_base<Client, Stub>& client,
std::size_t sequence_nr = ~0U)
{
return client.then(
[=](components::client_base<Client, Stub> && c)
{
return register_with_basename(base_name, c.get_id(), sequence_nr);
});
}
barrier::barrier(std::string const& base_name)
: node_(new (hpx::components::component_heap<wrapping_type>().alloc())
wrapping_type(new wrapped_type(base_name,
hpx::get_num_localities(hpx::launch::sync),
hpx::get_locality_id())))
{
if ((*node_)->num_ >= (*node_)->cut_off_ || (*node_)->rank_ == 0)
register_with_basename(
base_name, node_->get_unmanaged_id(), (*node_)->rank_).get();
}
barrier::barrier(std::string const& base_name,
std::vector<std::size_t> const& ranks, std::size_t rank)
{
auto rank_it = std::find(ranks.begin(), ranks.end(), rank);
HPX_ASSERT(rank_it != ranks.end());
std::size_t barrier_rank = std::distance(ranks.begin(), rank_it);
node_.reset(
new (hpx::components::component_heap<wrapping_type>().alloc())
wrapping_type(
new wrapped_type(base_name, ranks.size(), barrier_rank)));
if ((*node_)->num_ >= (*node_)->cut_off_ || (*node_)->rank_ == 0)
register_with_basename(
base_name, node_->get_unmanaged_id(), (*node_)->rank_)
.get();
}
