std::vector<mask_info> extract_core_masks(hwloc_topology const& t, spec_type const& s, std::size_t socket, mask_cref_type socket_mask, error_code& ec) { std::vector<mask_info> masks; switch (s.type_) { case spec_type::core: { std::size_t base = 0; std::size_t num_cores = 0; if (socket != std::size_t(-1)) { for (std::size_t i = 0; i != socket; ++i) base += t.get_number_of_socket_cores(i); num_cores = t.get_number_of_socket_cores(socket); } else { num_cores = t.get_number_of_cores(); } bounds_type bounds = extract_bounds(s, num_cores, ec); if (ec) break; for (std::int64_t index : bounds) { mask_type mask = t.init_core_affinity_mask_from_core(index + base); masks.push_back(util::make_tuple(index, mask & socket_mask)); } } break; case spec_type::unknown: { mask_type mask = extract_machine_mask(t, ec); masks.push_back(util::make_tuple( std::size_t(-1), mask & socket_mask )); } break; default: HPX_THROWS_IF(ec, bad_parameter, "extract_core_mask", boost::str(boost::format( "unexpected specification type %s" ) % spec_type::type_name(s.type_))); break; } return masks; }
mask_type decode_mapping_socket(hwloc_topology const& t, mapping_type& m, std::size_t size, std::size_t thread_index, error_code& ec) { bounds_type b = extract_bounds(m[0], size, ec); if (ec) return 0; std::size_t index = std::size_t(-1); if (m[1].type_ == spec_type::unknown && m[2].type_ == spec_type::unknown && b.size() > 1) { index = thread_index; } mask_type mask = 0; std::size_t socket_index = 0; for (bounds_type::const_iterator it = b.begin(); it != b.end(); ++it, ++socket_index) { if (index == std::size_t(-1) || socket_index == index) mask |= t.init_socket_affinity_mask_from_socket(*it); } std::size_t socket_base_index = *b.begin(); if (thread_index != std::size_t(-1) && b.size() > 1) socket_base_index += thread_index; std::size_t base_index = 0; for (std::size_t i = 0; i != socket_base_index; ++i) base_index += t.get_number_of_socket_cores(i); return decode_mapping0_unknown(t, m, size, mask, base_index, thread_index, ec); }
std::vector<mask_info> extract_pu_masks(hwloc_topology const& t, spec_type const& s, std::size_t socket, std::size_t core, mask_cref_type core_mask, error_code& ec) { std::vector<mask_info> masks; switch (s.type_) { case spec_type::pu: { std::size_t num_pus = 0; std::size_t socket_base = 0; if (std::size_t(-1) != socket) { // core number is relative to socket for (std::size_t i = 0; i != socket; ++i) socket_base += t.get_number_of_socket_cores(i); } if (std::size_t(-1) != core) { num_pus = t.get_number_of_core_pus(core); } else { num_pus = t.get_number_of_pus(); } bounds_type bounds = extract_bounds(s, num_pus, ec); if (ec) break; std::size_t num_cores = t.get_number_of_cores(); for (std::int64_t index : bounds) { std::size_t base_core = socket_base; if (std::size_t(-1) != core) { base_core += core; } else { // find core the given pu belongs to std::size_t base = 0; for (/**/; base_core < num_cores; ++base_core) { std::size_t num_core_pus = t.get_number_of_core_pus(base_core); if (base + num_core_pus > std::size_t(index)) break; base += num_core_pus; } } mask_type mask = t.init_thread_affinity_mask(base_core, index); masks.push_back(util::make_tuple(index, mask & core_mask)); } } break; case spec_type::unknown: { mask_type mask = extract_machine_mask(t, ec); masks.push_back(util::make_tuple( std::size_t(-1), mask & core_mask )); } break; default: HPX_THROWS_IF(ec, bad_parameter, "extract_pu_mask", boost::str(boost::format( "unexpected specification type %s" ) % spec_type::type_name(s.type_))); break; } return masks; }