int main(void) { hwloc_topology_t topology; hwloc_bitmap_t cpuset; int err; /* check the OS topology */ hwloc_topology_init(&topology); hwloc_topology_load(topology); assert(hwloc_topology_is_thissystem(topology)); cpuset = hwloc_bitmap_dup(hwloc_topology_get_complete_cpuset(topology)); result("Binding with OS backend", hwloc_set_cpubind(topology, cpuset, 0)); hwloc_topology_destroy(topology); /* We're assume there is a real processor numbered 0 */ hwloc_bitmap_zero(cpuset); hwloc_bitmap_set(cpuset, 0); /* check a synthetic topology */ hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, "1"); hwloc_topology_load(topology); assert(!hwloc_topology_is_thissystem(topology)); err = hwloc_set_cpubind(topology, cpuset, 0); result("Binding with synthetic backend", err); assert(!err); hwloc_topology_destroy(topology); /* check a synthetic topology but assuming it's the system topology */ hwloc_topology_init(&topology); hwloc_topology_set_flags(topology, HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM); hwloc_topology_set_synthetic(topology, "1"); hwloc_topology_load(topology); assert(hwloc_topology_is_thissystem(topology)); result("Binding with synthetic backend faking is_thissystem", hwloc_set_cpubind(topology, cpuset, 0)); hwloc_topology_destroy(topology); hwloc_bitmap_free(cpuset); return 0; }
int main (void) { hwloc_topology_t topology; unsigned depth; hwloc_obj_t last; hwloc_obj_t *closest; unsigned found; int err; unsigned numprocs; hwloc_obj_t ancestor; err = hwloc_topology_init (&topology); if (err) return EXIT_FAILURE; hwloc_topology_set_synthetic (topology, "2 3 4 5"); err = hwloc_topology_load (topology); if (err) return EXIT_FAILURE; depth = hwloc_topology_get_depth(topology); /* get the last object of last level */ numprocs = hwloc_get_nbobjs_by_depth(topology, depth-1); last = hwloc_get_obj_by_depth(topology, depth-1, numprocs-1); /* allocate the array of closest objects */ closest = malloc(numprocs * sizeof(*closest)); assert(closest); /* get closest levels */ found = hwloc_get_closest_objs (topology, last, closest, numprocs); printf("looked for %u closest entries, found %u\n", numprocs, found); assert(found == numprocs-1); /* check first found is closest */ assert(closest[0] == hwloc_get_obj_by_depth(topology, depth-1, numprocs-5 /* arity is 5 on last level */)); /* check some other expected positions */ assert(closest[found-1] == hwloc_get_obj_by_depth(topology, depth-1, 1*3*4*5-1 /* last of first half */)); assert(closest[found/2-1] == hwloc_get_obj_by_depth(topology, depth-1, 1*3*4*5+2*4*5-1 /* last of second third of second half */)); assert(closest[found/2/3-1] == hwloc_get_obj_by_depth(topology, depth-1, 1*3*4*5+2*4*5+3*5-1 /* last of third quarter of third third of second half */)); /* get ancestor of last and less close object */ ancestor = hwloc_get_common_ancestor_obj(topology, last, closest[found-1]); assert(hwloc_obj_is_in_subtree(topology, last, ancestor)); assert(hwloc_obj_is_in_subtree(topology, closest[found-1], ancestor)); assert(ancestor == hwloc_get_root_obj(topology)->first_child); printf("ancestor type %u depth %u number %u is system level\n", ancestor->type, ancestor->depth, ancestor->logical_index); free(closest); hwloc_topology_destroy (topology); return EXIT_SUCCESS; }
int main(void) { static hwloc_topology_t oldtopology, topology; hwloc_bitmap_t cpuset = hwloc_bitmap_alloc(); unsigned node_indexes[3], core_indexes[6]; float node_distances[9], core_distances[36]; unsigned i,j; int err; for(i=0; i<3; i++) { node_indexes[i] = i; for(j=0; j<3; j++) node_distances[i*3+j] = (i == j ? 10.f : 20.f); } for(i=0; i<6; i++) { core_indexes[i] = i; for(j=0; j<6; j++) core_distances[i*6+j] = (i == j ? 4.f : 8.f); } hwloc_topology_init(&oldtopology); printf("building fake 'node:3 core:2 pu:4' topology\n"); hwloc_topology_set_synthetic(oldtopology, "node:3 core:2 pu:4"); printf("adding node and core matrices\n"); hwloc_topology_set_distance_matrix(oldtopology, HWLOC_OBJ_NUMANODE, 3, node_indexes, node_distances); hwloc_topology_set_distance_matrix(oldtopology, HWLOC_OBJ_CORE, 6, core_indexes, core_distances); hwloc_topology_load(oldtopology); printf("duplicating\n"); hwloc_topology_dup(&topology, oldtopology); printf("destroying the old topology\n"); hwloc_topology_destroy(oldtopology); /* remove the entire third node */ printf("removing one node\n"); hwloc_bitmap_fill(cpuset); hwloc_bitmap_clr_range(cpuset, 16, 23); err = hwloc_topology_restrict(topology, cpuset, HWLOC_RESTRICT_FLAG_ADAPT_DISTANCES); assert(!err); printf("checking the result\n"); assert(hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_NUMANODE) == 2); hwloc_topology_destroy(topology); hwloc_bitmap_free(cpuset); return 0; }
int main(void) { hwloc_topology_t topology; char *string = NULL; hwloc_obj_t obj; hwloc_bitmap_t set; hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, SYNTHETIC_TOPOLOGY_DESCRIPTION); hwloc_topology_load(topology); set = hwloc_bitmap_alloc(); hwloc_bitmap_sscanf(set, GIVEN_CPUSET_STRING); obj = hwloc_get_obj_covering_cpuset(topology, set); assert(obj); fprintf(stderr, "found covering object type %s covering cpuset %s\n", hwloc_obj_type_string(obj->type), GIVEN_CPUSET_STRING); assert(hwloc_bitmap_isincluded(set, obj->cpuset)); hwloc_bitmap_asprintf(&string, obj->cpuset); fprintf(stderr, "covering object of %s is %s, expected %s\n", GIVEN_CPUSET_STRING, string, EXPECTED_CPUSET_STRING); assert(!strcmp(EXPECTED_CPUSET_STRING, string)); free(string); hwloc_bitmap_sscanf(set, GIVEN_LARGESPLIT_CPUSET_STRING); obj = hwloc_get_obj_covering_cpuset(topology, set); assert(obj == hwloc_get_root_obj(topology)); fprintf(stderr, "found system as covering object of first+last cpus cpuset %s\n", GIVEN_LARGESPLIT_CPUSET_STRING); hwloc_bitmap_sscanf(set, GIVEN_TOOLARGE_CPUSET_STRING); obj = hwloc_get_obj_covering_cpuset(topology, set); assert(!obj); fprintf(stderr, "found no covering object for too-large cpuset %s\n", GIVEN_TOOLARGE_CPUSET_STRING); hwloc_bitmap_free(set); hwloc_topology_destroy(topology); return EXIT_SUCCESS; }
int main(void) { hwloc_topology_t topology; struct hwloc_distances_s *distances[2]; hwloc_obj_t objs[16]; uint64_t values[16*16]; unsigned depth, topodepth; unsigned i, j, k, nr; int err; hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, "node:4 core:4 pu:1"); hwloc_topology_load(topology); nr = 0; err = hwloc_distances_get(topology, &nr, distances, 0, 0); assert(!err); assert(!nr); if (!nr) printf("No distance\n"); printf("\nInserting NUMA distances\n"); for(i=0; i<4; i++) objs[i] = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, i); /* matrix 2*2 */ for(i=0; i<16; i++) values[i] = 8; values[0+4*1] = 4; values[1+4*0] = 4; values[2+4*3] = 4; values[3+4*2] = 4; for(i=0; i<4; i++) values[i+4*i] = 1; err = hwloc_distances_add(topology, 4, objs, values, HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER, HWLOC_DISTANCES_FLAG_GROUP); assert(!err); topodepth = hwloc_topology_get_depth(topology); for(depth=0; depth<topodepth; depth++) { nr = 0; err = hwloc_distances_get_by_depth(topology, depth, &nr, distances, 0, 0); assert(!err); if (depth == 2) assert(nr == 1); else assert(!nr); if (!nr) { printf("No distance at depth %u\n", depth); continue; } nr = 1; err = hwloc_distances_get_by_depth(topology, depth, &nr, distances, 0, 0); assert(!err); printf("distance matrix for depth %u:\n", depth); print_distances(distances[0]); hwloc_distances_release(topology, distances[0]); } /* check numa distances */ printf("Checking NUMA distances\n"); nr = 1; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_NUMANODE, &nr, distances, 0, 0); assert(!err); assert(nr == 1); assert(distances[0]); assert(distances[0]->objs); assert(distances[0]->values); assert(distances[0]->kind == (HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER)); /* check that some random values are ok */ assert(distances[0]->values[0] == 1); /* diagonal */ assert(distances[0]->values[4] == 4); /* same group */ assert(distances[0]->values[6] == 8); /* different group */ assert(distances[0]->values[9] == 8); /* different group */ assert(distances[0]->values[10] == 1); /* diagonal */ assert(distances[0]->values[14] == 4); /* same group */ hwloc_distances_release(topology, distances[0]); printf("\nInserting PU distances\n"); /* matrix 4*2*2 */ for(i=0; i<16; i++) objs[i] = hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, i); for(i=0; i<256; i++) values[i] = 8; for(i=0; i<4; i++) { for(j=0; j<4; j++) for(k=0; k<4; k++) values[i*64+i*4+16*j+k] = 4; values[i*64+i*4+1] = 2; values[i*64+i*4+16] = 2; values[i*64+i*4+2*16+3] = 2; values[i*64+i*4+3*16+2] = 2; } for(i=0; i<16; i++) values[i+16*i] = 1; err = hwloc_distances_add(topology, 16, objs, values, HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER, HWLOC_DISTANCES_FLAG_GROUP); assert(!err); topodepth = hwloc_topology_get_depth(topology); for(depth=0; depth<topodepth; depth++) { nr = 0; err = hwloc_distances_get_by_depth(topology, depth, &nr, distances, 0, 0); assert(!err); if (depth == 2 || depth == 5) assert(nr == 1); else assert(!nr); if (!nr) { printf("No distance at depth %u\n", depth); continue; } nr = 1; err = hwloc_distances_get_by_depth(topology, depth, &nr, distances, 0, 0); assert(!err); printf("distance matrix for depth %u:\n", depth); print_distances(distances[0]); hwloc_distances_release(topology, distances[0]); } /* check PU distances */ printf("Checking PU distances\n"); nr = 1; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_PU, &nr, distances, 0, 0); assert(!err); assert(nr == 1); assert(distances[0]); assert(distances[0]->values); assert(distances[0]->kind == (HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER)); /* check that some random values are ok */ assert(distances[0]->values[0] == 1); /* diagonal */ assert(distances[0]->values[1] == 2); /* same group */ assert(distances[0]->values[3] == 4); /* same biggroup */ assert(distances[0]->values[15] == 8); /* different biggroup */ assert(distances[0]->values[250] == 8); /* different biggroup */ assert(distances[0]->values[253] == 4); /* same group */ assert(distances[0]->values[254] == 2); /* same biggroup */ assert(distances[0]->values[255] == 1); /* diagonal */ hwloc_distances_release(topology, distances[0]); printf("\nInserting 2nd PU distances\n"); /* matrix 4*1 */ for(i=0; i<4; i++) objs[i] = hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, i); for(i=0; i<16; i++) values[i] = 3; for(i=0; i<4; i++) values[i+4*i] = 7; err = hwloc_distances_add(topology, 4, objs, values, HWLOC_DISTANCES_KIND_MEANS_BANDWIDTH|HWLOC_DISTANCES_KIND_FROM_USER, HWLOC_DISTANCES_FLAG_GROUP); assert(!err); topodepth = hwloc_topology_get_depth(topology); for(depth=0; depth<topodepth; depth++) { nr = 0; err = hwloc_distances_get_by_depth(topology, depth, &nr, distances, 0, 0); assert(!err); if (depth == 2) assert(nr == 1); else if (depth == 5) assert(nr == 2); else assert(!nr); if (!nr) { printf("No distance at depth %u\n", depth); continue; } nr = 2; err = hwloc_distances_get_by_depth(topology, depth, &nr, distances, 0, 0); assert(!err); printf("distance matrix for depth %u:\n", depth); print_distances(distances[0]); hwloc_distances_release(topology, distances[0]); if (nr > 1) { print_distances(distances[1]); hwloc_distances_release(topology, distances[1]); } } /* check PU distances */ printf("Checking 2nd PU distances\n"); nr = 2; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_PU, &nr, distances, 0, 0); assert(!err); assert(nr == 2); assert(distances[1]); assert(distances[1]->values); assert(distances[1]->kind == (HWLOC_DISTANCES_KIND_MEANS_BANDWIDTH|HWLOC_DISTANCES_KIND_FROM_USER)); /* check that some random values are ok */ assert(distances[1]->values[0] == 7); /* diagonal */ assert(distances[1]->values[1] == 3); /* other */ assert(distances[1]->values[3] == 3); /* other */ assert(distances[1]->values[15] == 7); /* diagonal */ hwloc_distances_release(topology, distances[0]); hwloc_distances_release(topology, distances[1]); /* check distances by kind */ nr = 2; err = hwloc_distances_get(topology, &nr, distances, HWLOC_DISTANCES_KIND_MEANS_BANDWIDTH, 0); assert(!err); assert(nr == 1); hwloc_distances_release(topology, distances[0]); nr = 2; err = hwloc_distances_get(topology, &nr, distances, HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_OS, 0); assert(!err); assert(nr == 0); nr = 2; err = hwloc_distances_get(topology, &nr, distances, HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER, 0); assert(!err); assert(nr == 2); hwloc_distances_release(topology, distances[0]); hwloc_distances_release(topology, distances[1]); /* remove distances */ printf("Removing distances\n"); /* remove both PU distances */ err = hwloc_distances_remove_by_type(topology, HWLOC_OBJ_PU); assert(!err); nr = 0; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_PU, &nr, distances, 0, 0); assert(!err); assert(!nr); nr = 0; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_NUMANODE, &nr, distances, 0, 0); assert(!err); assert(nr == 1); /* remove all distances */ err = hwloc_distances_remove(topology); assert(!err); nr = 0; err = hwloc_distances_get(topology, &nr, distances, 0, 0); assert(!err); assert(!nr); nr = 0; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_PU, &nr, distances, 0, 0); assert(!err); assert(!nr); nr = 0; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_NUMANODE, &nr, distances, 0, 0); assert(!err); assert(!nr); hwloc_topology_destroy(topology); return 0; }
int main(void) { hwloc_topology_t topology, reimport; hwloc_obj_t obj1, obj2, obj3; char *xmlbuf; int xmlbuflen; randomstring = malloc(RANDOMSTRINGLENGTH); /* keep it uninitialized, we want binary data */ /* check the real topology */ hwloc_topology_init(&topology); hwloc_topology_load(topology); check(topology); assert(hwloc_topology_get_userdata(topology) == NULL); hwloc_topology_destroy(topology); /* check a synthetic topology */ hwloc_topology_init(&topology); hwloc_topology_set_userdata(topology, (void *)(uintptr_t)0x987654); hwloc_topology_set_synthetic(topology, "6 5 4 3 2"); hwloc_topology_load(topology); check(topology); /* now place some userdata and see if importing/exporting works well */ obj1 = hwloc_get_root_obj(topology); assert(obj1); obj1->userdata = (void *)(uintptr_t) 0x1; obj2 = hwloc_get_obj_by_depth(topology, 3, 13); assert(obj2); obj2->userdata = (void *)(uintptr_t) 0x2; obj3 = hwloc_get_obj_by_depth(topology, 5, 2*3*4*5*6-1); assert(obj3); obj3->userdata = (void *)(uintptr_t) 0x3; /* export/import without callback, we get nothing */ hwloc_topology_export_xmlbuffer(topology, &xmlbuf, &xmlbuflen); hwloc_topology_init(&reimport); hwloc_topology_set_xmlbuffer(reimport, xmlbuf, xmlbuflen); hwloc_topology_load(reimport); check(reimport); /* there should be no userdata */ hwloc_topology_destroy(reimport); /* export/import with callback, we should get three userdata */ hwloc_topology_set_userdata_export_callback(topology, export_cb); hwloc_topology_export_xmlbuffer(topology, &xmlbuf, &xmlbuflen); hwloc_topology_init(&reimport); hwloc_topology_set_userdata_import_callback(reimport, import_cb); hwloc_topology_set_xmlbuffer(reimport, xmlbuf, xmlbuflen); hwloc_topology_load(reimport); obj1 = hwloc_get_root_obj(reimport); assert(obj1); assert(obj1->userdata == (void *)(uintptr_t) 0x4); obj2 = hwloc_get_obj_by_depth(reimport, 3, 13); assert(obj2); assert(obj2->userdata == (void *)(uintptr_t) 0x5); obj3 = hwloc_get_obj_by_depth(reimport, 5, 2*3*4*5*6-1); assert(obj3); assert(obj3->userdata == (void *)(uintptr_t) 0x6); hwloc_topology_destroy(reimport); assert(hwloc_topology_get_userdata(topology) == (void *)(uintptr_t)0x987654); hwloc_topology_destroy(topology); free(randomstring); return 0; }
int main(void) { static hwloc_topology_t oldtopology, topology; hwloc_bitmap_t cpuset = hwloc_bitmap_alloc(); struct hwloc_distances_s *distances; hwloc_obj_t nodes[3], cores[6]; uint64_t node_distances[9], core_distances[36]; unsigned i,j,nr; int err; hwloc_topology_init(&oldtopology); hwloc_topology_set_synthetic(oldtopology, "node:3 core:2 pu:4"); hwloc_topology_load(oldtopology); for(i=0; i<3; i++) { nodes[i] = hwloc_get_obj_by_type(oldtopology, HWLOC_OBJ_NUMANODE, i); for(j=0; j<3; j++) node_distances[i*3+j] = (i == j ? 10 : 20); } err = hwloc_distances_add(oldtopology, 3, nodes, node_distances, HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER, HWLOC_DISTANCES_FLAG_GROUP); assert(!err); for(i=0; i<6; i++) { cores[i] = hwloc_get_obj_by_type(oldtopology, HWLOC_OBJ_CORE, i); for(j=0; j<6; j++) core_distances[i*6+j] = (i == j ? 4 : 8); } err = hwloc_distances_add(oldtopology, 6, cores, core_distances, HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER, HWLOC_DISTANCES_FLAG_GROUP); assert(!err); printf("duplicating\n"); err = hwloc_topology_dup(&topology, oldtopology); assert(!err); printf("destroying the old topology\n"); hwloc_topology_destroy(oldtopology); /* remove the entire third node */ printf("removing one node\n"); hwloc_bitmap_fill(cpuset); hwloc_bitmap_clr_range(cpuset, 16, 23); err = hwloc_topology_restrict(topology, cpuset, HWLOC_RESTRICT_FLAG_REMOVE_CPULESS); assert(!err); printf("checking the result\n"); assert(hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_NUMANODE) == 2); nr = 1; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_NUMANODE, &nr, &distances, 0, 0); assert(!err); assert(nr == 1); assert(distances->nbobjs == 2); assert(distances->kind == (HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER)); hwloc_distances_release(topology, distances); nr = 1; err = hwloc_distances_get_by_type(topology, HWLOC_OBJ_CORE, &nr, &distances, 0, 0); assert(!err); assert(nr == 1); assert(distances->nbobjs == 4); assert(distances->kind == (HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER)); hwloc_distances_release(topology, distances); hwloc_topology_destroy(topology); hwloc_bitmap_free(cpuset); return 0; }
static int allocate(orte_job_t *jdata, opal_list_t *nodes) { int i, n, val, dig, num_nodes; orte_node_t *node; #if OPAL_HAVE_HWLOC orte_topology_t *t; hwloc_topology_t topo; hwloc_obj_t obj; unsigned j, k; struct hwloc_topology_support *support; char **files=NULL; char **topos = NULL; bool use_local_topology = false; #endif char **node_cnt=NULL; char **slot_cnt=NULL; char **max_slot_cnt=NULL; char *tmp; char prefix[6]; node_cnt = opal_argv_split(mca_ras_simulator_component.num_nodes, ','); if (NULL != mca_ras_simulator_component.slots) { slot_cnt = opal_argv_split(mca_ras_simulator_component.slots, ','); /* backfile the slot_cnt so every topology has a cnt */ tmp = slot_cnt[opal_argv_count(slot_cnt)-1]; for (n=opal_argv_count(slot_cnt); n < opal_argv_count(node_cnt); n++) { opal_argv_append_nosize(&slot_cnt, tmp); } } if (NULL != mca_ras_simulator_component.slots_max) { max_slot_cnt = opal_argv_split(mca_ras_simulator_component.slots_max, ','); /* backfill the max_slot_cnt as reqd */ tmp = max_slot_cnt[opal_argv_count(slot_cnt)-1]; for (n=opal_argv_count(max_slot_cnt); n < opal_argv_count(max_slot_cnt); n++) { opal_argv_append_nosize(&max_slot_cnt, tmp); } } #if OPAL_HAVE_HWLOC if (NULL != mca_ras_simulator_component.topofiles) { files = opal_argv_split(mca_ras_simulator_component.topofiles, ','); if (opal_argv_count(files) != opal_argv_count(node_cnt)) { orte_show_help("help-ras-base.txt", "ras-sim:mismatch", true); goto error_silent; } } else if (NULL != mca_ras_simulator_component.topologies) { topos = opal_argv_split(mca_ras_simulator_component.topologies, ','); if (opal_argv_count(topos) != opal_argv_count(node_cnt)) { orte_show_help("help-ras-base.txt", "ras-sim:mismatch", true); goto error_silent; } } else { /* use our topology */ use_local_topology = true; } #else /* If we don't have hwloc and hwloc files were specified, then error out (because we can't deliver that functionality) */ if (NULL == mca_ras_simulator_component.topofiles) { orte_show_help("help-ras-simulator.txt", "no hwloc support for topofiles", true); goto error_silent; } #endif /* setup the prefix to the node names */ snprintf(prefix, 6, "nodeA"); /* process the request */ for (n=0; NULL != node_cnt[n]; n++) { num_nodes = strtol(node_cnt[n], NULL, 10); /* get number of digits */ val = num_nodes; for (dig=0; 0 != val; dig++) { val /= 10; } /* set the prefix for this group of nodes */ prefix[4] += n; /* check for topology */ #if OPAL_HAVE_HWLOC if (use_local_topology) { /* use our topology */ topo = opal_hwloc_topology; } else if (NULL != files) { if (0 != hwloc_topology_init(&topo)) { orte_show_help("help-ras-simulator.txt", "hwloc API fail", true, __FILE__, __LINE__, "hwloc_topology_init"); goto error_silent; } if (0 != hwloc_topology_set_xml(topo, files[n])) { orte_show_help("help-ras-simulator.txt", "hwloc failed to load xml", true, files[n]); hwloc_topology_destroy(topo); goto error_silent; } /* since we are loading this from an external source, we have to * explicitly set a flag so hwloc sets things up correctly */ if (0 != hwloc_topology_set_flags(topo, HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM)) { orte_show_help("help-ras-simulator.txt", "hwloc API fail", true, __FILE__, __LINE__, "hwloc_topology_set_flags"); hwloc_topology_destroy(topo); goto error_silent; } if (0 != hwloc_topology_load(topo)) { orte_show_help("help-ras-simulator.txt", "hwloc API fail", true, __FILE__, __LINE__, "hwloc_topology_load"); hwloc_topology_destroy(topo); goto error_silent; } /* remove the hostname from the topology. Unfortunately, hwloc * decided to add the source hostname to the "topology", thus * rendering it unusable as a pure topological description. So * we remove that information here. */ obj = hwloc_get_root_obj(topo); for (k=0; k < obj->infos_count; k++) { if (NULL == obj->infos[k].name || NULL == obj->infos[k].value) { continue; } if (0 == strncmp(obj->infos[k].name, "HostName", strlen("HostName"))) { free(obj->infos[k].name); free(obj->infos[k].value); /* left justify the array */ for (j=k; j < obj->infos_count-1; j++) { obj->infos[j] = obj->infos[j+1]; } obj->infos[obj->infos_count-1].name = NULL; obj->infos[obj->infos_count-1].value = NULL; obj->infos_count--; break; } } /* unfortunately, hwloc does not include support info in its * xml output :-(( To aid in debugging, we set it here */ support = (struct hwloc_topology_support*)hwloc_topology_get_support(topo); support->cpubind->set_thisproc_cpubind = mca_ras_simulator_component.have_cpubind; support->membind->set_thisproc_membind = mca_ras_simulator_component.have_membind; /* add it to our array */ t = OBJ_NEW(orte_topology_t); t->topo = topo; t->sig = opal_hwloc_base_get_topo_signature(topo); opal_pointer_array_add(orte_node_topologies, t); } else { if (0 != hwloc_topology_init(&topo)) { orte_show_help("help-ras-simulator.txt", "hwloc API fail", true, __FILE__, __LINE__, "hwloc_topology_init"); goto error_silent; } if (0 != hwloc_topology_set_synthetic(topo, topos[n])) { orte_show_help("help-ras-simulator.txt", "hwloc API fail", true, __FILE__, __LINE__, "hwloc_topology_set_synthetic"); hwloc_topology_destroy(topo); goto error_silent; } if (0 != hwloc_topology_load(topo)) { orte_show_help("help-ras-simulator.txt", "hwloc API fail", true, __FILE__, __LINE__, "hwloc_topology_load"); hwloc_topology_destroy(topo); goto error_silent; } if (OPAL_SUCCESS != opal_hwloc_base_filter_cpus(topo)) { orte_show_help("help-ras-simulator.txt", "hwloc API fail", true, __FILE__, __LINE__, "opal_hwloc_base_filter_cpus"); hwloc_topology_destroy(topo); goto error_silent; } /* remove the hostname from the topology. Unfortunately, hwloc * decided to add the source hostname to the "topology", thus * rendering it unusable as a pure topological description. So * we remove that information here. */ obj = hwloc_get_root_obj(topo); for (k=0; k < obj->infos_count; k++) { if (NULL == obj->infos[k].name || NULL == obj->infos[k].value) { continue; } if (0 == strncmp(obj->infos[k].name, "HostName", strlen("HostName"))) { free(obj->infos[k].name); free(obj->infos[k].value); /* left justify the array */ for (j=k; j < obj->infos_count-1; j++) { obj->infos[j] = obj->infos[j+1]; } obj->infos[obj->infos_count-1].name = NULL; obj->infos[obj->infos_count-1].value = NULL; obj->infos_count--; break; } } /* unfortunately, hwloc does not include support info in its * xml output :-(( To aid in debugging, we set it here */ support = (struct hwloc_topology_support*)hwloc_topology_get_support(topo); support->cpubind->set_thisproc_cpubind = mca_ras_simulator_component.have_cpubind; support->membind->set_thisproc_membind = mca_ras_simulator_component.have_membind; /* add it to our array */ t = OBJ_NEW(orte_topology_t); t->topo = topo; t->sig = opal_hwloc_base_get_topo_signature(topo); opal_pointer_array_add(orte_node_topologies, t); } #endif for (i=0; i < num_nodes; i++) { node = OBJ_NEW(orte_node_t); asprintf(&node->name, "%s%0*d", prefix, dig, i); node->state = ORTE_NODE_STATE_UP; node->slots_inuse = 0; #if OPAL_HAVE_HWLOC if (NULL == max_slot_cnt || NULL == max_slot_cnt[n]) { node->slots_max = 0; } else { obj = hwloc_get_root_obj(topo); node->slots_max = opal_hwloc_base_get_npus(topo, obj); } if (NULL == slot_cnt || NULL == slot_cnt[n]) { node->slots = 0; } else { obj = hwloc_get_root_obj(topo); node->slots = opal_hwloc_base_get_npus(topo, obj); } node->topology = topo; #endif opal_output_verbose(1, orte_ras_base_framework.framework_output, "Created Node <%10s> [%3d : %3d]", node->name, node->slots, node->slots_max); opal_list_append(nodes, &node->super); } } /* record the number of allocated nodes */ orte_num_allocated_nodes = opal_list_get_size(nodes); if (NULL != max_slot_cnt) { opal_argv_free(max_slot_cnt); } if (NULL != slot_cnt) { opal_argv_free(slot_cnt); } if (NULL != node_cnt) { opal_argv_free(node_cnt); } return ORTE_SUCCESS; error_silent: if (NULL != max_slot_cnt) { opal_argv_free(max_slot_cnt); } if (NULL != slot_cnt) { opal_argv_free(slot_cnt); } if (NULL != node_cnt) { opal_argv_free(node_cnt); } return ORTE_ERR_SILENT; }
int main(void) { hwloc_topology_t local, global; hwloc_obj_t sw1, sw2, sw11, sw12, sw21, sw22, root; int err; printf("Loading the local topology...\n"); hwloc_topology_init(&local); hwloc_topology_set_synthetic(local, "n:2 s:2 ca:1 core:2 ca:2 pu:2"); hwloc_topology_load(local); printf("Try to create an empty custom topology...\n"); hwloc_topology_init(&global); hwloc_topology_set_custom(global); err = hwloc_topology_load(global); assert(err == -1); assert(errno == EINVAL); hwloc_topology_destroy(global); printf("Creating a custom topology...\n"); hwloc_topology_init(&global); hwloc_topology_set_custom(global); printf("Inserting the local topology into the global one...\n"); root = hwloc_get_root_obj(global); sw1 = hwloc_custom_insert_group_object_by_parent(global, root, 0); sw11 = hwloc_custom_insert_group_object_by_parent(global, sw1, 1); hwloc_custom_insert_topology(global, sw11, local, NULL); hwloc_custom_insert_topology(global, sw11, local, NULL); sw12 = hwloc_custom_insert_group_object_by_parent(global, sw1, 1); hwloc_custom_insert_topology(global, sw12, local, NULL); hwloc_custom_insert_topology(global, sw12, local, NULL); sw2 = hwloc_custom_insert_group_object_by_parent(global, root, 0); sw21 = hwloc_custom_insert_group_object_by_parent(global, sw2, 1); hwloc_custom_insert_topology(global, sw21, local, NULL); hwloc_custom_insert_topology(global, sw21, local, NULL); hwloc_custom_insert_topology(global, sw21, local, NULL); sw22 = hwloc_custom_insert_group_object_by_parent(global, sw2, 1); hwloc_custom_insert_topology(global, sw22, local, NULL); /* only one to check that it won't get merged */ hwloc_topology_destroy(local); printf("Building the global topology...\n"); hwloc_topology_load(global); hwloc_topology_check(global); assert(hwloc_topology_get_depth(global) == 10); assert(hwloc_get_depth_type(global, 0) == HWLOC_OBJ_SYSTEM); assert(hwloc_get_nbobjs_by_type(global, HWLOC_OBJ_SYSTEM) == 1); assert(hwloc_get_depth_type(global, 1) == HWLOC_OBJ_GROUP); assert(hwloc_get_nbobjs_by_depth(global, 1) == 2); assert(hwloc_get_depth_type(global, 2) == HWLOC_OBJ_GROUP); assert(hwloc_get_nbobjs_by_depth(global, 2) == 4); /* the last group of this level shouldn't be merged */ assert(hwloc_get_depth_type(global, 3) == HWLOC_OBJ_MACHINE); assert(hwloc_get_nbobjs_by_type(global, HWLOC_OBJ_MACHINE) == 8); assert(hwloc_get_depth_type(global, 4) == HWLOC_OBJ_NODE); assert(hwloc_get_nbobjs_by_type(global, HWLOC_OBJ_NODE) == 16); assert(hwloc_get_depth_type(global, 5) == HWLOC_OBJ_SOCKET); assert(hwloc_get_nbobjs_by_type(global, HWLOC_OBJ_SOCKET) == 32); assert(hwloc_get_depth_type(global, 6) == HWLOC_OBJ_CACHE); assert(hwloc_get_nbobjs_by_depth(global, 6) == 32); assert(hwloc_get_depth_type(global, 7) == HWLOC_OBJ_CORE); assert(hwloc_get_nbobjs_by_type(global, HWLOC_OBJ_CORE) == 64); assert(hwloc_get_depth_type(global, 8) == HWLOC_OBJ_CACHE); assert(hwloc_get_nbobjs_by_depth(global, 8) == 128); assert(hwloc_get_depth_type(global, 9) == HWLOC_OBJ_PU); assert(hwloc_get_nbobjs_by_type(global, HWLOC_OBJ_PU) == 256); hwloc_topology_destroy(global); return 0; }
int main(void) { hwloc_topology_t topology1, topology2; char *xmlbuf; int xmlbuflen; char xmlfile[] = "hwloc_backends.tmpxml.XXXXXX"; char env[64]; int xmlbufok = 0, xmlfileok = 0, xmlfilefd; const char *orig_backend_name; putenv("HWLOC_LIBXML_CLEANUP=1"); printf("trying to export topology to XML buffer and file for later...\n"); hwloc_topology_init(&topology1); hwloc_topology_load(topology1); orig_backend_name = get_backend_name(topology1); hwloc_obj_add_info(hwloc_get_root_obj(topology1), "Foo", "Bar"); assert(hwloc_topology_is_thissystem(topology1)); if (hwloc_topology_export_xmlbuffer(topology1, &xmlbuf, &xmlbuflen) < 0) printf("XML buffer export failed (%s), ignoring\n", strerror(errno)); else xmlbufok = 1; xmlfilefd = mkstemp(xmlfile); if (xmlfilefd < 0 || hwloc_topology_export_xml(topology1, xmlfile) < 0) printf("XML file export failed (%s), ignoring\n", strerror(errno)); else xmlfileok = 1; /* init+config+destroy without loading */ printf("init...\n"); hwloc_topology_init(&topology2); if (xmlfileok) { printf("switching to xml...\n"); assert(!hwloc_topology_set_xml(topology2, xmlfile)); } if (xmlbufok) { printf("switching to xmlbuffer...\n"); assert(!hwloc_topology_set_xmlbuffer(topology2, xmlbuf, xmlbuflen)); } printf("switching to synthetic...\n"); hwloc_topology_set_synthetic(topology2, "machine:2 node:3 l1:2 pu:4"); hwloc_topology_destroy(topology2); /* init+xml+load+destroy */ if (xmlfileok) { printf("switching to xml and loading...\n"); hwloc_topology_init(&topology2); assert(!hwloc_topology_set_xml(topology2, xmlfile)); hwloc_topology_load(topology2); assert_backend_name(topology2, orig_backend_name); assert_foo_bar(topology2, 1); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); } /* init+xmlbuf+load+destroy */ if (xmlbufok) { printf("switching to xmlbuffer and loading...\n"); hwloc_topology_init(&topology2); assert(!hwloc_topology_set_xmlbuffer(topology2, xmlbuf, xmlbuflen)); hwloc_topology_load(topology2); assert_backend_name(topology2, orig_backend_name); assert_foo_bar(topology2, 1); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); } /* init+synthetic+load+destroy */ printf("switching to synthetic and loading...\n"); hwloc_topology_init(&topology2); hwloc_topology_set_synthetic(topology2, "machine:2 node:3 l3i:2 pu:4"); hwloc_topology_load(topology2); assert_backend_name(topology2, "Synthetic"); assert_foo_bar(topology2, 0); assert(hwloc_get_nbobjs_by_type(topology2, HWLOC_OBJ_PU) == 2*3*2*4); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); /* xmlenv+init+load+destroy */ if (xmlfileok) { printf("switching to xml by env and loading...\n"); snprintf(env, sizeof(env), "HWLOC_XMLFILE=%s", xmlfile); putenv(env); hwloc_topology_init(&topology2); hwloc_topology_load(topology2); assert_backend_name(topology2, orig_backend_name); assert_foo_bar(topology2, 1); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); } /* syntheticenv+init+load+destroy, synthetic env overrides xml */ printf("switching to synthetic by env and loading...\n"); putenv("HWLOC_SYNTHETIC=node:3 pu:3"); hwloc_topology_init(&topology2); hwloc_topology_load(topology2); assert_backend_name(topology2, "Synthetic"); assert_foo_bar(topology2, 0); assert(hwloc_get_nbobjs_by_type(topology2, HWLOC_OBJ_PU) == 3*3); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); /* componentsenv+init+load+destroy for testing defaults, overrides synthetic/xml/fsroot envs */ printf("switching to default components by env and loading...\n"); putenv("HWLOC_COMPONENTS=,"); /* don't set to empty since it means 'unset' on windows */ hwloc_topology_init(&topology2); hwloc_topology_load(topology2); assert_backend_name(topology2, orig_backend_name); assert_foo_bar(topology2, 0); hwloc_topology_check(topology2); assert(hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); if (xmlbufok) hwloc_free_xmlbuffer(topology1, xmlbuf); if (xmlfilefd >= 0) { unlink(xmlfile); close(xmlfilefd); } hwloc_topology_destroy(topology1); return 0; }
int main(int argc, char *argv[]) { static hwloc_topology_t orig; hwloc_obj_t nodes[3]; uint64_t node_distances[9]; unsigned i,j; int err, ret, ret2; if (argc > 1) { int fd; unsigned long forced_addr; unsigned long fileoffset; size_t shmem_length; int synthetic_with_distances; if (argc < 6) { printf("needs 5 arguments\n"); return EXIT_FAILURE; } printf(" opening %s\n", argv[1]); fd = open(argv[1], O_RDONLY); if (fd < 0) { perror("open"); return EXIT_FAILURE; } fileoffset = strtoul(argv[2], NULL, 0); forced_addr = strtoul(argv[3], NULL, 0); shmem_length = strtoul(argv[4], NULL, 0); synthetic_with_distances = atoi(argv[5]); ret = adopt(fd, fileoffset, forced_addr, shmem_length, synthetic_with_distances); close(fd); exit(ret); } printf("########################\n"); printf("creating native topology\n"); err = hwloc_topology_init(&orig); assert(!err); err = hwloc_topology_set_all_types_filter(orig, HWLOC_TYPE_FILTER_KEEP_ALL); assert(!err); err = hwloc_topology_load(orig); assert(!err); ret = test(orig, argv[0]); printf("destroying original\n"); hwloc_topology_destroy(orig); printf("###############################################\n"); printf("creating synthetic topo with distances topology\n"); err = hwloc_topology_init(&orig); assert(!err); err = hwloc_topology_set_synthetic(orig, "node:3 core:2 pu:4"); assert(!err); err = hwloc_topology_load(orig); assert(!err); printf("adding distance matrix\n"); for(i=0; i<3; i++) { nodes[i] = hwloc_get_obj_by_type(orig, HWLOC_OBJ_NUMANODE, i); for(j=0; j<3; j++) node_distances[i*3+j] = (i == j ? 10 : 20); } err = hwloc_distances_add(orig, 3, nodes, node_distances, HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER, HWLOC_DISTANCES_ADD_FLAG_GROUP); assert(!err); ret2 = test(orig, argv[0]); printf("destroying original\n"); hwloc_topology_destroy(orig); /* we caught errors above. * return SKIP if both returned SKIP. otherwise SUCCESS */ if (ret == EXIT_SKIP && ret2 == EXIT_SKIP) ret = EXIT_SKIP; else ret = EXIT_SUCCESS; return ret; }
int main (void) { hwloc_topology_t topology; hwloc_bitmap_t set; hwloc_obj_t obj; int depth; int err; set = hwloc_bitmap_alloc(); err = hwloc_topology_init (&topology); if (err) return EXIT_FAILURE; hwloc_topology_set_synthetic (topology, "pack:8 cores:2 1"); err = hwloc_topology_load (topology); if (err) return EXIT_FAILURE; hwloc_bitmap_sscanf(set, "00008f18"); obj = hwloc_get_next_obj_covering_cpuset_by_type(topology, set, HWLOC_OBJ_PACKAGE, NULL); assert(obj == hwloc_get_obj_by_depth(topology, 1, 1)); obj = hwloc_get_next_obj_covering_cpuset_by_type(topology, set, HWLOC_OBJ_PACKAGE, obj); assert(obj == hwloc_get_obj_by_depth(topology, 1, 2)); obj = hwloc_get_next_obj_covering_cpuset_by_type(topology, set, HWLOC_OBJ_PACKAGE, obj); assert(obj == hwloc_get_obj_by_depth(topology, 1, 4)); obj = hwloc_get_next_obj_covering_cpuset_by_type(topology, set, HWLOC_OBJ_PACKAGE, obj); assert(obj == hwloc_get_obj_by_depth(topology, 1, 5)); obj = hwloc_get_next_obj_covering_cpuset_by_type(topology, set, HWLOC_OBJ_PACKAGE, obj); assert(obj == hwloc_get_obj_by_depth(topology, 1, 7)); obj = hwloc_get_next_obj_covering_cpuset_by_type(topology, set, HWLOC_OBJ_PACKAGE, obj); assert(!obj); hwloc_topology_destroy (topology); err = hwloc_topology_init (&topology); if (err) return EXIT_FAILURE; hwloc_topology_set_synthetic (topology, "nodes:2 pack:5 cores:3 4"); err = hwloc_topology_load (topology); if (err) return EXIT_FAILURE; hwloc_bitmap_sscanf(set, "0ff08000"); depth = hwloc_get_type_depth(topology, HWLOC_OBJ_PACKAGE); assert(depth == 2); obj = hwloc_get_next_obj_covering_cpuset_by_depth(topology, set, depth, NULL); assert(obj == hwloc_get_obj_by_depth(topology, depth, 1)); obj = hwloc_get_next_obj_covering_cpuset_by_depth(topology, set, depth, obj); assert(obj == hwloc_get_obj_by_depth(topology, depth, 2)); obj = hwloc_get_next_obj_covering_cpuset_by_depth(topology, set, depth, obj); assert(!obj); hwloc_topology_destroy (topology); hwloc_bitmap_free(set); return EXIT_SUCCESS; }
int main(void) { hwloc_topology_t topology; unsigned depth; char buffer[1024]; int err; /* check a synthetic topology */ hwloc_topology_init(&topology); err = hwloc_topology_set_synthetic(topology, "pack:2 numa:3 l2:4 core:5 pu:6"); assert(!err); hwloc_topology_load(topology); assert(hwloc_get_memory_parents_depth(topology) == 2); /* internal checks */ hwloc_topology_check(topology); /* local checks */ depth = hwloc_topology_get_depth(topology); assert(depth == 6); check_level(topology, 0, 1, 2); check_level(topology, 1, 2, 3); check_level(topology, 2, 6, 4); check_level(topology, 3, 24, 5); check_level(topology, 4, 120, 6); check_level(topology, 5, 720, 0); check_level(topology, HWLOC_TYPE_DEPTH_NUMANODE, 6, 0); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 83); err = strcmp("Package:2 Group:3 [NUMANode(memory=1073741824)] L2Cache:4(size=4194304) Core:5 PU:6", buffer); assert(!err); assert(hwloc_get_memory_parents_depth(topology) == 2); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_NO_EXTENDED_TYPES|HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_NO_ATTRS|HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_V1); assert(err == 47); err = strcmp("Socket:2 Group:3 NUMANode:1 Cache:4 Core:5 PU:6", buffer); assert(!err); hwloc_topology_destroy(topology); hwloc_topology_init(&topology); err = hwloc_topology_set_type_filter(topology, HWLOC_OBJ_L1ICACHE, HWLOC_TYPE_FILTER_KEEP_ALL); err = hwloc_topology_set_synthetic(topology, "pack:2(indexes=3,5) numa:2(memory=256GB indexes=pack) l3u:1(size=20mb) l2:2 l1i:1(size=16kB) l1dcache:2 core:1 pu:2(indexes=l2)"); assert(!err); hwloc_topology_load(topology); assert(hwloc_get_memory_parents_depth(topology) == 2); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 181); err = strcmp("Package:2 L3Cache:2(size=20971520) [NUMANode(memory=274877906944 indexes=2*2:1*2)] L2Cache:2(size=4194304) L1iCache:1(size=16384) L1dCache:2(size=32768) Core:1 PU:2(indexes=4*8:1*4)", buffer); assert(!err); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PACKAGE, 1)->os_index == 5); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, 1)->os_index == 2); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 12)->os_index == 3); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 13)->os_index == 11); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 14)->os_index == 19); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 15)->os_index == 27); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 16)->os_index == 4); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 17)->os_index == 12); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 18)->os_index == 20); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 19)->os_index == 28); hwloc_topology_destroy(topology); hwloc_topology_init(&topology); err = hwloc_topology_set_synthetic(topology, "pack:2 core:2 pu:2(indexes=0,4,2,6,1,5,3,7)"); assert(!err); hwloc_topology_load(topology); assert(hwloc_get_memory_parents_depth(topology) == 0); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 72); err = strcmp("[NUMANode(memory=1073741824)] Package:2 Core:2 PU:2(indexes=4*2:2*2:1*2)", buffer); assert(!err); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 0)->os_index == 0); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 1)->os_index == 4); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 2)->os_index == 2); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 3)->os_index == 6); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 4)->os_index == 1); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 5)->os_index == 5); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 6)->os_index == 3); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 7)->os_index == 7); hwloc_topology_destroy(topology); hwloc_topology_init(&topology); err = hwloc_topology_set_synthetic(topology, "pack:2 numa:2 core:1 pu:2(indexes=0,4,2,6,1,3,5,7)"); assert(!err); hwloc_topology_load(topology); assert(hwloc_get_memory_parents_depth(topology) == 2); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 76); err = strcmp("Package:2 Core:2 [NUMANode(memory=1073741824)] PU:2(indexes=0,4,2,6,1,3,5,7)", buffer); assert(!err); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 0)->os_index == 0); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 1)->os_index == 4); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 2)->os_index == 2); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 3)->os_index == 6); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 4)->os_index == 1); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 5)->os_index == 3); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 6)->os_index == 5); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 7)->os_index == 7); hwloc_topology_destroy(topology); hwloc_topology_init(&topology); err = hwloc_topology_set_synthetic(topology, "pack:2 [numa(memory=1GB)] [numa(memory=1MB)] core:2 [numa(indexes=8,7,5,6,4,3,1,2)] pu:4"); assert(!err); hwloc_topology_load(topology); assert(hwloc_get_memory_parents_depth(topology) == HWLOC_TYPE_DEPTH_MULTIPLE); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 114); err = strcmp("Package:2 [NUMANode(memory=1073741824)] [NUMANode(memory=1048576)] Core:2 [NUMANode(indexes=8,7,5,6,4,3,1,2)] PU:4", buffer); assert(!err); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_V1); assert(err == -1); assert(errno == EINVAL); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_IGNORE_MEMORY); assert(err == 21); err = strcmp("Package:2 Core:2 PU:4", buffer); assert(!err); hwloc_topology_destroy(topology); return 0; }
int main(void) { hwloc_topology_t topology1, topology2; char *xmlbuf; int xmlbuflen; char xmlfile[] = "hwloc_backends.tmpxml.XXXXXX"; int xmlbufok = 0, xmlfileok = 0; hwloc_obj_t sw; int err; printf("trying to export topology to XML buffer and file for later...\n"); hwloc_topology_init(&topology1); hwloc_topology_load(topology1); assert(hwloc_topology_is_thissystem(topology1)); if (hwloc_topology_export_xmlbuffer(topology1, &xmlbuf, &xmlbuflen) < 0) printf("XML buffer export failed (%s), ignoring\n", strerror(errno)); else xmlbufok = 1; mktemp(xmlfile); if (hwloc_topology_export_xml(topology1, xmlfile) < 0) printf("XML file export failed (%s), ignoring\n", strerror(errno)); else xmlfileok = 1; printf("init...\n"); hwloc_topology_init(&topology2); if (xmlfileok) { printf("switching to xml...\n"); assert(!hwloc_topology_set_xml(topology2, xmlfile)); } if (xmlbufok) { printf("switching to xmlbuffer...\n"); assert(!hwloc_topology_set_xmlbuffer(topology2, xmlbuf, xmlbuflen)); } printf("switching to custom...\n"); hwloc_topology_set_custom(topology2); printf("switching to synthetic...\n"); hwloc_topology_set_synthetic(topology2, "machine:2 node:3 cache:2 pu:4"); printf("switching sysfs fsroot to // ...\n"); hwloc_topology_set_fsroot(topology2, "//"); /* valid path that won't be recognized as '/' */ printf("switching sysfs fsroot to / ...\n"); hwloc_topology_set_fsroot(topology2, "/"); if (xmlfileok) { printf("switching to xml and loading...\n"); assert(!hwloc_topology_set_xml(topology2, xmlfile)); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); } if (xmlbufok) { printf("switching to xmlbuffer and loading...\n"); assert(!hwloc_topology_set_xmlbuffer(topology2, xmlbuf, xmlbuflen)); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); } printf("switching to custom and loading...\n"); hwloc_topology_set_custom(topology2); sw = hwloc_custom_insert_group_object_by_parent(topology2, hwloc_get_root_obj(topology2), 0); assert(sw); hwloc_custom_insert_topology(topology2, sw, topology1, NULL); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); /* don't try fsroot here because it fails on !linux, we would revert back to custom, which requires some insert to make the topology valid */ printf("switching to synthetic and loading...\n"); hwloc_topology_set_synthetic(topology2, "machine:2 node:3 cache:2 pu:4"); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); printf("switching sysfs fsroot to // and loading...\n"); hwloc_topology_set_fsroot(topology2, "//"); /* valid path that won't be recognized as '/' */ hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); /* earlier fsroot worked, or we're still synthetic */ printf("switching sysfs fsroot to / and loading...\n"); err = hwloc_topology_set_fsroot(topology2, "/"); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(hwloc_topology_is_thissystem(topology2) == !err); /* on Linux, '/' is recognized as thissystem. on !Linux, set_fsroot() failed and we went back to synthetic */ printf("switching to synthetic...\n"); hwloc_topology_set_synthetic(topology2, "machine:2 node:3 cache:2 pu:4"); hwloc_topology_destroy(topology2); if (xmlbufok) hwloc_free_xmlbuffer(topology1, xmlbuf); if (xmlfileok) unlink(xmlfile); hwloc_topology_destroy(topology1); return 0; }
int main(void) { hwloc_topology_t topology; unsigned depth; hwloc_obj_t objs[OBJ_MAX]; hwloc_obj_t obj; hwloc_bitmap_t set; int ret; hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, SYNTHETIC_TOPOLOGY_DESCRIPTION); hwloc_topology_load(topology); depth = hwloc_topology_get_depth(topology); /* just get the system object */ obj = hwloc_get_root_obj(topology); ret = hwloc_get_largest_objs_inside_cpuset(topology, obj->cpuset, objs, 1); assert(ret == 1); assert(objs[0] == obj); objs[0] = hwloc_get_first_largest_obj_inside_cpuset(topology, obj->cpuset); assert(objs[0] == obj); /* just get the very last object */ obj = hwloc_get_obj_by_depth(topology, depth-1, hwloc_get_nbobjs_by_depth(topology, depth-1)-1); ret = hwloc_get_largest_objs_inside_cpuset(topology, obj->cpuset, objs, 1); assert(ret == 1); assert(objs[0] == obj); /* try an empty one */ set = hwloc_bitmap_alloc(); ret = hwloc_get_largest_objs_inside_cpuset(topology, set, objs, 1); assert(ret == 0); objs[0] = hwloc_get_first_largest_obj_inside_cpuset(topology, set); assert(objs[0] == NULL); hwloc_bitmap_free(set); /* try an impossible one */ set = hwloc_bitmap_alloc(); hwloc_bitmap_sscanf(set, GIVEN_TOOLARGE_CPUSET_STRING); ret = hwloc_get_largest_objs_inside_cpuset(topology, set, objs, 1); assert(ret == -1); objs[0] = hwloc_get_first_largest_obj_inside_cpuset(topology, set); assert(objs[0] == NULL); hwloc_bitmap_free(set); /* try a harder one with 1 obj instead of 2 needed */ set = hwloc_bitmap_alloc(); hwloc_bitmap_sscanf(set, GIVEN_LARGESPLIT_CPUSET_STRING); ret = hwloc_get_largest_objs_inside_cpuset(topology, set, objs, 1); assert(ret == 1); assert(objs[0] == hwloc_get_obj_by_depth(topology, depth-1, 0)); objs[0] = hwloc_get_first_largest_obj_inside_cpuset(topology, set); assert(objs[0] == hwloc_get_obj_by_depth(topology, depth-1, 0)); /* try a harder one with lots of objs instead of 2 needed */ ret = hwloc_get_largest_objs_inside_cpuset(topology, set, objs, 2); assert(ret == 2); assert(objs[0] == hwloc_get_obj_by_depth(topology, depth-1, 0)); assert(objs[1] == hwloc_get_obj_by_depth(topology, depth-1, hwloc_get_nbobjs_by_depth(topology, depth-1)-1)); objs[0] = hwloc_get_first_largest_obj_inside_cpuset(topology, set); hwloc_bitmap_andnot(set, set, objs[0]->cpuset); objs[1] = hwloc_get_first_largest_obj_inside_cpuset(topology, set); hwloc_bitmap_andnot(set, set, objs[1]->cpuset); objs[2] = hwloc_get_first_largest_obj_inside_cpuset(topology, set); assert(objs[0] == hwloc_get_obj_by_depth(topology, depth-1, 0)); assert(objs[1] == hwloc_get_obj_by_depth(topology, depth-1, hwloc_get_nbobjs_by_depth(topology, depth-1)-1)); assert(objs[2] == NULL); assert(hwloc_bitmap_iszero(set)); hwloc_bitmap_free(set); /* try a very hard one */ set = hwloc_bitmap_alloc(); hwloc_bitmap_sscanf(set, GIVEN_HARD_CPUSET_STRING); ret = hwloc_get_largest_objs_inside_cpuset(topology, set, objs, OBJ_MAX); assert(objs[0] == hwloc_get_obj_by_depth(topology, 5, 29)); assert(objs[1] == hwloc_get_obj_by_depth(topology, 3, 5)); assert(objs[2] == hwloc_get_obj_by_depth(topology, 3, 6)); assert(objs[3] == hwloc_get_obj_by_depth(topology, 3, 7)); assert(objs[4] == hwloc_get_obj_by_depth(topology, 2, 2)); assert(objs[5] == hwloc_get_obj_by_depth(topology, 4, 36)); assert(objs[6] == hwloc_get_obj_by_depth(topology, 5, 74)); hwloc_bitmap_free(set); hwloc_topology_destroy(topology); return EXIT_SUCCESS; }
int main(void) { hwloc_topology_t topology; unsigned nbobjs; const struct hwloc_distances_s *distances; float d1, d2; unsigned depth, topodepth, i, j; int err; hwloc_obj_t obj1, obj2; hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, "node:4 core:4 pu:1"); putenv("HWLOC_NUMANode_DISTANCES=0,1,2,3:2*2"); putenv("HWLOC_PU_DISTANCES=0-15:4*2*2"); hwloc_topology_load(topology); topodepth = hwloc_topology_get_depth(topology); for(depth=0; depth<topodepth; depth++) { distances = hwloc_get_whole_distance_matrix_by_depth(topology, depth); if (!distances || !distances->latency) { printf("No distance at depth %u\n", depth); continue; } printf("distance matrix for depth %u:\n", depth); print_distances(distances); nbobjs = distances->nbobjs; obj1 = hwloc_get_obj_by_depth(topology, depth, 0); obj2 = hwloc_get_obj_by_depth(topology, depth, nbobjs-1); err = hwloc_get_latency(topology, obj1, obj2, &d1, &d2); assert(!err); assert(d1 == distances->latency[0*nbobjs+(nbobjs-1)]); assert(d2 == distances->latency[(nbobjs-1)*nbobjs+0]); } /* check that hwloc_get_latency works fine on numa distances */ distances = hwloc_get_whole_distance_matrix_by_type(topology, HWLOC_OBJ_NUMANODE); if (!distances || !distances->latency) { fprintf(stderr, "No NUMA distance matrix!\n"); return -1; } printf("distance matrix for NUMA nodes\n"); print_distances(distances); nbobjs = distances->nbobjs; for(i=0; i<nbobjs; i++) for(j=0; j<nbobjs; j++) { obj1 = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, i); obj2 = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, j); err = hwloc_get_latency(topology, obj1, obj2, &d1, &d2); assert(!err); assert(d1 == distances->latency[i*nbobjs+j]); assert(d2 == distances->latency[j*nbobjs+i]); } /* check that some random values are ok */ assert(distances->latency[0] == 1.0); /* diagonal */ assert(distances->latency[4] == 4.0); /* same group */ assert(distances->latency[6] == 8.0); /* different group */ assert(distances->latency[9] == 8.0); /* different group */ assert(distances->latency[10] == 1.0); /* diagonal */ assert(distances->latency[14] == 4.0); /* same group */ /* check that hwloc_get_latency works fine on PU distances */ distances = hwloc_get_whole_distance_matrix_by_type(topology, HWLOC_OBJ_PU); if (!distances || !distances->latency) { fprintf(stderr, "No PU distance matrix!\n"); return -1; } printf("distance matrix for PU nodes\n"); print_distances(distances); nbobjs = distances->nbobjs; for(i=0; i<16; i++) for(j=0; j<16; j++) { obj1 = hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, i); obj2 = hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, j); err = hwloc_get_latency(topology, obj1, obj2, &d1, &d2); assert(!err); assert(d1 == distances->latency[i*nbobjs+j]); assert(d2 == distances->latency[j*nbobjs+i]); } /* check that some random values are ok */ assert(distances->latency[0] == 1.0); /* diagonal */ assert(distances->latency[1] == 2.0); /* same group */ assert(distances->latency[3] == 4.0); /* same biggroup */ assert(distances->latency[15] == 8.0); /* different biggroup */ assert(distances->latency[250] == 8.0); /* different biggroup */ assert(distances->latency[253] == 4.0); /* same group */ assert(distances->latency[254] == 2.0); /* same biggroup */ assert(distances->latency[255] == 1.0); /* diagonal */ hwloc_topology_destroy(topology); return 0; }
int main(void) { hwloc_topology_t topology; unsigned depth; unsigned i,j, width; char buffer[1024]; int err; /* check a synthetic topology */ hwloc_topology_init(&topology); err = hwloc_topology_set_synthetic(topology, "2 3 4 5 6"); assert(!err); hwloc_topology_load(topology); /* internal checks */ hwloc_topology_check(topology); /* local checks */ depth = hwloc_topology_get_depth(topology); assert(depth == 6); width = 1; for(i=0; i<6; i++) { /* check arities */ assert(hwloc_get_nbobjs_by_depth(topology, i) == width); for(j=0; j<width; j++) { hwloc_obj_t obj = hwloc_get_obj_by_depth(topology, i, j); assert(obj); assert(obj->arity == (i<5 ? i+2 : 0)); } width *= i+2; } err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 75); err = strcmp("Package:2 NUMANode:3(memory=1073741824) L2Cache:4(size=4194304) Core:5 PU:6", buffer); assert(!err); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_NO_EXTENDED_TYPES|HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_NO_ATTRS); assert(err == 42); err = strcmp("Package:2 NUMANode:3 L2Cache:4 Core:5 PU:6", buffer); assert(!err); hwloc_topology_destroy(topology); hwloc_topology_init(&topology); err = hwloc_topology_set_type_filter(topology, HWLOC_OBJ_L1ICACHE, HWLOC_TYPE_FILTER_KEEP_ALL); err = hwloc_topology_set_synthetic(topology, "pack:2(indexes=3,5) numa:2(memory=256GB indexes=pack) l3u:1(size=20mb) l2:2 l1i:1(size=16kB) l1dcache:2 core:1 pu:2(indexes=l2)"); assert(!err); hwloc_topology_load(topology); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 181); err = strcmp("Package:2 NUMANode:2(memory=274877906944 indexes=2*2:1*2) L3Cache:1(size=20971520) L2Cache:2(size=4194304) L1iCache:1(size=16384) L1dCache:2(size=32768) Core:1 PU:2(indexes=4*8:1*4)", buffer); assert(!err); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PACKAGE, 1)->os_index == 5); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, 1)->os_index == 2); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 12)->os_index == 3); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 13)->os_index == 11); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 14)->os_index == 19); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 15)->os_index == 27); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 16)->os_index == 4); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 17)->os_index == 12); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 18)->os_index == 20); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 19)->os_index == 28); hwloc_topology_destroy(topology); hwloc_topology_init(&topology); err = hwloc_topology_set_synthetic(topology, "pack:2 core:2 pu:2(indexes=0,4,2,6,1,5,3,7)"); assert(!err); hwloc_topology_load(topology); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 72); err = strcmp("NUMANode:1(memory=1073741824) Package:2 Core:2 PU:2(indexes=4*2:2*2:1*2)", buffer); assert(!err); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 0)->os_index == 0); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 1)->os_index == 4); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 2)->os_index == 2); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 3)->os_index == 6); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 4)->os_index == 1); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 5)->os_index == 5); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 6)->os_index == 3); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 7)->os_index == 7); hwloc_topology_destroy(topology); hwloc_topology_init(&topology); err = hwloc_topology_set_synthetic(topology, "pack:2 numa:2 core:1 pu:2(indexes=0,4,2,6,1,3,5,7)"); assert(!err); hwloc_topology_load(topology); err = hwloc_topology_export_synthetic(topology, buffer, sizeof(buffer), 0); assert(err == 76); err = strcmp("Package:2 NUMANode:2(memory=1073741824) Core:1 PU:2(indexes=0,4,2,6,1,3,5,7)", buffer); assert(!err); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 0)->os_index == 0); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 1)->os_index == 4); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 2)->os_index == 2); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 3)->os_index == 6); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 4)->os_index == 1); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 5)->os_index == 3); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 6)->os_index == 5); assert(hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 7)->os_index == 7); hwloc_topology_destroy(topology); return 0; }
int main(void) { hwloc_topology_t topology1, topology2; char *xmlbuf; int xmlbuflen; char xmlfile[] = "hwloc_backends.tmpxml.XXXXXX"; int xmlbufok = 0, xmlfileok = 0, xmlfilefd; hwloc_obj_t sw; int err; printf("trying to export topology to XML buffer and file for later...\n"); hwloc_topology_init(&topology1); hwloc_topology_load(topology1); assert(hwloc_topology_is_thissystem(topology1)); if (hwloc_topology_export_xmlbuffer(topology1, &xmlbuf, &xmlbuflen) < 0) printf("XML buffer export failed (%s), ignoring\n", strerror(errno)); else xmlbufok = 1; xmlfilefd = mkstemp(xmlfile); if (xmlfilefd < 0 || hwloc_topology_export_xml(topology1, xmlfile) < 0) printf("XML file export failed (%s), ignoring\n", strerror(errno)); else xmlfileok = 1; printf("init...\n"); hwloc_topology_init(&topology2); if (xmlfileok) { printf("switching to xml...\n"); assert(!hwloc_topology_set_xml(topology2, xmlfile)); } if (xmlbufok) { printf("switching to xmlbuffer...\n"); assert(!hwloc_topology_set_xmlbuffer(topology2, xmlbuf, xmlbuflen)); } printf("switching to custom...\n"); hwloc_topology_set_custom(topology2); printf("switching to synthetic...\n"); hwloc_topology_set_synthetic(topology2, "machine:2 node:3 cache:2 pu:4"); printf("switching sysfs fsroot to // ...\n"); hwloc_topology_set_fsroot(topology2, "//"); /* valid path that won't be recognized as '/' */ printf("switching sysfs fsroot to / ...\n"); hwloc_topology_set_fsroot(topology2, "/"); hwloc_topology_destroy(topology2); if (xmlfileok) { printf("switching to xml and loading...\n"); hwloc_topology_init(&topology2); assert(!hwloc_topology_set_xml(topology2, xmlfile)); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); } if (xmlbufok) { printf("switching to xmlbuffer and loading...\n"); hwloc_topology_init(&topology2); assert(!hwloc_topology_set_xmlbuffer(topology2, xmlbuf, xmlbuflen)); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); } printf("switching to custom and loading...\n"); hwloc_topology_init(&topology2); hwloc_topology_set_custom(topology2); sw = hwloc_custom_insert_group_object_by_parent(topology2, hwloc_get_root_obj(topology2), 0); assert(sw); hwloc_custom_insert_topology(topology2, sw, topology1, NULL); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); printf("switching to synthetic and loading...\n"); hwloc_topology_init(&topology2); hwloc_topology_set_synthetic(topology2, "machine:2 node:3 cache:2 pu:4"); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2)); hwloc_topology_destroy(topology2); printf("switching sysfs fsroot to // and loading...\n"); hwloc_topology_init(&topology2); err = hwloc_topology_set_fsroot(topology2, "//"); /* '//' isn't recognized as the normal fsroot on Linux, and it fails and falls back to normal topology on !Linux */ hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(!hwloc_topology_is_thissystem(topology2) == !err); hwloc_topology_destroy(topology2); printf("switching sysfs fsroot to / and loading...\n"); hwloc_topology_init(&topology2); err = hwloc_topology_set_fsroot(topology2, "/"); hwloc_topology_load(topology2); hwloc_topology_check(topology2); assert(hwloc_topology_is_thissystem(topology2)); /* '/' is recognized as the normal fsroot on Linux, and it fails and falls back to normal topology on !Linux */ hwloc_topology_destroy(topology2); printf("switching to synthetic...\n"); hwloc_topology_init(&topology2); hwloc_topology_set_synthetic(topology2, "machine:2 node:3 cache:2 pu:4"); hwloc_topology_destroy(topology2); if (xmlbufok) hwloc_free_xmlbuffer(topology1, xmlbuf); if (xmlfilefd >= 0) { unlink(xmlfile); close(xmlfilefd); } hwloc_topology_destroy(topology1); return 0; }
int main(void) { hwloc_topology_t topology; hwloc_obj_t obj, cache; hwloc_bitmap_t set; hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, SYNTHETIC_TOPOLOGY_DESCRIPTION); hwloc_topology_load(topology); /* check the cache above a given cpu */ #define CPUINDEX 180 set = hwloc_bitmap_alloc(); obj = hwloc_get_obj_by_depth(topology, 5, CPUINDEX); assert(obj); hwloc_bitmap_or(set, set, obj->cpuset); cache = hwloc_get_cache_covering_cpuset(topology, set); assert(cache); assert(cache->type == HWLOC_OBJ_CACHE); assert(cache->logical_index == CPUINDEX/2/3); assert(hwloc_obj_is_in_subtree(topology, obj, cache)); hwloc_bitmap_free(set); /* check the cache above two nearby cpus */ #define CPUINDEX1 180 #define CPUINDEX2 183 set = hwloc_bitmap_alloc(); obj = hwloc_get_obj_by_depth(topology, 5, CPUINDEX1); assert(obj); hwloc_bitmap_or(set, set, obj->cpuset); obj = hwloc_get_obj_by_depth(topology, 5, CPUINDEX2); assert(obj); hwloc_bitmap_or(set, set, obj->cpuset); cache = hwloc_get_cache_covering_cpuset(topology, set); assert(cache); assert(cache->type == HWLOC_OBJ_CACHE); assert(cache->logical_index == CPUINDEX1/2/3); assert(cache->logical_index == CPUINDEX2/2/3); assert(hwloc_obj_is_in_subtree(topology, obj, cache)); hwloc_bitmap_free(set); /* check no cache above two distant cpus */ #undef CPUINDEX1 #define CPUINDEX1 300 set = hwloc_bitmap_alloc(); obj = hwloc_get_obj_by_depth(topology, 5, CPUINDEX1); assert(obj); hwloc_bitmap_or(set, set, obj->cpuset); obj = hwloc_get_obj_by_depth(topology, 5, CPUINDEX2); assert(obj); hwloc_bitmap_or(set, set, obj->cpuset); cache = hwloc_get_cache_covering_cpuset(topology, set); assert(!cache); hwloc_bitmap_free(set); /* check no cache above higher level */ set = hwloc_bitmap_alloc(); obj = hwloc_get_obj_by_depth(topology, 2, 0); assert(obj); hwloc_bitmap_or(set, set, obj->cpuset); cache = hwloc_get_cache_covering_cpuset(topology, set); assert(!cache); hwloc_bitmap_free(set); hwloc_topology_destroy(topology); return EXIT_SUCCESS; }
int main(void) { hwloc_bitmap_t cpuset = hwloc_bitmap_alloc(); unsigned node_indexes[3], core_indexes[6]; float node_distances[9], core_distances[36]; unsigned i,j; int err; for(i=0; i<3; i++) { node_indexes[i] = i; for(j=0; j<3; j++) node_distances[i*3+j] = (i == j ? 10.f : 20.f); } for(i=0; i<6; i++) { core_indexes[i] = i; for(j=0; j<6; j++) core_distances[i*6+j] = (i == j ? 4.f : 8.f); } hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, "node:3 core:2 pu:4"); hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_NODE, 3, node_indexes, node_distances); hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 6, core_indexes, core_distances); hwloc_topology_load(topology); /* entire topology */ printf("starting from full topology\n"); check(3, 6, 24); check_distances(3, 6); /* restrict to nothing, impossible */ printf("restricting to nothing, must fail\n"); hwloc_bitmap_zero(cpuset); err = hwloc_topology_restrict(topology, cpuset, HWLOC_RESTRICT_FLAG_ADAPT_DISTANCES); assert(err < 0 && errno == EINVAL); check(3, 6, 24); check_distances(3, 6); /* restrict to everything, will do nothing */ printf("restricting to nothing, does nothing\n"); hwloc_bitmap_fill(cpuset); err = hwloc_topology_restrict(topology, cpuset, HWLOC_RESTRICT_FLAG_ADAPT_DISTANCES); assert(!err); check(3, 6, 24); check_distances(3, 6); /* remove a single pu (second PU of second core of second node) */ printf("removing one PU\n"); hwloc_bitmap_fill(cpuset); hwloc_bitmap_clr(cpuset, 13); err = hwloc_topology_restrict(topology, cpuset, HWLOC_RESTRICT_FLAG_ADAPT_DISTANCES); assert(!err); check(3, 6, 23); check_distances(3, 6); /* remove the entire second core of first node */ printf("removing one core\n"); hwloc_bitmap_fill(cpuset); hwloc_bitmap_clr_range(cpuset, 4, 7); err = hwloc_topology_restrict(topology, cpuset, HWLOC_RESTRICT_FLAG_ADAPT_DISTANCES); assert(!err); check(3, 5, 19); check_distances(3, 5); /* remove the entire third node */ printf("removing one node\n"); hwloc_bitmap_fill(cpuset); hwloc_bitmap_clr_range(cpuset, 16, 23); err = hwloc_topology_restrict(topology, cpuset, HWLOC_RESTRICT_FLAG_ADAPT_DISTANCES); assert(!err); check(2, 3, 11); check_distances(2, 3); /* restrict to the third node, impossible */ printf("restricting to only some already removed node, must fail\n"); hwloc_bitmap_zero(cpuset); hwloc_bitmap_set_range(cpuset, 16, 23); err = hwloc_topology_restrict(topology, cpuset, HWLOC_RESTRICT_FLAG_ADAPT_DISTANCES); assert(err == -1 && errno == EINVAL); check(2, 3, 11); check_distances(2, 3); /* only keep three PUs (first and last of first core, and last of last core of second node) */ printf("restricting to 3 PUs\n"); hwloc_bitmap_zero(cpuset); hwloc_bitmap_set(cpuset, 0); hwloc_bitmap_set(cpuset, 3); hwloc_bitmap_set(cpuset, 15); err = hwloc_topology_restrict(topology, cpuset, 0); assert(!err); check(2, 2, 3); check_distances(0, 0); /* only keep one PU (last of last core of second node) */ printf("restricting to a single PU\n"); hwloc_bitmap_zero(cpuset); hwloc_bitmap_set(cpuset, 15); err = hwloc_topology_restrict(topology, cpuset, 0); assert(!err); check(1, 1, 1); check_distances(0, 0); hwloc_topology_destroy(topology); /* check that restricting exactly on a Misc object keeps things coherent */ printf("restricting to a Misc covering only the of the PU level\n"); hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, "pu:4"); hwloc_topology_load(topology); hwloc_bitmap_zero(cpuset); hwloc_bitmap_set_range(cpuset, 1, 2); hwloc_topology_insert_misc_object_by_cpuset(topology, cpuset, "toto"); hwloc_topology_restrict(topology, cpuset, 0); hwloc_topology_check(topology); hwloc_topology_destroy(topology); hwloc_bitmap_free(cpuset); return 0; }
int main(void) { hwloc_topology_t topology; hwloc_obj_t obj; unsigned indexes[5]; float distances[5*5]; unsigned depth; unsigned width; /* group 3 numa nodes as 1 group of 2 and 1 on the side */ hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, "node:3 pu:1"); indexes[0] = 0; indexes[1] = 1; indexes[2] = 2; distances[0] = 1; distances[1] = 4; distances[2] = 4; distances[3] = 4; distances[4] = 1; distances[5] = 2; distances[6] = 4; distances[7] = 2; distances[8] = 1; hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_PU, 3, indexes, distances); hwloc_topology_load(topology); /* 2 groups at depth 1 */ depth = hwloc_get_type_depth(topology, HWLOC_OBJ_GROUP); assert(depth == 1); width = hwloc_get_nbobjs_by_depth(topology, depth); assert(width == 1); /* 3 node at depth 2 */ depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NUMANODE); assert(depth == 2); width = hwloc_get_nbobjs_by_depth(topology, depth); assert(width == 3); /* find the root obj */ obj = hwloc_get_root_obj(topology); assert(obj->arity == 2); /* check its children */ assert(obj->children[0]->type == HWLOC_OBJ_NUMANODE); assert(obj->children[0]->depth == 2); assert(obj->children[0]->arity == 1); assert(obj->children[1]->type == HWLOC_OBJ_GROUP); assert(obj->children[1]->depth == 1); assert(obj->children[1]->arity == 2); hwloc_topology_destroy(topology); /* group 5 packages as 2 group of 2 and 1 on the side, all of them below a common node object */ hwloc_topology_init(&topology); hwloc_topology_set_synthetic(topology, "node:1 pack:5 pu:1"); indexes[0] = 0; indexes[1] = 1; indexes[2] = 2; indexes[3] = 3; indexes[4] = 4; distances[ 0] = 1; distances[ 1] = 2; distances[ 2] = 4; distances[ 3] = 4; distances[ 4] = 4; distances[ 5] = 2; distances[ 6] = 1; distances[ 7] = 4; distances[ 8] = 4; distances[ 9] = 4; distances[10] = 4; distances[11] = 4; distances[12] = 1; distances[13] = 4; distances[14] = 4; distances[15] = 4; distances[16] = 4; distances[17] = 4; distances[18] = 1; distances[19] = 2; distances[20] = 4; distances[21] = 4; distances[22] = 4; distances[23] = 2; distances[24] = 1; hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_PACKAGE, 5, indexes, distances); hwloc_topology_load(topology); /* 1 node at depth 1 */ depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NUMANODE); assert(depth == 1); width = hwloc_get_nbobjs_by_depth(topology, depth); assert(width == 1); /* 2 groups at depth 2 */ depth = hwloc_get_type_depth(topology, HWLOC_OBJ_GROUP); assert(depth == 2); width = hwloc_get_nbobjs_by_depth(topology, depth); assert(width == 2); /* 5 packages at depth 3 */ depth = hwloc_get_type_depth(topology, HWLOC_OBJ_PACKAGE); assert(depth == 3); width = hwloc_get_nbobjs_by_depth(topology, depth); assert(width == 5); /* find the node obj */ obj = hwloc_get_root_obj(topology); assert(obj->arity == 1); obj = obj->children[0]; assert(obj->type == HWLOC_OBJ_NUMANODE); assert(obj->arity == 3); /* check its children */ assert(obj->children[0]->type == HWLOC_OBJ_GROUP); assert(obj->children[0]->depth == 2); assert(obj->children[0]->arity == 2); assert(obj->children[1]->type == HWLOC_OBJ_PACKAGE); assert(obj->children[1]->depth == 3); assert(obj->children[1]->arity == 1); assert(obj->children[2]->type == HWLOC_OBJ_GROUP); assert(obj->children[2]->depth == 2); assert(obj->children[2]->arity == 2); hwloc_topology_destroy(topology); return 0; }
int main (void) { hwloc_topology_t topology; hwloc_obj_t obj, root; int err; err = hwloc_topology_init (&topology); if (err) return EXIT_FAILURE; hwloc_topology_set_synthetic (topology, "nodes:2 sockets:3 caches:4 cores:5 6"); err = hwloc_topology_load (topology); if (err) return EXIT_FAILURE; /* there is no second system object */ root = hwloc_get_root_obj (topology); obj = hwloc_get_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_SYSTEM, 1); assert(!obj); /* first system object is the top-level object of the topology */ obj = hwloc_get_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_MACHINE, 0); assert(obj == hwloc_get_root_obj(topology)); /* first next-object object is the top-level object of the topology */ obj = hwloc_get_next_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_MACHINE, NULL); assert(obj == hwloc_get_root_obj(topology)); /* there is no next object after the system object */ obj = hwloc_get_next_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_SYSTEM, obj); assert(!obj); /* check last PU */ obj = hwloc_get_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_PU, 2*3*4*5*6-1); assert(obj == hwloc_get_obj_by_depth(topology, 5, 2*3*4*5*6-1)); /* there is no next PU after the last one */ obj = hwloc_get_next_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_PU, obj); assert(!obj); /* check there are 20 cores inside first socket */ root = hwloc_get_obj_by_depth(topology, 2, 0); assert(hwloc_get_nbobjs_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_CORE) == 20); /* check there are 12 caches inside last node */ root = hwloc_get_obj_by_depth(topology, 1, 1); assert(hwloc_get_nbobjs_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_CACHE) == 12); /* check first PU of second socket */ root = hwloc_get_obj_by_depth(topology, 2, 1); obj = hwloc_get_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_PU, 0); assert(obj == hwloc_get_obj_by_depth(topology, 5, 4*5*6)); /* check third core of third socket */ root = hwloc_get_obj_by_depth(topology, 2, 2); obj = hwloc_get_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_CORE, 2); assert(obj == hwloc_get_obj_by_depth(topology, 4, 2*4*5+2)); /* check first socket of second node */ root = hwloc_get_obj_by_depth(topology, 1, 1); obj = hwloc_get_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_SOCKET, 0); assert(obj == hwloc_get_obj_by_depth(topology, 2, 3)); /* there is no node inside sockets */ root = hwloc_get_obj_by_depth(topology, 2, 0); obj = hwloc_get_obj_inside_cpuset_by_type(topology, root->cpuset, HWLOC_OBJ_NODE, 0); assert(!obj); hwloc_topology_destroy (topology); return EXIT_SUCCESS; }