int main(void)
{
hwloc_bitmap_t orig, expected;
orig = hwloc_bitmap_alloc();
expected = hwloc_bitmap_alloc();
/* empty set gives empty set */
hwloc_bitmap_singlify(orig);
assert(hwloc_bitmap_iszero(orig));
/* full set gives first bit only */
hwloc_bitmap_fill(orig);
hwloc_bitmap_singlify(orig);
hwloc_bitmap_zero(expected);
hwloc_bitmap_set(expected, 0);
assert(hwloc_bitmap_isequal(orig, expected));
assert(!hwloc_bitmap_compare(orig, expected));
/* actual non-trivial set */
hwloc_bitmap_zero(orig);
hwloc_bitmap_set(orig, 45);
hwloc_bitmap_set(orig, 46);
hwloc_bitmap_set(orig, 517);
hwloc_bitmap_singlify(orig);
hwloc_bitmap_zero(expected);
hwloc_bitmap_set(expected, 45);
assert(hwloc_bitmap_isequal(orig, expected));
assert(!hwloc_bitmap_compare(orig, expected));
hwloc_bitmap_free(orig);
hwloc_bitmap_free(expected);
return 0;
}
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;
}
static void
hwloc_netbsd_bsd2hwloc(hwloc_bitmap_t hwloc_cpuset, const cpuset_t *cpuset)
{
unsigned cpu, cpulimit;
int found = 0;
hwloc_bitmap_zero(hwloc_cpuset);
cpulimit = cpuset_size(cpuset) * CHAR_BIT;
for (cpu = 0; cpu < cpulimit; cpu++)
if (cpuset_isset(cpu, cpuset)) {
hwloc_bitmap_set(hwloc_cpuset, cpu);
found++;
}
/* when never bound, it returns an empty set, fill it instead */
if (!found)
hwloc_bitmap_fill(hwloc_cpuset);
}
static int
hwloc_aix_get_pid_getthrds_cpubind(hwloc_topology_t topology __hwloc_attribute_unused, pid_t pid, hwloc_bitmap_t hwloc_set, int flags __hwloc_attribute_unused)
{
#if HWLOC_BITS_PER_LONG == 64
struct thrdentry64 thread_info;
tid64_t next_thread;
#else
struct thrdsinfo thread_info;
tid_t next_thread;
#endif
next_thread = 0;
/* TODO: get multiple at once */
#if HWLOC_BITS_PER_LONG == 64
while (getthrds64 (pid, &thread_info, sizeof (thread_info),
&next_thread, 1) == 1) {
#else
while (getthrds (pid, &thread_info, sizeof (thread_info),
&next_thread, 1) == 1) {
#endif
if (PROCESSOR_CLASS_ANY != thread_info.ti_cpuid)
hwloc_bitmap_set(hwloc_set, thread_info.ti_cpuid);
else
hwloc_bitmap_fill(hwloc_set);
}
/* TODO: what if the thread list changes and we get nothing? */
return 0;
}
static int
hwloc_aix_get_tid_getthrds_cpubind(hwloc_topology_t topology __hwloc_attribute_unused, tid_t tid, hwloc_bitmap_t hwloc_set, int flags __hwloc_attribute_unused)
{
#if HWLOC_BITS_PER_LONG == 64
struct thrdentry64 thread_info;
tid64_t next_thread;
#else
struct thrdsinfo thread_info;
tid_t next_thread;
#endif
pid_t pid = getpid();
next_thread = 0;
/* TODO: get multiple at once */
#if HWLOC_BITS_PER_LONG == 64
while (getthrds64 (pid, &thread_info, sizeof (thread_info),
&next_thread, 1) == 1) {
#else
while (getthrds (pid, &thread_info, sizeof (thread_info),
&next_thread, 1) == 1) {
#endif
if (thread_info.ti_tid == tid) {
if (PROCESSOR_CLASS_ANY != thread_info.ti_cpuid)
hwloc_bitmap_set(hwloc_set, thread_info.ti_cpuid);
else
hwloc_bitmap_fill(hwloc_set);
break;
}
}
/* TODO: what if the thread goes away in the meantime? */
return 0;
}
static int
hwloc_aix_set_thisproc_cpubind(hwloc_topology_t topology, hwloc_const_bitmap_t hwloc_set, int flags)
{
rsid_t who;
who.at_pid = getpid();
return hwloc_aix_set_sth_cpubind(topology, R_PROCESS, who, who.at_pid, hwloc_set, flags);
}
static int
hwloc_aix_get_thisproc_cpubind(hwloc_topology_t topology, hwloc_bitmap_t hwloc_set, int flags)
{
int ret, bound;
rsid_t who;
who.at_pid = getpid();
ret = hwloc_aix_get_sth_rset_cpubind(topology, R_PROCESS, who, hwloc_set, flags, &bound);
if (!ret && !bound) {
hwloc_bitmap_zero(hwloc_set);
ret = hwloc_aix_get_pid_getthrds_cpubind(topology, who.at_pid, hwloc_set, flags);
}
return ret;
}
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;
}
int main(void)
{
hwloc_bitmap_t set;
int i, cpu, expected_cpu = 0;
/* empty set */
set = hwloc_bitmap_alloc();
assert(hwloc_bitmap_first(set) == -1);
assert(hwloc_bitmap_last(set) == -1);
assert(hwloc_bitmap_next(set, 0) == -1);
assert(hwloc_bitmap_next(set, -1) == -1);
assert(hwloc_bitmap_weight(set) == 0);
/* full set */
hwloc_bitmap_fill(set);
assert(hwloc_bitmap_first(set) == 0);
assert(hwloc_bitmap_last(set) == -1);
assert(hwloc_bitmap_next(set, -1) == 0);
assert(hwloc_bitmap_next(set, 0) == 1);
assert(hwloc_bitmap_next(set, 1) == 2);
assert(hwloc_bitmap_next(set, 2) == 3);
assert(hwloc_bitmap_next(set, 30) == 31);
assert(hwloc_bitmap_next(set, 31) == 32);
assert(hwloc_bitmap_next(set, 32) == 33);
assert(hwloc_bitmap_next(set, 62) == 63);
assert(hwloc_bitmap_next(set, 63) == 64);
assert(hwloc_bitmap_next(set, 64) == 65);
assert(hwloc_bitmap_next(set, 12345) == 12346);
assert(hwloc_bitmap_weight(set) == -1);
/* custom sets */
hwloc_bitmap_zero(set);
hwloc_bitmap_set_range(set, 36, 59);
assert(hwloc_bitmap_first(set) == 36);
assert(hwloc_bitmap_last(set) == 59);
assert(hwloc_bitmap_next(set, -1) == 36);
assert(hwloc_bitmap_next(set, 0) == 36);
assert(hwloc_bitmap_next(set, 36) == 37);
assert(hwloc_bitmap_next(set, 59) == -1);
assert(hwloc_bitmap_weight(set) == 24);
hwloc_bitmap_set_range(set, 136, 259);
assert(hwloc_bitmap_first(set) == 36);
assert(hwloc_bitmap_last(set) == 259);
assert(hwloc_bitmap_next(set, 59) == 136);
assert(hwloc_bitmap_next(set, 259) == -1);
assert(hwloc_bitmap_weight(set) == 148);
hwloc_bitmap_clr(set, 199);
assert(hwloc_bitmap_first(set) == 36);
assert(hwloc_bitmap_last(set) == 259);
assert(hwloc_bitmap_next(set, 198) == 200);
assert(hwloc_bitmap_next(set, 199) == 200);
assert(hwloc_bitmap_weight(set) == 147);
i = 0;
hwloc_bitmap_foreach_begin(cpu, set) {
if (0 <= i && i < 24)
expected_cpu = i + 36;
else if (24 <= i && i < 87)
expected_cpu = i + 112;
else if (87 <= i && i < 147)
expected_cpu = i + 113;
assert(expected_cpu == cpu);
i++;
} hwloc_bitmap_foreach_end();
hwloc_bitmap_free(set);
return 0;
}
static
void getNumCPUs(void) {
//
// accessible cores
//
//
// Hwloc can't tell us the number of accessible cores directly, so
// get that by counting the parent cores of the accessible PUs.
//
//
// We could seemingly use hwloc_topology_get_allowed_cpuset() to get
// the set of accessible PUs here. But that seems not to reflect the
// schedaffinity settings, so use hwloc_get_proc_cpubind() instead.
//
hwloc_cpuset_t logAccSet;
CHK_ERR_ERRNO((logAccSet = hwloc_bitmap_alloc()) != NULL);
if (hwloc_get_proc_cpubind(topology, getpid(), logAccSet, 0) != 0) {
#ifdef __APPLE__
const int errRecoverable = (errno == ENOSYS); // no cpubind on macOS
#else
const int errRecoverable = 0;
#endif
if (errRecoverable) {
hwloc_bitmap_fill(logAccSet);
} else {
REPORT_ERR_ERRNO(hwloc_get_proc_cpubind(topology, getpid(), logAccSet, 0)
== 0);
}
}
hwloc_bitmap_and(logAccSet, logAccSet,
hwloc_topology_get_online_cpuset(topology));
hwloc_cpuset_t physAccSet;
CHK_ERR_ERRNO((physAccSet = hwloc_bitmap_alloc()) != NULL);
#define NEXT_PU(pu) \
hwloc_get_next_obj_inside_cpuset_by_type(topology, logAccSet, \
HWLOC_OBJ_PU, pu)
for (hwloc_obj_t pu = NEXT_PU(NULL); pu != NULL; pu = NEXT_PU(pu)) {
hwloc_obj_t core;
CHK_ERR_ERRNO((core = hwloc_get_ancestor_obj_by_type(topology,
HWLOC_OBJ_CORE,
pu))
!= NULL);
hwloc_bitmap_set(physAccSet, core->logical_index);
}
#undef NEXT_PU
numCPUsPhysAcc = hwloc_bitmap_weight(physAccSet);
hwloc_bitmap_free(physAccSet);
CHK_ERR(numCPUsPhysAcc > 0);
//
// all cores
//
numCPUsPhysAll = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_CORE);
CHK_ERR(numCPUsPhysAll > 0);
//
// accessible PUs
//
numCPUsLogAcc = hwloc_bitmap_weight(logAccSet);
CHK_ERR(numCPUsLogAcc > 0);
hwloc_bitmap_free(logAccSet);
//
// all PUs
//
numCPUsLogAll = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_PU);
CHK_ERR(numCPUsLogAll > 0);
}
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;
}
