static lcos::future<Result>
call(naming::id_type const& id, naming::address && addr, Ts &&... vs)
{
bool target_is_managed = false;
naming::id_type id1;
if (id.get_management_type() == naming::id_type::managed)
{
id1 = naming::id_type(id.get_gid(), naming::id_type::unmanaged);
target_is_managed = true;
}
lcos::packaged_action<Action, Result> p;
p.apply(std::move(addr), target_is_managed ? id1 : id,
std::forward<Ts>(vs)...);
// keep id alive, if needed - this allows to send the destination
// as an unmanaged id
future<Result> f = p.get_future();
if (target_is_managed)
{
typedef typename traits::detail::shared_state_ptr_for<
future<Result>
>::type shared_state_ptr;
shared_state_ptr const& state = traits::detail::get_shared_state(f);
state->set_on_completed(hpx::detail::keep_id_alive(id));
}
return f;
}
typename boost::enable_if_c<
util::tuple_size<typename Action::arguments_type>::value == 1
, lcos::future<
typename traits::promise_local_result<
typename hpx::actions::extract_action<Action>::remote_result_type
>::type>
>::type
async_colocated(
naming::id_type const& gid
, Arg0 && arg0)
{
agas::request req(agas::primary_ns_resolve_gid, gid.get_gid());
naming::id_type service_target(
agas::stubs::primary_namespace::get_service_instance(gid.get_gid())
, naming::id_type::unmanaged);
typedef agas::server::primary_namespace::service_action action_type;
using util::placeholders::_2;
return async_continue<action_type>(
service_target, req
, util::functional::async_continuation(
util::bind<Action>(
util::bind(util::functional::extract_locality(gid), _2)
, std::forward<Arg0>( arg0 ))
));
}
typename std::enable_if<
traits::is_continuation<Continuation>::value
, bool
>::type
apply_colocated(Continuation && cont,
naming::id_type const& gid, Ts&&... vs)
{
// shortcut co-location code if target already is a locality
if (naming::is_locality(gid))
{
return apply_c<Action>(std::forward<Continuation>(cont), gid,
std::forward<Ts>(vs)...);
}
// Attach the requested action as a continuation to a resolve_async
// call on the locality responsible for the target gid.
agas::request req(agas::primary_ns_resolve_gid, gid.get_gid());
naming::id_type service_target(
agas::stubs::primary_namespace::get_service_instance(gid.get_gid()),
naming::id_type::unmanaged);
typedef agas::server::primary_namespace::service_action action_type;
using util::placeholders::_2;
return apply_continue<action_type>(
util::functional::apply_continuation(
util::bind<Action>(
util::bind(util::functional::extract_locality(), _2, gid),
std::forward<Ts>(vs)...),
std::forward<Continuation>(cont)),
service_target, req);
}
void trigger_lco_event(naming::id_type const& id, naming::address && addr,
naming::id_type const& cont, bool move_credits)
{
typedef lcos::base_lco::set_event_action set_action;
typedef
hpx::traits::extract_action<set_action>::local_result_type
local_result_type;
typedef
hpx::traits::extract_action<set_action>::remote_result_type
remote_result_type;
if (move_credits &&
id.get_management_type() != naming::id_type::unmanaged)
{
naming::id_type target(id.get_gid(), id_type::managed_move_credit);
id.make_unmanaged();
detail::apply_impl<set_action>(
actions::typed_continuation<
local_result_type, remote_result_type>(cont),
target, std::move(addr), actions::action_priority<set_action>());
}
else
{
detail::apply_impl<set_action>(
actions::typed_continuation<
local_result_type, remote_result_type>(cont),
id, std::move(addr), actions::action_priority<set_action>());
}
}
naming::gid_type component_storage::migrate_to_here(
std::vector<char> const& data, naming::id_type id,
naming::address const& current_lva)
{
naming::gid_type gid(naming::detail::get_stripped_gid(id.get_gid()));
data_[gid] = data;
// rebind the object to this storage locality
naming::address addr(current_lva);
addr.address_ = 0; // invalidate lva
if (!agas::bind(launch::sync, gid, addr, this->gid_))
{
std::ostringstream strm;
strm << "failed to rebind id " << id
<< "to storage locality: " << gid_;
HPX_THROW_EXCEPTION(duplicate_component_address,
"component_storage::migrate_to_here",
strm.str());
return naming::invalid_gid;
}
id.make_unmanaged(); // we can now release the object
return naming::invalid_gid;
}
lcos::future<
typename traits::promise_local_result<
typename hpx::traits::extract_action<Action>::remote_result_type
>::type>
async_colocated(naming::id_type const& gid, Ts&&... vs)
{
// Attach the requested action as a continuation to a resolve_async
// call on the locality responsible for the target gid.
naming::id_type service_target(
agas::primary_namespace::get_service_instance(gid.get_gid())
, naming::id_type::unmanaged);
typedef
typename hpx::traits::extract_action<Action>::remote_result_type
remote_result_type;
typedef agas::server::primary_namespace::colocate_action action_type;
using util::placeholders::_2;
return detail::async_continue_r<action_type, remote_result_type>(
util::functional::async_continuation(
util::bind<Action>(
util::bind(util::functional::extract_locality(), _2, gid)
, std::forward<Ts>(vs)...)
), service_target, gid.get_gid());
}
bool apply_colocated_cb(Continuation && cont,
naming::id_type const& gid, Callback&& cb, Ts&&... vs)
{
// shortcut co-location code if target already is a locality
if (naming::is_locality(gid))
{
return apply_p_cb<Action>(std::forward<Continuation>(cont), gid,
actions::action_priority<Action>(),
std::forward<Callback>(cb), std::forward<Ts>(vs)...);
}
// Attach the requested action as a continuation to a resolve_async
// call on the locality responsible for the target gid.
naming::id_type service_target(
agas::primary_namespace::get_service_instance(gid.get_gid()),
naming::id_type::unmanaged);
typedef agas::server::primary_namespace::colocate_action action_type;
using util::placeholders::_2;
return apply_continue_cb<action_type>(
util::functional::apply_continuation(
util::bind<Action>(
util::bind(util::functional::extract_locality(), _2, gid)
, std::forward<Ts>(vs)...)
, std::forward<Continuation>(cont)),
service_target, std::forward<Callback>(cb), gid.get_gid());
}
void set_lco_error(naming::id_type const& id, boost::exception_ptr const& e)
{
naming::id_type target(id.get_gid(), id_type::managed_move_credit);
id.make_unmanaged();
lcos::base_lco::set_exception_action set;
apply(set, target, e);
}
void trigger_lco_event(naming::id_type const& id, naming::id_type const& cont)
{
naming::id_type target(id.get_gid(), id_type::managed_move_credit);
id.make_unmanaged();
lcos::base_lco::set_event_action set;
apply_c(set, cont, target);
}
void set_lco_error(naming::id_type const& id, //-V659
boost::exception_ptr && e, naming::id_type const& cont)
{
naming::id_type target(id.get_gid(), id_type::managed_move_credit);
id.make_unmanaged();
lcos::base_lco::set_exception_action set;
apply_c(set, cont, target, std::move(e));
}
inline bool is_local_address_cached(
naming::id_type const& gid
, error_code& ec = throws
)
{
return is_local_address_cached(gid.get_gid(), ec);
}
void set_lco_error(naming::id_type const& id, naming::address && addr,
std::exception_ptr const& e, bool move_credits)
{
typedef lcos::base_lco::set_exception_action set_action;
if (move_credits &&
id.get_management_type() != naming::id_type::unmanaged)
{
naming::id_type target(id.get_gid(), id_type::managed_move_credit);
id.make_unmanaged();
detail::apply_impl<set_action>(
target, std::move(addr), actions::action_priority<set_action>(), e);
}
else
{
detail::apply_impl<set_action>(
id, std::move(addr), actions::action_priority<set_action>(), e);
}
}
bool apply_colocated(naming::id_type const& gid, Ts&&... vs)
{
// Attach the requested action as a continuation to a resolve_async
// call on the locality responsible for the target gid.
agas::request req(agas::primary_ns_resolve_gid, gid.get_gid());
naming::id_type service_target(
agas::stubs::primary_namespace::get_service_instance(gid.get_gid()),
naming::id_type::unmanaged);
typedef agas::server::primary_namespace::service_action action_type;
using util::placeholders::_2;
return apply_continue<action_type>(
util::functional::apply_continuation(
util::bind<Action>(
util::bind(util::functional::extract_locality(), _2, gid),
std::forward<Ts>(vs)...)),
service_target, req);
}
inline bool
apply_r_p(naming::address& addr, naming::id_type const& gid,
threads::thread_priority priority)
{
typedef typename hpx::actions::extract_action<Action>::type action_type;
// If remote, create a new parcel to be sent to the destination
// Create a new parcel with the gid, action, and arguments
parcelset::parcel p (gid.get_gid(), complement_addr<action_type>(addr),
new hpx::actions::transfer_action<action_type>(priority));
// Send the parcel through the parcel handler
hpx::applier::get_applier().get_parcel_handler().put_parcel(p);
return false; // destination is remote
}
static bool is_service_instance(naming::id_type const& id)
{
return is_service_instance(id.get_gid());
}
static naming::gid_type get_service_instance(naming::id_type const& dest)
{
return get_service_instance(dest.get_gid());
}
inline bool is_local_lva_encoded_address(
naming::id_type const& gid
)
{
return is_local_lva_encoded_address(gid.get_gid());
}
