///////////////////////////////////////////////////////////////////////
// expand main counter name
bool expand_counter_info_threads(
counter_info& i, counter_path_elements& p,
discover_counter_func const& f, error_code& ec)
{
std::size_t num_threads = get_os_thread_count();
for (std::size_t l = 0; l != num_threads; ++l)
{
p.instanceindex_ = static_cast<boost::int64_t>(l);
counter_status status = get_counter_name(p, i.fullname_, ec);
if (!status_is_valid(status) || !f(i, ec) || ec)
return false;
}
return true;
}
// store all information required for static allocation in
// proxies_static_allocation_data
// also store new proxy scheduler
void resource_manager::preprocess_static_allocation(
std::size_t min_punits, std::size_t max_punits)
{
proxies_map_type::iterator it;
proxies_static_allocation_data.clear();
for (proxies_map_type::iterator it = proxies_.begin();
it != proxies_.end(); ++it)
{
proxy_data& p = (*it).second;
static_allocation_data st;
st.proxy_ = p.proxy_;
// ask executor for its policies
error_code ec1(lightweight);
st.min_proxy_cores_ =
p.proxy_->get_policy_element(detail::min_concurrency, ec1);
if (ec1) st.min_proxy_cores_ = 1;
st.max_proxy_cores_ =
p.proxy_->get_policy_element(detail::max_concurrency, ec1);
if (ec1) st.max_proxy_cores_ = get_os_thread_count();
st.num_borrowed_cores_ = 0;
st.num_owned_cores_ = 0;
for (coreids_type coreids : p.core_ids_)
{
if (punits_[coreids.first].use_count_ > 1)
st.num_borrowed_cores_++;
if (punits_[coreids.first].use_count_ == 1)
st.num_owned_cores_++;
}
proxies_static_allocation_data.insert(
allocation_data_map_type::value_type((*it).first , st));
}
std::size_t cookie = next_cookie_ + 1;
static_allocation_data st;
st.min_proxy_cores_ = min_punits;
st.max_proxy_cores_ = max_punits;
st.adjusted_desired_ = static_cast<double>(max_punits);
st.num_cores_stolen_ = 0;
proxies_static_allocation_data.insert(
allocation_data_map_type::value_type(cookie , st));
}
// Request an initial resource allocation
std::size_t resource_manager::initial_allocation(
detail::manage_executor* proxy, error_code& ec)
{
if (nullptr == proxy) {
HPX_THROWS_IF(ec, bad_parameter,
"resource_manager::init_allocation",
"manage_executor pointer is a nullptr");
return std::size_t(-1);
}
// ask executor for its policies
error_code ec1(lightweight);
std::size_t min_punits =
proxy->get_policy_element(detail::min_concurrency, ec1);
if (ec1) min_punits = 1;
std::size_t max_punits =
proxy->get_policy_element(detail::max_concurrency, ec1);
if (ec1) max_punits = get_os_thread_count();
// lock the resource manager from this point on
std::lock_guard<mutex_type> l(mtx_);
// allocate initial resources for the given executor
std::vector<std::pair<std::size_t, std::size_t> > cores =
allocate_virt_cores(proxy, min_punits, max_punits, ec);
if (ec) return std::size_t(-1);
// attach the given proxy to this resource manager
std::size_t cookie = ++next_cookie_;
proxies_.insert(proxies_map_type::value_type(
cookie, proxy_data(proxy, std::move(cores))));
if (&ec != &throws)
ec = make_success_code();
return cookie;
}
static_priority_queue_os_executor::static_priority_queue_os_executor()
: scheduled_executor(new detail::thread_pool_os_executor<
policies::static_priority_queue_scheduler<> >(get_os_thread_count()))
{}
local_queue_os_executor::local_queue_os_executor()
: scheduled_executor(new detail::thread_pool_os_executor<
policies::local_queue_scheduler<> >(get_os_thread_count()))
{}
static_priority_queue_executor::static_priority_queue_executor()
: scheduled_executor(new detail::thread_pool_executor<
policies::static_priority_queue_scheduler<lcos::local::spinlock> >(
get_os_thread_count(), 1))
{}
local_priority_queue_executor::local_priority_queue_executor()
: scheduled_executor(new detail::thread_pool_executor<
policies::local_priority_queue_scheduler<> >(
get_os_thread_count(), 1, "local_priority_queue_executor"))
{}
throttle_queue_executor::throttle_queue_executor()
: scheduled_executor(new detail::thread_pool_executor<
policies::throttle_queue_scheduler<> >(
get_os_thread_count(), 1))
{}
static_queue_executor::static_queue_executor()
: scheduled_executor(new detail::thread_pool_executor<
policies::static_queue_scheduler<> >(
get_os_thread_count(), 1, "static_queue_executor"))
{}
// the resource manager is locked while executing this function
std::vector<std::pair<std::size_t, std::size_t> >
resource_manager::allocate_virt_cores(
detail::manage_executor* proxy, std::size_t min_punits,
std::size_t max_punits, error_code& ec)
{
std::vector<coreids_type> core_ids;
// array of available processing units
std::vector<punit_status> available_punits(
get_os_thread_count(), punit_status::unassigned);
// find all available processing units with zero use count
std::size_t reserved = reserve_processing_units(0, max_punits,
available_punits);
if (reserved < max_punits)
{
// insufficient available cores found, try to share
// processing units
preprocess_static_allocation(min_punits, max_punits);
reserved += release_cores_on_existing_schedulers(
release_borrowed_cores, available_punits);
if(reserved < max_punits)
{
reserved += redistribute_cores_among_all(
reserved, min_punits, max_punits, available_punits);
if (reserved < min_punits)
{
reserved += release_cores_on_existing_schedulers(
release_cores_to_min, available_punits);
if (reserved < min_punits)
{
reserve_at_higher_use_count(
min_punits - reserved , available_punits);
}
}
}
}
// processing units found, inform scheduler
std::size_t punit = 0;
for (std::size_t i = 0; i != available_punits.size(); ++i)
{
if (available_punits[i] == punit_status::reserved) //-V104
{
proxy->add_processing_unit(punit, i, ec);
if (ec) break;
core_ids.push_back(std::make_pair(i, punit));
++punit;
// update use count for reserved processing units
++punits_[i].use_count_;
}
}
HPX_ASSERT(punit <= max_punits);
if (ec) {
// on error, remove the already assigned virtual cores
for (std::size_t j = 0; j != punit; ++j)
{
proxy->remove_processing_unit(j, ec);
--punits_[j].use_count_;
}
return std::vector<coreids_type>();
}
if (&ec != &throws)
ec = make_success_code();
return core_ids;
}
resource_manager::resource_manager()
: next_cookie_(0),
punits_(get_os_thread_count()),
topology_(get_topology())
{}
