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 (int argc, char *argv[])
{
int err;
hwloc_topology_t topology;
const char *filename = NULL;
unsigned long flags = HWLOC_TOPOLOGY_FLAG_IO_DEVICES | HWLOC_TOPOLOGY_FLAG_IO_BRIDGES | HWLOC_TOPOLOGY_FLAG_ICACHES;
unsigned long restrict_flags = 0;
int merge = 0;
int ignorecache = 0;
char * callname;
char * input = NULL;
enum hwloc_utils_input_format input_format = HWLOC_UTILS_INPUT_DEFAULT;
enum output_format output_format = LSTOPO_OUTPUT_DEFAULT;
char *restrictstring = NULL;
struct lstopo_output loutput;
int opt;
unsigned i;
loutput.overwrite = 0;
loutput.logical = -1;
loutput.legend = 1;
loutput.verbose_mode = LSTOPO_VERBOSE_MODE_DEFAULT;
for(i=0; i<HWLOC_OBJ_TYPE_MAX; i++)
force_orient[i] = LSTOPO_ORIENT_NONE;
force_orient[HWLOC_OBJ_PU] = LSTOPO_ORIENT_HORIZ;
force_orient[HWLOC_OBJ_CACHE] = LSTOPO_ORIENT_HORIZ;
force_orient[HWLOC_OBJ_NUMANODE] = LSTOPO_ORIENT_HORIZ;
/* enable verbose backends */
putenv("HWLOC_XML_VERBOSE=1");
putenv("HWLOC_SYNTHETIC_VERBOSE=1");
#ifdef HAVE_SETLOCALE
setlocale(LC_ALL, "");
#endif
callname = strrchr(argv[0], '/');
if (!callname)
callname = argv[0];
else
callname++;
/* skip argv[0], handle options */
argc--;
argv++;
err = hwloc_topology_init (&topology);
if (err)
return EXIT_FAILURE;
while (argc >= 1)
{
opt = 0;
if (!strcmp (argv[0], "-v") || !strcmp (argv[0], "--verbose")) {
loutput.verbose_mode++;
} else if (!strcmp (argv[0], "-s") || !strcmp (argv[0], "--silent")) {
loutput.verbose_mode--;
} else if (!strcmp (argv[0], "-h") || !strcmp (argv[0], "--help")) {
usage(callname, stdout);
exit(EXIT_SUCCESS);
} else if (!strcmp (argv[0], "-f") || !strcmp (argv[0], "--force"))
loutput.overwrite = 1;
else if (!strcmp (argv[0], "-l") || !strcmp (argv[0], "--logical"))
loutput.logical = 1;
else if (!strcmp (argv[0], "-p") || !strcmp (argv[0], "--physical"))
loutput.logical = 0;
else if (!strcmp (argv[0], "-c") || !strcmp (argv[0], "--cpuset"))
lstopo_show_cpuset = 1;
else if (!strcmp (argv[0], "-C") || !strcmp (argv[0], "--cpuset-only"))
lstopo_show_cpuset = 2;
else if (!strcmp (argv[0], "--taskset")) {
lstopo_show_taskset = 1;
if (!lstopo_show_cpuset)
lstopo_show_cpuset = 1;
} else if (!strcmp (argv[0], "--only")) {
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
if (hwloc_obj_type_sscanf(argv[1], &lstopo_show_only, NULL, NULL, 0) < 0)
fprintf(stderr, "Unsupported type `%s' passed to --only, ignoring.\n", argv[1]);
opt = 1;
}
else if (!strcmp (argv[0], "--ignore")) {
hwloc_obj_type_t type;
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
if (hwloc_obj_type_sscanf(argv[1], &type, NULL, NULL, 0) < 0)
fprintf(stderr, "Unsupported type `%s' passed to --ignore, ignoring.\n", argv[1]);
else if (type == HWLOC_OBJ_PU)
lstopo_ignore_pus = 1;
else
hwloc_topology_ignore_type(topology, type);
opt = 1;
}
else if (!strcmp (argv[0], "--no-caches"))
ignorecache = 2;
else if (!strcmp (argv[0], "--no-useless-caches"))
ignorecache = 1;
else if (!strcmp (argv[0], "--no-icaches"))
flags &= ~HWLOC_TOPOLOGY_FLAG_ICACHES;
else if (!strcmp (argv[0], "--whole-system"))
flags |= HWLOC_TOPOLOGY_FLAG_WHOLE_SYSTEM;
else if (!strcmp (argv[0], "--no-io"))
flags &= ~(HWLOC_TOPOLOGY_FLAG_IO_DEVICES | HWLOC_TOPOLOGY_FLAG_IO_BRIDGES);
else if (!strcmp (argv[0], "--no-bridges"))
flags &= ~(HWLOC_TOPOLOGY_FLAG_IO_BRIDGES);
else if (!strcmp (argv[0], "--whole-io"))
flags |= HWLOC_TOPOLOGY_FLAG_WHOLE_IO;
else if (!strcmp (argv[0], "--merge"))
merge = 1;
else if (!strcmp (argv[0], "--no-collapse"))
lstopo_collapse = 0;
else if (!strcmp (argv[0], "--thissystem"))
flags |= HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM;
else if (!strcmp (argv[0], "--restrict")) {
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
restrictstring = strdup(argv[1]);
opt = 1;
}
else if (!strcmp (argv[0], "--restrict-flags")) {
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
restrict_flags = (unsigned long) strtoull(argv[1], NULL, 0);
opt = 1;
}
else if (!strcmp (argv[0], "--export-synthetic-flags")) {
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
lstopo_export_synthetic_flags = (unsigned long) strtoull(argv[1], NULL, 0);
opt = 1;
}
else if (!strcmp (argv[0], "--horiz"))
for(i=0; i<HWLOC_OBJ_TYPE_MAX; i++)
force_orient[i] = LSTOPO_ORIENT_HORIZ;
else if (!strcmp (argv[0], "--vert"))
for(i=0; i<HWLOC_OBJ_TYPE_MAX; i++)
force_orient[i] = LSTOPO_ORIENT_VERT;
else if (!strcmp (argv[0], "--rect"))
for(i=0; i<HWLOC_OBJ_TYPE_MAX; i++)
force_orient[i] = LSTOPO_ORIENT_RECT;
else if (!strncmp (argv[0], "--horiz=", 8)
|| !strncmp (argv[0], "--vert=", 7)
|| !strncmp (argv[0], "--rect=", 7)) {
enum lstopo_orient_e orient = (argv[0][2] == 'h') ? LSTOPO_ORIENT_HORIZ : (argv[0][2] == 'v') ? LSTOPO_ORIENT_VERT : LSTOPO_ORIENT_RECT;
char *tmp = argv[0] + ((argv[0][2] == 'h') ? 8 : 7);
while (tmp) {
char *end = strchr(tmp, ',');
hwloc_obj_type_t type;
if (end)
*end = '\0';
if (hwloc_obj_type_sscanf(tmp, &type, NULL, NULL, 0) < 0)
fprintf(stderr, "Unsupported type `%s' passed to %s, ignoring.\n", tmp, argv[0]);
else
force_orient[type] = orient;
if (!end)
break;
tmp = end+1;
}
}
else if (!strcmp (argv[0], "--fontsize")) {
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
fontsize = atoi(argv[1]);
opt = 1;
}
else if (!strcmp (argv[0], "--gridsize")) {
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
gridsize = atoi(argv[1]);
opt = 1;
}
else if (!strcmp (argv[0], "--no-legend")) {
loutput.legend = 0;
}
else if (!strcmp (argv[0], "--append-legend")) {
char **tmp;
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
tmp = realloc(lstopo_append_legends, (lstopo_append_legends_nr+1) * sizeof(*lstopo_append_legends));
if (!tmp) {
fprintf(stderr, "Failed to realloc legend append array, legend ignored.\n");
} else {
lstopo_append_legends = tmp;
lstopo_append_legends[lstopo_append_legends_nr] = strdup(argv[1]);
lstopo_append_legends_nr++;
}
opt = 1;
}
else if (hwloc_utils_lookup_input_option(argv, argc, &opt,
&input, &input_format,
callname)) {
/* nothing to do anymore */
} else if (!strcmp (argv[0], "--pid")) {
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
lstopo_pid_number = atoi(argv[1]); opt = 1;
} else if (!strcmp (argv[0], "--ps") || !strcmp (argv[0], "--top"))
top = 1;
else if (!strcmp (argv[0], "--version")) {
printf("%s %s\n", callname, HWLOC_VERSION);
exit(EXIT_SUCCESS);
} else if (!strcmp (argv[0], "--output-format") || !strcmp (argv[0], "--of")) {
if (argc < 2) {
usage (callname, stderr);
exit(EXIT_FAILURE);
}
output_format = parse_output_format(argv[1], callname);
opt = 1;
} else {
if (filename) {
fprintf (stderr, "Unrecognized option: %s\n", argv[0]);
usage (callname, stderr);
exit(EXIT_FAILURE);
} else
filename = argv[0];
}
argc -= opt+1;
argv += opt+1;
}
if (lstopo_show_only != (hwloc_obj_type_t)-1)
merge = 0;
hwloc_topology_set_flags(topology, flags);
if (ignorecache > 1) {
hwloc_topology_ignore_type(topology, HWLOC_OBJ_CACHE);
} else if (ignorecache) {
hwloc_topology_ignore_type_keep_structure(topology, HWLOC_OBJ_CACHE);
}
if (merge)
hwloc_topology_ignore_all_keep_structure(topology);
if (input) {
err = hwloc_utils_enable_input_format(topology, input, &input_format, loutput.verbose_mode > 1, callname);
if (err)
return err;
}
if (lstopo_pid_number > 0) {
lstopo_pid = hwloc_pid_from_number(lstopo_pid_number, 0);
if (hwloc_topology_set_pid(topology, lstopo_pid)) {
perror("Setting target pid");
return EXIT_FAILURE;
}
}
/* if the output format wasn't enforced, look at the filename */
if (filename && output_format == LSTOPO_OUTPUT_DEFAULT) {
if (!strcmp(filename, "-")
|| !strcmp(filename, "/dev/stdout")) {
output_format = LSTOPO_OUTPUT_CONSOLE;
} else {
char *dot = strrchr(filename, '.');
if (dot)
output_format = parse_output_format(dot+1, callname);
else {
fprintf(stderr, "Cannot infer output type for file `%s' without any extension, using default output.\n", filename);
filename = NULL;
}
}
}
/* if the output format wasn't enforced, think a bit about what the user probably want */
if (output_format == LSTOPO_OUTPUT_DEFAULT) {
if (lstopo_show_cpuset
|| lstopo_show_only != (hwloc_obj_type_t)-1
|| loutput.verbose_mode != LSTOPO_VERBOSE_MODE_DEFAULT)
output_format = LSTOPO_OUTPUT_CONSOLE;
}
if (input_format == HWLOC_UTILS_INPUT_XML
&& output_format == LSTOPO_OUTPUT_XML) {
/* must be after parsing output format and before loading the topology */
putenv("HWLOC_XML_USERDATA_NOT_DECODED=1");
hwloc_topology_set_userdata_import_callback(topology, hwloc_utils_userdata_import_cb);
hwloc_topology_set_userdata_export_callback(topology, hwloc_utils_userdata_export_cb);
}
err = hwloc_topology_load (topology);
if (err) {
fprintf(stderr, "hwloc_topology_load() failed (%s).\n", strerror(errno));
return EXIT_FAILURE;
}
if (top)
add_process_objects(topology);
if (restrictstring) {
hwloc_bitmap_t restrictset = hwloc_bitmap_alloc();
if (!strcmp (restrictstring, "binding")) {
if (lstopo_pid_number > 0)
hwloc_get_proc_cpubind(topology, lstopo_pid, restrictset, HWLOC_CPUBIND_PROCESS);
else
hwloc_get_cpubind(topology, restrictset, HWLOC_CPUBIND_PROCESS);
} else {
hwloc_bitmap_sscanf(restrictset, restrictstring);
}
err = hwloc_topology_restrict (topology, restrictset, restrict_flags);
if (err) {
perror("Restricting the topology");
/* fallthrough */
}
hwloc_bitmap_free(restrictset);
free(restrictstring);
}
if (loutput.logical == -1) {
if (output_format == LSTOPO_OUTPUT_CONSOLE)
loutput.logical = 1;
else if (output_format != LSTOPO_OUTPUT_DEFAULT)
loutput.logical = 0;
}
loutput.topology = topology;
loutput.file = NULL;
lstopo_populate_userdata(hwloc_get_root_obj(topology));
if (output_format != LSTOPO_OUTPUT_XML && lstopo_collapse)
lstopo_add_collapse_attributes(topology);
switch (output_format) {
case LSTOPO_OUTPUT_DEFAULT:
#ifdef LSTOPO_HAVE_GRAPHICS
#if CAIRO_HAS_XLIB_SURFACE && defined HWLOC_HAVE_X11_KEYSYM
if (getenv("DISPLAY")) {
if (loutput.logical == -1)
loutput.logical = 0;
output_x11(&loutput, NULL);
} else
#endif /* CAIRO_HAS_XLIB_SURFACE */
#ifdef HWLOC_WIN_SYS
{
if (loutput.logical == -1)
loutput.logical = 0;
output_windows(&loutput, NULL);
}
#endif
#endif /* !LSTOPO_HAVE_GRAPHICS */
#if !defined HWLOC_WIN_SYS || !defined LSTOPO_HAVE_GRAPHICS
{
if (loutput.logical == -1)
loutput.logical = 1;
output_console(&loutput, NULL);
}
#endif
break;
case LSTOPO_OUTPUT_CONSOLE:
output_console(&loutput, filename);
break;
case LSTOPO_OUTPUT_SYNTHETIC:
output_synthetic(&loutput, filename);
break;
case LSTOPO_OUTPUT_ASCII:
output_ascii(&loutput, filename);
break;
case LSTOPO_OUTPUT_FIG:
output_fig(&loutput, filename);
break;
#ifdef LSTOPO_HAVE_GRAPHICS
# if CAIRO_HAS_PNG_FUNCTIONS
case LSTOPO_OUTPUT_PNG:
output_png(&loutput, filename);
break;
# endif /* CAIRO_HAS_PNG_FUNCTIONS */
# if CAIRO_HAS_PDF_SURFACE
case LSTOPO_OUTPUT_PDF:
output_pdf(&loutput, filename);
break;
# endif /* CAIRO_HAS_PDF_SURFACE */
# if CAIRO_HAS_PS_SURFACE
case LSTOPO_OUTPUT_PS:
output_ps(&loutput, filename);
break;
#endif /* CAIRO_HAS_PS_SURFACE */
#if CAIRO_HAS_SVG_SURFACE
case LSTOPO_OUTPUT_SVG:
output_svg(&loutput, filename);
break;
#endif /* CAIRO_HAS_SVG_SURFACE */
#endif /* LSTOPO_HAVE_GRAPHICS */
case LSTOPO_OUTPUT_XML:
output_xml(&loutput, filename);
break;
default:
fprintf(stderr, "file format not supported\n");
usage(callname, stderr);
exit(EXIT_FAILURE);
}
lstopo_destroy_userdata(hwloc_get_root_obj(topology));
hwloc_utils_userdata_free_recursive(hwloc_get_root_obj(topology));
hwloc_topology_destroy (topology);
for(i=0; i<lstopo_append_legends_nr; i++)
free(lstopo_append_legends[i]);
free(lstopo_append_legends);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
hwloc_topology_t topology;
int loaded = 0;
unsigned depth;
hwloc_bitmap_t cpubind_set, membind_set;
int got_cpubind = 0, got_membind = 0;
int working_on_cpubind = 1; /* membind if 0 */
int get_binding = 0;
int get_last_cpu_location = 0;
unsigned long flags = 0;
int force = 0;
int single = 0;
int verbose = 0;
int logical = 1;
int taskset = 0;
int cpubind_flags = 0;
hwloc_membind_policy_t membind_policy = HWLOC_MEMBIND_BIND;
int membind_flags = 0;
int opt;
int ret;
int pid_number = -1;
hwloc_pid_t pid = 0; /* only valid when pid_number > 0, but gcc-4.8 still reports uninitialized warnings */
char *callname;
cpubind_set = hwloc_bitmap_alloc();
membind_set = hwloc_bitmap_alloc();
/* don't load now, in case some options change the config before the topology is actually used */
#define LOADED() (loaded)
#define ENSURE_LOADED() do { \
if (!loaded) { \
hwloc_topology_init(&topology); \
hwloc_topology_set_all_types_filter(topology, HWLOC_TYPE_FILTER_KEEP_ALL); \
hwloc_topology_set_flags(topology, flags); \
hwloc_topology_load(topology); \
depth = hwloc_topology_get_depth(topology); \
loaded = 1; \
} \
} while (0)
callname = argv[0];
/* skip argv[0], handle options */
argv++;
argc--;
while (argc >= 1) {
if (!strcmp(argv[0], "--")) {
argc--;
argv++;
break;
}
opt = 0;
if (*argv[0] == '-') {
if (!strcmp(argv[0], "-v") || !strcmp(argv[0], "--verbose")) {
verbose++;
goto next;
}
if (!strcmp(argv[0], "-q") || !strcmp(argv[0], "--quiet")) {
verbose--;
goto next;
}
if (!strcmp(argv[0], "--help")) {
usage("hwloc-bind", stdout);
return EXIT_SUCCESS;
}
if (!strcmp(argv[0], "--single")) {
single = 1;
goto next;
}
if (!strcmp(argv[0], "-f") || !strcmp(argv[0], "--force")) {
force = 1;
goto next;
}
if (!strcmp(argv[0], "--strict")) {
cpubind_flags |= HWLOC_CPUBIND_STRICT;
membind_flags |= HWLOC_MEMBIND_STRICT;
goto next;
}
if (!strcmp(argv[0], "--pid")) {
if (argc < 2) {
usage ("hwloc-bind", stderr);
exit(EXIT_FAILURE);
}
pid_number = atoi(argv[1]);
opt = 1;
goto next;
}
if (!strcmp (argv[0], "--version")) {
printf("%s %s\n", callname, HWLOC_VERSION);
exit(EXIT_SUCCESS);
}
if (!strcmp(argv[0], "-l") || !strcmp(argv[0], "--logical")) {
logical = 1;
goto next;
}
if (!strcmp(argv[0], "-p") || !strcmp(argv[0], "--physical")) {
logical = 0;
goto next;
}
if (!strcmp(argv[0], "--taskset")) {
taskset = 1;
goto next;
}
if (!strcmp (argv[0], "-e") || !strncmp (argv[0], "--get-last-cpu-location", 10)) {
get_last_cpu_location = 1;
goto next;
}
if (!strcmp (argv[0], "--get")) {
get_binding = 1;
goto next;
}
if (!strcmp (argv[0], "--cpubind")) {
working_on_cpubind = 1;
goto next;
}
if (!strcmp (argv[0], "--membind")) {
working_on_cpubind = 0;
goto next;
}
if (!strcmp (argv[0], "--mempolicy")) {
if (!strncmp(argv[1], "default", 2))
membind_policy = HWLOC_MEMBIND_DEFAULT;
else if (!strncmp(argv[1], "firsttouch", 2))
membind_policy = HWLOC_MEMBIND_FIRSTTOUCH;
else if (!strncmp(argv[1], "bind", 2))
membind_policy = HWLOC_MEMBIND_BIND;
else if (!strncmp(argv[1], "interleave", 2))
membind_policy = HWLOC_MEMBIND_INTERLEAVE;
else if (!strncmp(argv[1], "nexttouch", 2))
membind_policy = HWLOC_MEMBIND_NEXTTOUCH;
else {
fprintf(stderr, "Unrecognized memory binding policy %s\n", argv[1]);
usage ("hwloc-bind", stderr);
exit(EXIT_FAILURE);
}
opt = 1;
goto next;
}
if (!strcmp (argv[0], "--whole-system")) {
if (loaded) {
fprintf(stderr, "Input option %s disallowed after options using the topology\n", argv[0]);
exit(EXIT_FAILURE);
}
flags |= HWLOC_TOPOLOGY_FLAG_WHOLE_SYSTEM;
goto next;
}
if (!strcmp (argv[0], "--restrict")) {
hwloc_bitmap_t restrictset;
int err;
if (argc < 2) {
usage (callname, stdout);
exit(EXIT_FAILURE);
}
restrictset = hwloc_bitmap_alloc();
hwloc_bitmap_sscanf(restrictset, argv[1]);
ENSURE_LOADED();
err = hwloc_topology_restrict (topology, restrictset, 0);
if (err) {
perror("Restricting the topology");
/* fallthrough */
}
hwloc_bitmap_free(restrictset);
argc--;
argv++;
goto next;
}
fprintf (stderr, "Unrecognized option: %s\n", argv[0]);
usage("hwloc-bind", stderr);
return EXIT_FAILURE;
}
ENSURE_LOADED();
ret = hwloc_calc_process_arg(topology, depth, argv[0], logical,
working_on_cpubind ? cpubind_set : membind_set,
verbose);
if (ret < 0) {
if (verbose > 0)
fprintf(stderr, "assuming the command starts at %s\n", argv[0]);
break;
}
if (working_on_cpubind)
got_cpubind = 1;
else
got_membind = 1;
next:
argc -= opt+1;
argv += opt+1;
}
ENSURE_LOADED();
if (pid_number > 0) {
pid = hwloc_pid_from_number(pid_number, !(get_binding || get_last_cpu_location));
/* no need to set_pid()
* the doc just says we're operating on pid, not that we're retrieving the topo/cpuset as seen from inside pid
*/
}
if (get_last_cpu_location && !working_on_cpubind) {
fprintf(stderr, "Options --membind and --get-last-cpu-location cannot be combined.\n");
return EXIT_FAILURE;
}
if ((get_binding || get_last_cpu_location) && (got_cpubind || got_membind)) {
/* doesn't work because get_binding/get_last_cpu_location overwrites cpubind_set */
fprintf(stderr, "Cannot display and set binding at the same time.\n");
return EXIT_FAILURE;
}
if (get_binding || get_last_cpu_location) {
char *s;
const char *policystr = NULL;
int err;
if (working_on_cpubind) {
if (get_last_cpu_location) {
if (pid_number > 0)
err = hwloc_get_proc_last_cpu_location(topology, pid, cpubind_set, 0);
else
err = hwloc_get_last_cpu_location(topology, cpubind_set, 0);
} else {
if (pid_number > 0)
err = hwloc_get_proc_cpubind(topology, pid, cpubind_set, 0);
else
err = hwloc_get_cpubind(topology, cpubind_set, 0);
}
if (err) {
const char *errmsg = strerror(errno);
if (pid_number > 0)
fprintf(stderr, "hwloc_get_proc_%s %d failed (errno %d %s)\n", get_last_cpu_location ? "last_cpu_location" : "cpubind", pid_number, errno, errmsg);
else
fprintf(stderr, "hwloc_get_%s failed (errno %d %s)\n", get_last_cpu_location ? "last_cpu_location" : "cpubind", errno, errmsg);
return EXIT_FAILURE;
}
if (taskset)
hwloc_bitmap_taskset_asprintf(&s, cpubind_set);
else
hwloc_bitmap_asprintf(&s, cpubind_set);
} else {
hwloc_membind_policy_t policy;
if (pid_number > 0)
err = hwloc_get_proc_membind(topology, pid, membind_set, &policy, 0);
else
err = hwloc_get_membind(topology, membind_set, &policy, 0);
if (err) {
const char *errmsg = strerror(errno);
if (pid_number > 0)
fprintf(stderr, "hwloc_get_proc_membind %d failed (errno %d %s)\n", pid_number, errno, errmsg);
else
fprintf(stderr, "hwloc_get_membind failed (errno %d %s)\n", errno, errmsg);
return EXIT_FAILURE;
}
if (taskset)
hwloc_bitmap_taskset_asprintf(&s, membind_set);
else
hwloc_bitmap_asprintf(&s, membind_set);
switch (policy) {
case HWLOC_MEMBIND_DEFAULT: policystr = "default"; break;
case HWLOC_MEMBIND_FIRSTTOUCH: policystr = "firsttouch"; break;
case HWLOC_MEMBIND_BIND: policystr = "bind"; break;
case HWLOC_MEMBIND_INTERLEAVE: policystr = "interleave"; break;
case HWLOC_MEMBIND_NEXTTOUCH: policystr = "nexttouch"; break;
default: fprintf(stderr, "unknown memory policy %d\n", policy); assert(0); break;
}
}
if (policystr)
printf("%s (%s)\n", s, policystr);
else
printf("%s\n", s);
free(s);
}
if (got_membind) {
if (hwloc_bitmap_iszero(membind_set)) {
if (verbose >= 0)
fprintf(stderr, "cannot membind to empty set\n");
if (!force)
goto failed_binding;
}
if (verbose > 0) {
char *s;
hwloc_bitmap_asprintf(&s, membind_set);
fprintf(stderr, "binding on memory set %s\n", s);
free(s);
}
if (single)
hwloc_bitmap_singlify(membind_set);
if (pid_number > 0)
ret = hwloc_set_proc_membind(topology, pid, membind_set, membind_policy, membind_flags);
else
ret = hwloc_set_membind(topology, membind_set, membind_policy, membind_flags);
if (ret && verbose >= 0) {
int bind_errno = errno;
const char *errmsg = strerror(bind_errno);
char *s;
hwloc_bitmap_asprintf(&s, membind_set);
if (pid_number > 0)
fprintf(stderr, "hwloc_set_proc_membind %s %d failed (errno %d %s)\n", s, pid_number, bind_errno, errmsg);
else
fprintf(stderr, "hwloc_set_membind %s failed (errno %d %s)\n", s, bind_errno, errmsg);
free(s);
}
if (ret && !force)
goto failed_binding;
}
if (got_cpubind) {
if (hwloc_bitmap_iszero(cpubind_set)) {
if (verbose >= 0)
fprintf(stderr, "cannot cpubind to empty set\n");
if (!force)
goto failed_binding;
}
if (verbose > 0) {
char *s;
hwloc_bitmap_asprintf(&s, cpubind_set);
fprintf(stderr, "binding on cpu set %s\n", s);
free(s);
}
if (single)
hwloc_bitmap_singlify(cpubind_set);
if (pid_number > 0)
ret = hwloc_set_proc_cpubind(topology, pid, cpubind_set, cpubind_flags);
else
ret = hwloc_set_cpubind(topology, cpubind_set, cpubind_flags);
if (ret && verbose >= 0) {
int bind_errno = errno;
const char *errmsg = strerror(bind_errno);
char *s;
hwloc_bitmap_asprintf(&s, cpubind_set);
if (pid_number > 0)
fprintf(stderr, "hwloc_set_proc_cpubind %s %d failed (errno %d %s)\n", s, pid_number, bind_errno, errmsg);
else
fprintf(stderr, "hwloc_set_cpubind %s failed (errno %d %s)\n", s, bind_errno, errmsg);
free(s);
}
if (ret && !force)
goto failed_binding;
}
hwloc_bitmap_free(cpubind_set);
hwloc_bitmap_free(membind_set);
hwloc_topology_destroy(topology);
if (pid_number > 0)
return EXIT_SUCCESS;
if (0 == argc) {
if (get_binding || get_last_cpu_location)
return EXIT_SUCCESS;
fprintf(stderr, "%s: nothing to do!\n", callname);
return EXIT_FAILURE;
}
/* FIXME: check whether Windows execvp() passes INHERIT_PARENT_AFFINITY to CreateProcess()
* because we need to propagate processor group affinity. However process-wide affinity
* isn't supported with processor groups so far.
*/
ret = execvp(argv[0], argv);
if (ret) {
fprintf(stderr, "%s: Failed to launch executable \"%s\"\n",
callname, argv[0]);
perror("execvp");
}
return EXIT_FAILURE;
failed_binding:
hwloc_bitmap_free(cpubind_set);
hwloc_bitmap_free(membind_set);
hwloc_topology_destroy(topology);
return EXIT_FAILURE;
}
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(int argc, char *argv[])
{
hwloc_topology_t topology;
unsigned depth;
hwloc_bitmap_t cpubind_set, membind_set;
int got_cpubind = 0, got_membind = 0;
int working_on_cpubind = 1; /* membind if 0 */
int get_binding = 0;
int get_last_cpu_location = 0;
unsigned long flags = HWLOC_TOPOLOGY_FLAG_WHOLE_IO|HWLOC_TOPOLOGY_FLAG_ICACHES;
int force = 0;
int single = 0;
int verbose = 0;
int logical = 1;
int taskset = 0;
int cpubind_flags = 0;
hwloc_membind_policy_t membind_policy = HWLOC_MEMBIND_BIND;
int membind_flags = 0;
int opt;
int ret;
int pid_number = 0;
hwloc_pid_t pid;
char *callname;
cpubind_set = hwloc_bitmap_alloc();
membind_set = hwloc_bitmap_alloc();
hwloc_topology_init(&topology);
hwloc_topology_set_flags(topology, flags);
hwloc_topology_load(topology);
depth = hwloc_topology_get_depth(topology);
callname = argv[0];
/* skip argv[0], handle options */
argv++;
argc--;
while (argc >= 1) {
if (!strcmp(argv[0], "--")) {
argc--;
argv++;
break;
}
opt = 0;
if (*argv[0] == '-') {
if (!strcmp(argv[0], "-v") || !strcmp(argv[0], "--verbose")) {
verbose++;
goto next;
}
else if (!strcmp(argv[0], "-q") || !strcmp(argv[0], "--quiet")) {
verbose--;
goto next;
}
else if (!strcmp(argv[0], "--help")) {
usage("hwloc-bind", stdout);
return EXIT_SUCCESS;
}
else if (!strcmp(argv[0], "--single")) {
single = 1;
goto next;
}
else if (!strcmp(argv[0], "-f") || !strcmp(argv[0], "--force")) {
force = 1;
goto next;
}
else if (!strcmp(argv[0], "--strict")) {
cpubind_flags |= HWLOC_CPUBIND_STRICT;
membind_flags |= HWLOC_MEMBIND_STRICT;
goto next;
}
else if (!strcmp(argv[0], "--pid")) {
if (argc < 2) {
usage ("hwloc-bind", stderr);
exit(EXIT_FAILURE);
}
pid_number = atoi(argv[1]);
opt = 1;
goto next;
}
else if (!strcmp (argv[0], "--version")) {
printf("%s %s\n", callname, VERSION);
exit(EXIT_SUCCESS);
}
if (!strcmp(argv[0], "-l") || !strcmp(argv[0], "--logical")) {
logical = 1;
goto next;
}
if (!strcmp(argv[0], "-p") || !strcmp(argv[0], "--physical")) {
logical = 0;
goto next;
}
if (!strcmp(argv[0], "--taskset")) {
taskset = 1;
goto next;
}
else if (!strcmp (argv[0], "-e") || !strncmp (argv[0], "--get-last-cpu-location", 10)) {
get_last_cpu_location = 1;
goto next;
}
else if (!strcmp (argv[0], "--get")) {
get_binding = 1;
goto next;
}
else if (!strcmp (argv[0], "--cpubind")) {
working_on_cpubind = 1;
goto next;
}
else if (!strcmp (argv[0], "--membind")) {
working_on_cpubind = 0;
goto next;
}
else if (!strcmp (argv[0], "--mempolicy")) {
if (!strncmp(argv[1], "default", 2))
membind_policy = HWLOC_MEMBIND_DEFAULT;
else if (!strncmp(argv[1], "firsttouch", 2))
membind_policy = HWLOC_MEMBIND_FIRSTTOUCH;
else if (!strncmp(argv[1], "bind", 2))
membind_policy = HWLOC_MEMBIND_BIND;
else if (!strncmp(argv[1], "interleave", 2))
membind_policy = HWLOC_MEMBIND_INTERLEAVE;
else if (!strncmp(argv[1], "replicate", 2))
membind_policy = HWLOC_MEMBIND_REPLICATE;
else if (!strncmp(argv[1], "nexttouch", 2))
membind_policy = HWLOC_MEMBIND_NEXTTOUCH;
else {
fprintf(stderr, "Unrecognized memory binding policy %s\n", argv[1]);
usage ("hwloc-bind", stderr);
exit(EXIT_FAILURE);
}
opt = 1;
goto next;
}
else if (!strcmp (argv[0], "--whole-system")) {
flags |= HWLOC_TOPOLOGY_FLAG_WHOLE_SYSTEM;
hwloc_topology_destroy(topology);
hwloc_topology_init(&topology);
hwloc_topology_set_flags(topology, flags);
hwloc_topology_load(topology);
depth = hwloc_topology_get_depth(topology);
goto next;
}
else if (!strcmp (argv[0], "--restrict")) {
hwloc_bitmap_t restrictset;
int err;
if (argc < 2) {
usage (callname, stdout);
exit(EXIT_FAILURE);
}
restrictset = hwloc_bitmap_alloc();
hwloc_bitmap_sscanf(restrictset, argv[1]);
err = hwloc_topology_restrict (topology, restrictset, 0);
if (err) {
perror("Restricting the topology");
/* fallthrough */
}
hwloc_bitmap_free(restrictset);
argc--;
argv++;
goto next;
}
fprintf (stderr, "Unrecognized option: %s\n", argv[0]);
usage("hwloc-bind", stderr);
return EXIT_FAILURE;
}
ret = hwloc_calc_process_arg(topology, depth, argv[0], logical,
working_on_cpubind ? cpubind_set : membind_set,
verbose);
if (ret < 0) {
if (verbose > 0)
fprintf(stderr, "assuming the command starts at %s\n", argv[0]);
break;
}
if (working_on_cpubind)
got_cpubind = 1;
else
got_membind = 1;
next:
argc -= opt+1;
argv += opt+1;
}
pid = hwloc_pid_from_number(pid_number, !(get_binding || get_last_cpu_location));
if (get_binding || get_last_cpu_location) {
char *s;
const char *policystr = NULL;
int err;
if (working_on_cpubind) {
if (get_last_cpu_location) {
if (pid_number)
err = hwloc_get_proc_last_cpu_location(topology, pid, cpubind_set, 0);
else
err = hwloc_get_last_cpu_location(topology, cpubind_set, 0);
} else {
if (pid_number)
err = hwloc_get_proc_cpubind(topology, pid, cpubind_set, 0);
else
err = hwloc_get_cpubind(topology, cpubind_set, 0);
}
if (err) {
const char *errmsg = strerror(errno);
if (pid_number)
fprintf(stderr, "hwloc_get_proc_%s %d failed (errno %d %s)\n", get_last_cpu_location ? "last_cpu_location" : "cpubind", pid_number, errno, errmsg);
else
fprintf(stderr, "hwloc_get_%s failed (errno %d %s)\n", get_last_cpu_location ? "last_cpu_location" : "cpubind", errno, errmsg);
return EXIT_FAILURE;
}
if (taskset)
hwloc_bitmap_taskset_asprintf(&s, cpubind_set);
else
hwloc_bitmap_asprintf(&s, cpubind_set);
} else {
hwloc_membind_policy_t policy;
if (pid_number)
err = hwloc_get_proc_membind(topology, pid, membind_set, &policy, 0);
else
err = hwloc_get_membind(topology, membind_set, &policy, 0);
if (err) {
const char *errmsg = strerror(errno);
if (pid_number)
fprintf(stderr, "hwloc_get_proc_membind %d failed (errno %d %s)\n", pid_number, errno, errmsg);
else
fprintf(stderr, "hwloc_get_membind failed (errno %d %s)\n", errno, errmsg);
return EXIT_FAILURE;
}
if (taskset)
hwloc_bitmap_taskset_asprintf(&s, membind_set);
else
hwloc_bitmap_asprintf(&s, membind_set);
switch (policy) {
case HWLOC_MEMBIND_DEFAULT: policystr = "default"; break;
case HWLOC_MEMBIND_FIRSTTOUCH: policystr = "firsttouch"; break;
case HWLOC_MEMBIND_BIND: policystr = "bind"; break;
case HWLOC_MEMBIND_INTERLEAVE: policystr = "interleave"; break;
case HWLOC_MEMBIND_REPLICATE: policystr = "replicate"; break;
case HWLOC_MEMBIND_NEXTTOUCH: policystr = "nexttouch"; break;
default: fprintf(stderr, "unknown memory policy %d\n", policy); assert(0); break;
}
}
if (policystr)
printf("%s (%s)\n", s, policystr);
else
printf("%s\n", s);
free(s);
return EXIT_SUCCESS;
}
if (got_membind) {
if (hwloc_bitmap_iszero(membind_set)) {
if (verbose >= 0)
fprintf(stderr, "cannot membind to empty set\n");
if (!force)
goto failed_binding;
}
if (verbose > 0) {
char *s;
hwloc_bitmap_asprintf(&s, membind_set);
fprintf(stderr, "binding on memory set %s\n", s);
free(s);
}
if (single)
hwloc_bitmap_singlify(membind_set);
if (pid_number)
ret = hwloc_set_proc_membind(topology, pid, membind_set, membind_policy, membind_flags);
else
ret = hwloc_set_membind(topology, membind_set, membind_policy, membind_flags);
if (ret && verbose >= 0) {
int bind_errno = errno;
const char *errmsg = strerror(bind_errno);
char *s;
hwloc_bitmap_asprintf(&s, membind_set);
if (pid_number)
fprintf(stderr, "hwloc_set_proc_membind %s %d failed (errno %d %s)\n", s, pid_number, bind_errno, errmsg);
else
fprintf(stderr, "hwloc_set_membind %s failed (errno %d %s)\n", s, bind_errno, errmsg);
free(s);
}
if (ret && !force)
goto failed_binding;
}
if (got_cpubind) {
if (hwloc_bitmap_iszero(cpubind_set)) {
if (verbose >= 0)
fprintf(stderr, "cannot cpubind to empty set\n");
if (!force)
goto failed_binding;
}
if (verbose > 0) {
char *s;
hwloc_bitmap_asprintf(&s, cpubind_set);
fprintf(stderr, "binding on cpu set %s\n", s);
free(s);
}
if (single)
hwloc_bitmap_singlify(cpubind_set);
if (pid_number)
ret = hwloc_set_proc_cpubind(topology, pid, cpubind_set, cpubind_flags);
else
ret = hwloc_set_cpubind(topology, cpubind_set, cpubind_flags);
if (ret && verbose >= 0) {
int bind_errno = errno;
const char *errmsg = strerror(bind_errno);
char *s;
hwloc_bitmap_asprintf(&s, cpubind_set);
if (pid_number)
fprintf(stderr, "hwloc_set_proc_cpubind %s %d failed (errno %d %s)\n", s, pid_number, bind_errno, errmsg);
else
fprintf(stderr, "hwloc_set_cpubind %s failed (errno %d %s)\n", s, bind_errno, errmsg);
free(s);
}
if (ret && !force)
goto failed_binding;
}
hwloc_bitmap_free(cpubind_set);
hwloc_bitmap_free(membind_set);
hwloc_topology_destroy(topology);
if (pid_number)
return EXIT_SUCCESS;
if (0 == argc) {
fprintf(stderr, "%s: nothing to do!\n", callname);
return EXIT_FAILURE;
}
ret = execvp(argv[0], argv);
if (ret) {
fprintf(stderr, "%s: Failed to launch executable \"%s\"\n",
callname, argv[0]);
perror("execvp");
}
return EXIT_FAILURE;
failed_binding:
hwloc_bitmap_free(cpubind_set);
hwloc_bitmap_free(membind_set);
hwloc_topology_destroy(topology);
return EXIT_FAILURE;
}
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;
}
