Esempio n. 1
0
 /// 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);
         });
 }
Esempio n. 2
0
    hpx::future<void> barrier_node::do_wait(This this_,
        hpx::future<void> future)
    {
        if (rank_ == 0)
        {
            return future.then(hpx::launch::sync,
                [this_](hpx::future<void>&& f)
                {
                    // Trigger possible errors...
                    f.get();

                    std::vector<hpx::future<void> > futures;
                    futures.reserve(this_->children_.size());

                    // After the root process received the notification that
                    // everyone entered the barrier, it will broadcast to
                    // everyone that they can leave the barrier
                    for(hpx::id_type& id : this_->children_)
                    {
                        base_lco::set_event_action action;
                        futures.push_back(hpx::async(action, id));
                    }

                    return hpx::when_all(futures);
                });
        }

        return future.then(hpx::launch::sync,
            [this_](hpx::future<void>&& f)
            {
                // Trigger possible errors...
                f.get();

                // Once the non-roots are ready to leave the barrier, we
                // need to reset our promises such that the barrier can be
                // reused.
                this_->broadcast_promise_ = hpx::lcos::local::promise<void>();
                this_->gather_promise_ = hpx::lcos::local::promise<void>();
            });
    }