void Topology::set_thread_cpubind(identifier_type numa_node){ #ifdef M3BP_LOCALITY_ENABLED const auto num_nodes = m_available_numa_nodes.size(); assert(numa_node < num_nodes); hwloc_obj_t obj; if(num_nodes == 1){ obj = hwloc_get_obj_by_type(m_topology, HWLOC_OBJ_MACHINE, 0); if(!obj){ throw std::runtime_error( "An error occured on " "`hwloc_get_obj_by_type(HWLOC_OBJ_MACHINE)`"); } }else{ obj = hwloc_get_obj_by_type( m_topology, HWLOC_OBJ_NODE, m_available_numa_nodes[numa_node]); if(!obj){ throw std::runtime_error( "An error occured on `hwloc_get_obj_by_type(HWLOC_OBJ_NODE)`"); } } if(hwloc_set_cpubind(m_topology, obj->cpuset, HWLOC_CPUBIND_THREAD) != 0){ throw std::runtime_error("An error occured on `hwloc_set_cpubind()`"); } # ifdef M3BP_NO_THREAD_LOCAL g_ts_binded_node.get() = numa_node; # else g_binded_node = numa_node; # endif #else (void)(numa_node); #endif }
void qrm_hwloc_topo(int *nodes, int *topo) { int depth, ret; unsigned i, n, j, ncores, nnodes, cnode; int topodepth, numa; hwloc_topology_t topology; hwloc_cpuset_t cpuset; hwloc_obj_t obj, cobj; hwloc_obj_type_t otype; hwloc_topology_init(&topology); hwloc_topology_load(topology); /* get the number os cores and NUMA nodes */ ncores = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_CORE); printf("ncores: %d\n",ncores); nnodes = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_NODE); if(nnodes == 0){ otype = HWLOC_OBJ_SOCKET; printf("grouping with sockets\n"); nnodes = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_SOCKET); } else { otype = HWLOC_OBJ_NODE; printf("grouping with NUMA nodes\n"); } /* get the handle for the first NUMA node */ obj = hwloc_get_obj_by_type(topology, otype, 0); /* get the number of cores in one NUMA node (supposedly the same for all nodes) */ cnode = hwloc_get_nbobjs_inside_cpuset_by_type(topology, obj->cpuset, HWLOC_OBJ_CORE); for(i=0; i<nnodes; i++){ /* get the handle for the first i-th node */ obj = hwloc_get_obj_by_type(topology, otype, i); /* get the number of cores in i-th NUMA node (supposedly the same for all nodes) */ cnode = hwloc_get_nbobjs_inside_cpuset_by_type(topology, obj->cpuset, HWLOC_OBJ_CORE); /* get the first core in this node */ cobj = hwloc_get_next_obj_inside_cpuset_by_type(topology, obj->cpuset, HWLOC_OBJ_CORE, NULL); topo[(i*cnode)] = cobj->logical_index; /* printf("%2d -- group: %2d",i,cobj->logical_index); */ for(j=1; j<cnode; j++){ cobj = hwloc_get_next_obj_inside_cpuset_by_type(topology, obj->cpuset, HWLOC_OBJ_CORE, cobj); topo[(i*cnode)+j] = cobj->logical_index; /* printf(" %2d",cobj->logical_index); */ } /* printf("\n"); */ } hwloc_topology_destroy(topology); return; }
signed getNodeForCore(unsigned core) { hwloc_topology_t topology = getHWTopology(); unsigned nodes = getNumberOfNodes(topology); hwloc_obj_t core_obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, core); for (unsigned i = 0; i < nodes; i++) { hwloc_obj_t obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, i); if (hwloc_obj_is_in_subtree(topology, core_obj, obj)) { return i; } } return -1; }
unsigned getNodeForCore(unsigned core){ hwloc_topology_t topology = getHWTopology(); unsigned nodes = getNumberOfNodes(topology); hwloc_obj_t obj; hwloc_obj_t core_obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, core); for(unsigned i = 0; i < nodes; i++){ obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, i); if (hwloc_obj_is_in_subtree(topology, core_obj, obj)){ return i; } } throw std::runtime_error("expected to find node for core"); }
void darts :: hwloc :: AbstractMachine :: discoverTopologyWithLLC(void) { unsigned nbSockets = hwloc_get_nbobjs_by_type(_topology,HWLOC_OBJ_SOCKET); hwloc_obj_t o = hwloc_get_obj_by_type(_topology,HWLOC_OBJ_SOCKET,0); hwloc_obj_t obj; for (obj = o->first_child; obj && obj->type != HWLOC_OBJ_CACHE; obj = obj->first_child) ; _nbClusters = nbSockets; if (obj) { int n = hwloc_get_nbobjs_inside_cpuset_by_type(_topology,obj->cpuset,HWLOC_OBJ_PU); _nbClusters = _nbTotalUnits / n; // XXX assumes homogeneous distribution of PUs } _clusterMap = new Cluster[_nbClusters]; // TODO Refactor this code and the next function's code into a single one for (o = obj; o; o = o->next_cousin) { int nUnits = hwloc_get_nbobjs_inside_cpuset_by_type(_topology,o->cpuset,HWLOC_OBJ_PU); Unit *units = new Unit[nUnits]; for (int i = 0; i < nUnits; ++i) { hwloc_obj_t t = hwloc_get_obj_inside_cpuset_by_type(_topology,o->cpuset,HWLOC_OBJ_PU,i); Unit hwu(o->logical_index,t->logical_index,t->os_index); units[i] = hwu; // simple shallow copy } Cluster cluster(o->logical_index,o->logical_index,nUnits,units); _clusterMap[o->logical_index] = cluster; // simple shallow copy } }
void AbstractCoreBoundTaskQueue::launchThread(int core) { //get the number of cores on system int NUM_PROCS = getNumberOfCoresOnSystem(); if (core < NUM_PROCS) { _thread = new std::thread(&AbstractTaskQueue::executeTask, this); hwloc_cpuset_t cpuset; hwloc_obj_t obj; hwloc_topology_t topology = getHWTopology(); obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, core); // the bitmap to modify cpuset = hwloc_bitmap_dup(obj->cpuset); // remove hyperthreads hwloc_bitmap_singlify(cpuset); // bind if (hwloc_set_thread_cpubind(topology, _thread->native_handle(), cpuset, HWLOC_CPUBIND_STRICT | HWLOC_CPUBIND_NOMEMBIND)) { char *str; int error = errno; hwloc_bitmap_asprintf(&str, obj->cpuset); fprintf(stderr, "Couldn't bind to cpuset %s: %s\n", str, strerror(error)); fprintf(stderr, "Continuing as normal, however, no guarantees\n"); //throw std::runtime_error(strerror(error)); } hwloc_bitmap_free(cpuset); } else { // this case should never happen, as TaskQueue is only initialized from SimpleTaskScheduler, which captures this case throw std::logic_error("CPU to run thread on is larger than number of total cores; seems that TaskQueue was initialized outside of SimpleTaskScheduler, which should not happen"); } }
std::size_t hwloc_topology::init_node_number( std::size_t num_thread, hwloc_obj_type_t type ) { // {{{ if (std::size_t(-1) == num_thread) return std::size_t(-1); std::size_t num_pu = num_thread % num_of_pus_; { hwloc_obj_t obj; { scoped_lock lk(topo_mtx); obj = hwloc_get_obj_by_type(topo, HWLOC_OBJ_PU, static_cast<unsigned>(num_pu)); } while (obj) { if (hwloc_compare_types(obj->type, type) == 0) { // on Windows os_index is always -1 if (obj->logical_index == ~0x0u) return static_cast<std::size_t>(obj->os_index); return static_cast<std::size_t>(obj->logical_index); } obj = obj->parent; } } return 0; } // }}}
/* * Get the number of net cards in a NUMA node */ int hw_get_nnetcards(int NUMAnode) { int count, net_NUMAnode, error; hwloc_obj_t obj, obj_anc; count = 0; hwloc_topology_t topo_net; error = hwloc_topology_init(&topo_net); hwloc_topology_set_flags(topo_net, HWLOC_TOPOLOGY_FLAG_IO_DEVICES); if (!error){ hwloc_topology_load(topo_net); for (obj = hwloc_get_obj_by_type(topo_net, HWLOC_OBJ_OS_DEVICE, 0); obj; obj = hwloc_get_next_osdev(topo_net,obj)) if (obj->attr->osdev.type == HWLOC_OBJ_OSDEV_NETWORK || obj->attr->osdev.type == HWLOC_OBJ_OSDEV_OPENFABRICS){ obj_anc = hwloc_get_non_io_ancestor_obj(topo_net,obj); net_NUMAnode = hwloc_bitmap_first(obj_anc->nodeset); //only if the MPI NUMA node is equal to the found net card if(NUMAnode == net_NUMAnode) count++; } } hwloc_topology_destroy(topo_net); return count; }
Topology::Topology() : m_topology(initialize_topology()) , m_available_processing_units(enumerate_processing_units(m_topology)) , m_available_numa_nodes(enumerate_numa_nodes(m_topology)) , m_processing_units_per_node(m_available_numa_nodes.size()) { const auto num_nodes = m_available_numa_nodes.size(); for(const auto pu : m_available_processing_units){ if(num_nodes == 1){ ++m_processing_units_per_node[0]; }else{ auto obj = hwloc_get_obj_by_type(m_topology, HWLOC_OBJ_PU, pu); while(obj && obj->type != HWLOC_OBJ_NODE){ obj = obj->parent; } if(obj && obj->type == HWLOC_OBJ_NODE){ const auto it = std::find( m_available_numa_nodes.begin(), m_available_numa_nodes.end(), obj->logical_index); const auto index = it - m_available_numa_nodes.begin(); ++m_processing_units_per_node[index]; }else{ ++m_processing_units_per_node[0]; } } } }
mask_type hwloc_topology::init_socket_affinity_mask_from_socket( std::size_t num_socket ) const { // {{{ // If we have only one or no socket, the socket affinity mask // spans all processors if (std::size_t(-1) == num_socket) return machine_affinity_mask_; hwloc_obj_t socket_obj; { scoped_lock lk(topo_mtx); socket_obj = hwloc_get_obj_by_type(topo, HWLOC_OBJ_SOCKET, static_cast<unsigned>(num_socket)); } if (socket_obj) { mask_type socket_affinity_mask = 0; extract_node_mask(socket_obj, socket_affinity_mask); return socket_affinity_mask; } return machine_affinity_mask_; } // }}}
mask_type hwloc_topology::init_numa_node_affinity_mask_from_numa_node( std::size_t numa_node ) const { // {{{ // If we have only one or no NUMA domain, the NUMA affinity mask // spans all processors if (std::size_t(-1) == numa_node) { return machine_affinity_mask_; } hwloc_obj_t numa_node_obj; { scoped_lock lk(topo_mtx); numa_node_obj = hwloc_get_obj_by_type(topo, HWLOC_OBJ_NODE, static_cast<unsigned>(numa_node)); } if (numa_node_obj) { mask_type node_affinity_mask = 0; extract_node_mask(numa_node_obj, node_affinity_mask); return node_affinity_mask; } return machine_affinity_mask_; } // }}}
mask_type hwloc_topology::init_thread_affinity_mask( std::size_t num_thread ) const { // {{{ if (std::size_t(-1) == num_thread) { return get_core_affinity_mask(num_thread, false); } std::size_t num_pu = num_thread % num_of_pus_; hwloc_obj_t obj; { scoped_lock lk(topo_mtx); obj = hwloc_get_obj_by_type(topo, HWLOC_OBJ_PU, static_cast<unsigned>(num_pu)); } if (!obj) { return get_core_affinity_mask(num_thread, false); } mask_type mask = 0x0u; mask |= (static_cast<mask_type>(1) << obj->os_index); return mask; } // }}}
/* Wrapper routines for hwloc */ void qrm_hwloc_bind(int id) { int depth, ret; unsigned i, n; int topodepth; hwloc_topology_t topology; hwloc_cpuset_t cpuset; hwloc_obj_t obj; hwloc_topology_init(&topology); hwloc_topology_load(topology); obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, id); ret = hwloc_set_cpubind(topology, obj->cpuset, HWLOC_CPUBIND_THREAD); if (ret) { printf("Couldn't bind to core %d\n", id); assert(0); } else { printf("Bound to core %d\n", id); } hwloc_topology_destroy(topology); return; }
/* * Set the memory policy for data allocation for a process */ int hw_set_mempol(int mempol, int node) { int error; switch(mempol) { case OS: if (local_topo->nnodes != 0 ){ hwloc_obj_t obj; obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_MACHINE,0); error = hwloc_set_membind_nodeset(topology,obj->nodeset,HWLOC_MEMBIND_FIRSTTOUCH,0); } break; case LOCAL: if (local_topo->nnodes != 0 ){ node = hw_get_proc_node(); hwloc_obj_t obj; obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, node); error = hwloc_set_membind_nodeset(topology,obj->nodeset,HWLOC_MEMBIND_BIND,0); } break; case INTERLEAVE: if (local_topo->nnodes != 0 ){ node = hw_get_proc_node(); hwloc_obj_t obj; obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, node); obj = obj->parent; error = hwloc_set_membind_nodeset(topology,obj->nodeset,HWLOC_MEMBIND_INTERLEAVE,0); } break; case MANUAL: if (local_topo->nnodes != 0 ){ if (node == -1) node = hw_get_proc_node(); hwloc_obj_t obj; obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, node); error = hwloc_set_membind_nodeset(topology,obj->nodeset,HWLOC_MEMBIND_BIND,0); } break; default: error = 1; break; } return error; }
static inline const char *get_hn (hwloc_topology_t topo) { hwloc_obj_t obj; const char *hn = NULL; obj = hwloc_get_obj_by_type (topo, HWLOC_OBJ_MACHINE, 0); if (obj) hn = hwloc_obj_get_info_by_name (obj, "HostName"); return hn; }
std::vector<unsigned> getCoresForNode(hwloc_topology_t topology, unsigned node){ std::vector<unsigned> children; unsigned number_of_cores; // get hwloc obj for node hwloc_obj_t obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, node); // get all cores and check whether core is in subtree of node, if yes, push to vector // get number of cores by type number_of_cores = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_CORE); // iterate over cores and check whether in subtree hwloc_obj_t core; for(unsigned i = 0; i < number_of_cores; i++){ core = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, i); if(hwloc_obj_is_in_subtree(topology, core, obj)){ children.push_back(core->logical_index); } } return children; }
void bindCurrentThreadToNumaNode(int node) { hwloc_topology_t topology = getHWTopology(); hwloc_cpuset_t cpuset; hwloc_obj_t obj; // The actual node obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, node); // obj is nullptr on non NUMA machines if (obj == nullptr) { fprintf(stderr, "Couldn't get hwloc object, bindCurrentThreadToNumaNode failed!\n"); return; } cpuset = hwloc_bitmap_dup(obj->cpuset); // hwloc_bitmap_singlify(cpuset); // bind if (hwloc_set_cpubind(topology, cpuset, HWLOC_CPUBIND_STRICT | HWLOC_CPUBIND_NOMEMBIND | HWLOC_CPUBIND_THREAD)) { char* str; int error = errno; hwloc_bitmap_asprintf(&str, obj->cpuset); printf("Couldn't bind to cpuset %s: %s\n", str, strerror(error)); free(str); throw std::runtime_error(strerror(error)); } // free duplicated cpuset hwloc_bitmap_free(cpuset); // assuming single machine system obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_MACHINE, 0); // set membind policy interleave for this thread if (hwloc_set_membind_nodeset( topology, obj->nodeset, HWLOC_MEMBIND_INTERLEAVE, HWLOC_MEMBIND_STRICT | HWLOC_MEMBIND_THREAD) && errno != ENOSYS) { char* str; int error = errno; hwloc_bitmap_asprintf(&str, obj->nodeset); fprintf(stderr, "Couldn't membind to nodeset %s: %s\n", str, strerror(error)); fprintf(stderr, "Continuing as normal, however, no guarantees\n"); free(str); } }
/****** binding_support/get_number_of_cores() ************************************** * NAME * get_number_of_cores() -- Get number of cores per socket. * * SYNOPSIS * int get_number_of_cores(int socket_number) * * FUNCTION * Returns the number of cores for a specific socket. * * INPUTS * int socket_number - Logical socket number starting at 0. * * RESULT * int - Amount of cores for the given socket or 0. * * NOTES * MT-NOTE: get_number_of_cores() is MT safe * *******************************************************************************/ int get_number_of_cores(int socket_number) { #if HAVE_HWLOC hwloc_obj_t socket = hwloc_get_obj_by_type(sge_hwloc_topology, HWLOC_OBJ_SOCKET, socket_number); if (socket) return count_type_under(socket, HWLOC_OBJ_CORE); else #endif return 0; }
/* * Get the phys ids for cores */ void get_phys_id(hwloc_topology_t topology, int ncores,int cur_core) { unsigned i; hwloc_obj_t obj; for (i = 0; i < ncores; i++){ obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, i); phys_cpus[cur_core] = obj->os_index; cur_core++; } }
inline void __pact_hwloc_init() { hwloc_topology_init(&__pact_topo); hwloc_topology_load(__pact_topo); hwloc_obj_t obj; __pact_cache_size = 0; for (obj = hwloc_get_obj_by_type(__pact_topo, HWLOC_OBJ_PU, 0); obj; obj = obj->parent) { if (obj->type == HWLOC_OBJ_CACHE) __pact_cache_size += obj->attr->cache.size; } }
void __spm_init() { SPMR_DEBUG(std::cout << "Runtime: initialize\n"); hwloc_topology_init(&__spm_topo); hwloc_topology_load(__spm_topo); hwloc_obj_t obj; for (obj = hwloc_get_obj_by_type(__spm_topo, HWLOC_OBJ_PU, 0); obj; obj = obj->parent) if (obj->type == HWLOC_OBJ_CACHE) __spm_cache_size += obj->attr->cache.size; }
std::vector<unsigned> getCoresForNode(hwloc_topology_t topology, unsigned node) { std::vector<unsigned> children; // get number of cores by type unsigned number_of_cores = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_CORE); hwloc_obj_t obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, node); if (obj == nullptr) { // in case there is no node... children.resize(number_of_cores); std::iota(children.begin(), children.end(), 0); return children; } // get all cores and check whether core is in subtree of node, if yes, push to vector // iterate over cores and check whether in subtree for (unsigned i = 0; i < number_of_cores; i++) { hwloc_obj_t core = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, i); if (hwloc_obj_is_in_subtree(topology, core, obj)) { children.push_back(core->logical_index); } } return children; }
std::vector<hwloc_cpuset_t> getCPUSetsForNode(hwloc_topology_t topology, unsigned node) { std::vector<hwloc_cpuset_t> children; // get number of cores by type unsigned number_of_cores = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_CORE); hwloc_obj_t obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, node); if (obj == nullptr) { // in case there is no node... for (unsigned i = 0; i < number_of_cores; i++) { hwloc_obj_t core = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, i); children.push_back(core->cpuset); } return children; } // get all cores and check whether core is in subtree of node, if yes, push to vector // iterate over cores and check whether in subtree for (unsigned i = 0; i < number_of_cores; i++) { hwloc_obj_t core = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, i); if (hwloc_obj_is_in_subtree(topology, core, obj)) { children.push_back(core->cpuset); } } return children; }
void hwloc_init_cpuInfo(cpu_set_t cpuSet) { int i; hwloc_obj_t obj; hwloc_topology_init(&hwloc_topology); hwloc_topology_set_flags(hwloc_topology, HWLOC_TOPOLOGY_FLAG_WHOLE_IO ); hwloc_topology_load(hwloc_topology); obj = hwloc_get_obj_by_type(hwloc_topology, HWLOC_OBJ_SOCKET, 0); cpuid_info.model = 0; cpuid_info.family = 0; cpuid_info.isIntel = 0; cpuid_info.osname = malloc(MAX_MODEL_STRING_LENGTH * sizeof(char)); for(i=0;i<obj->infos_count;i++) { if (strcmp(obj->infos[i].name ,"CPUModelNumber") == 0) { cpuid_info.model = atoi(hwloc_obj_get_info_by_name(obj, "CPUModelNumber")); } else if (strcmp(obj->infos[i].name, "CPUFamilyNumber") == 0) { cpuid_info.family = atoi(hwloc_obj_get_info_by_name(obj, "CPUFamilyNumber")); } else if (strcmp(obj->infos[i].name, "CPUVendor") == 0 && strcmp(hwloc_obj_get_info_by_name(obj, "CPUVendor"), "GenuineIntel") == 0) { cpuid_info.isIntel = 1; } else if (strcmp(obj->infos[i].name ,"CPUModel") == 0) { strcpy(cpuid_info.osname, obj->infos[i].value); } } cpuid_topology.numHWThreads = hwloc_get_nbobjs_by_type(hwloc_topology, HWLOC_OBJ_PU); cpuid_info.stepping = get_stepping(); DEBUG_PRINT(DEBUGLEV_DEVELOP, HWLOC CpuInfo Family %d Model %d Stepping %d isIntel %d numHWThreads %d activeHWThreads %d, cpuid_info.family, cpuid_info.model, cpuid_info.stepping, cpuid_info.isIntel, cpuid_topology.numHWThreads, cpuid_topology.activeHWThreads) return; }
/* * Make a layout string of all available sockets and cores. Note that * this is *everything* -- not just the ones that are available to * this process. * * Example: [../..] * Key: [] - signifies socket * / - signifies core * . - signifies PU */ static int get_layout_exists(char str[OMPI_AFFINITY_STRING_MAX]) { int core_index, pu_index; int len = OMPI_AFFINITY_STRING_MAX; hwloc_obj_t socket, core, pu; str[0] = '\0'; /* Iterate over all existing sockets */ for (socket = hwloc_get_obj_by_type(opal_hwloc_topology, HWLOC_OBJ_SOCKET, 0); NULL != socket; socket = socket->next_cousin) { strncat(str, "[", len - strlen(str)); /* Iterate over all existing cores in this socket */ core_index = 0; for (core = hwloc_get_obj_inside_cpuset_by_type(opal_hwloc_topology, socket->cpuset, HWLOC_OBJ_CORE, core_index); NULL != core; core = hwloc_get_obj_inside_cpuset_by_type(opal_hwloc_topology, socket->cpuset, HWLOC_OBJ_CORE, ++core_index)) { if (core_index > 0) { strncat(str, "/", len - strlen(str)); } /* Iterate over all existing PUs in this core */ pu_index = 0; for (pu = hwloc_get_obj_inside_cpuset_by_type(opal_hwloc_topology, core->cpuset, HWLOC_OBJ_PU, pu_index); NULL != pu; pu = hwloc_get_obj_inside_cpuset_by_type(opal_hwloc_topology, core->cpuset, HWLOC_OBJ_PU, ++pu_index)) { strncat(str, ".", len - strlen(str)); } } strncat(str, "]", len - strlen(str)); } return OMPI_SUCCESS; }
/* *Get the direct siblings of a core - it is allways considering cache sharing * index: the logical id of the core * myid: the physical id of the core * obj: the HWLOC representation of the core * nsiblings: the number of siblings of the core */ void set_phys_siblings(int index, unsigned myid, hwloc_obj_t obj, int ncores, int nsiblings,int type) { int i,j = 0; hwloc_obj_t obj2, ant; for(i = 0; i< ncores && nsiblings > 0 ; i++) { obj2 = hwloc_get_obj_by_type(topology,type,i); ant = hwloc_get_common_ancestor_obj(topology,obj,obj2); if(ant->type == HWLOC_OBJ_CACHE && obj2->os_index != myid) { machine_cores[index].siblings_id[j] = obj2->os_index; j++; nsiblings--; ant = NULL; } } }
void darts :: hwloc :: AbstractMachine :: discoverTopology(void) { _nbClusters = hwloc_get_nbobjs_by_type(_topology,HWLOC_OBJ_SOCKET); _clusterMap = new Cluster[_nbClusters]; hwloc_obj_t o = hwloc_get_obj_by_type(_topology,HWLOC_OBJ_SOCKET,0); // TODO Refactor this code and the previous function's code into a single one for (; o; o = o->next_cousin) { int nUnits = hwloc_get_nbobjs_inside_cpuset_by_type(_topology,o->cpuset,HWLOC_OBJ_PU); Unit *units = new Unit[nUnits]; for (int i = 0; i < nUnits; ++i) { hwloc_obj_t t = hwloc_get_obj_inside_cpuset_by_type(_topology,o->cpuset,HWLOC_OBJ_PU,i); Unit hwu(o->logical_index,t->logical_index,t->os_index); units[i] = hwu; // simple shallow copy } Cluster cluster(o->logical_index,o->logical_index,nUnits,units); _clusterMap[o->logical_index] = cluster; // simple shallow copy } }
mask_type hwloc_topology::init_machine_affinity_mask() const { // {{{ mask_type machine_affinity_mask = 0; hwloc_obj_t machine_obj; { scoped_lock lk(topo_mtx); machine_obj = hwloc_get_obj_by_type(topo, HWLOC_OBJ_MACHINE, 0); } if (machine_obj) { extract_node_mask(machine_obj, machine_affinity_mask); return machine_affinity_mask; } HPX_THROW_EXCEPTION(kernel_error , "hpx::threads::hwloc_topology::init_machine_affinity_mask" , "failed to initialize machine affinity mask"); return 0; } // }}}
std::size_t hwloc_topology::get_number_of_numa_node_cores( std::size_t numa_node ) const { hwloc_obj_t node_obj; { scoped_lock lk(topo_mtx); node_obj = hwloc_get_obj_by_type(topo, HWLOC_OBJ_NODE, static_cast<unsigned>(numa_node)); } if (node_obj) { std::size_t pu_count = 0; return extract_node_count(node_obj, HWLOC_OBJ_CORE, pu_count); } return hwloc_get_nbobjs_by_type(topo, HWLOC_OBJ_CORE); }
std::size_t hwloc_topology::get_number_of_socket_pus( std::size_t num_socket ) const { hwloc_obj_t socket_obj; { scoped_lock lk(topo_mtx); socket_obj = hwloc_get_obj_by_type(topo, HWLOC_OBJ_SOCKET, static_cast<unsigned>(num_socket)); } if (socket_obj) { std::size_t pu_count = 0; return extract_node_count(socket_obj, HWLOC_OBJ_PU, pu_count); } return hwloc_get_nbobjs_by_type(topo, HWLOC_OBJ_PU); }