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;
}
