int slurm_getaffinity(pid_t pid, size_t size, cpu_set_t *mask)
{
int rval;
char mstr[1 + CPU_SETSIZE / 4];
CPU_ZERO(mask);
/*
* The FreeBSD cpuset API is a superset of the Linux API.
* In addition to PIDs, it supports threads, interrupts,
* jails, and potentially other objects. The first two arguments
* to cpuset_*etaffinity() below indicate that the third argument
* is a PID. -1 indicates the PID of the calling process.
* Linux sched_*etaffinity() uses 0 for this.
*/
#ifdef __FreeBSD__
rval = cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID,
pid, size, mask);
#elif defined(SCHED_GETAFFINITY_THREE_ARGS)
rval = sched_getaffinity(pid, size, mask);
#else
rval = sched_getaffinity(pid, mask);
#endif
if (rval) {
verbose("sched_getaffinity(%d,%zd,0x%s) failed with status %d",
pid, size, task_cpuset_to_str(mask, mstr), rval);
} else {
debug3("sched_getaffinity(%d) = 0x%s",
pid, task_cpuset_to_str(mask, mstr));
}
return (rval);
}
int slurm_setaffinity(pid_t pid, size_t size, const cpu_set_t *mask)
{
int rval;
char mstr[1 + CPU_SETSIZE / 4];
#ifdef __FreeBSD__
rval = cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID,
pid, size, mask);
#elif defined(SCHED_GETAFFINITY_THREE_ARGS)
rval = sched_setaffinity(pid, size, mask);
#else
rval = sched_setaffinity(pid, mask);
#endif
if (rval) {
verbose("sched_setaffinity(%d,%zd,0x%s) failed: %m",
pid, size, task_cpuset_to_str(mask, mstr));
}
return (rval);
}
/* user to have to play with the cgroup hierarchy to modify it */
extern int task_cgroup_cpuset_set_task_affinity(stepd_step_rec_t *job)
{
int fstatus = SLURM_ERROR;
#ifndef HAVE_HWLOC
error("task/cgroup: plugin not compiled with hwloc support, "
"skipping affinity.");
return fstatus;
#else
char mstr[1 + CPU_SETSIZE / 4];
cpu_bind_type_t bind_type;
cpu_set_t ts;
hwloc_obj_t obj;
hwloc_obj_type_t socket_or_node;
hwloc_topology_t topology;
hwloc_bitmap_t cpuset;
hwloc_obj_type_t hwtype;
hwloc_obj_type_t req_hwtype;
int bind_verbose = 0;
int rc = SLURM_SUCCESS;
pid_t pid = job->envtp->task_pid;
size_t tssize;
uint32_t nldoms;
uint32_t nsockets;
uint32_t ncores;
uint32_t npus;
uint32_t nobj;
uint32_t taskid = job->envtp->localid;
uint32_t jntasks = job->node_tasks;
uint32_t jnpus;
/* Allocate and initialize hwloc objects */
hwloc_topology_init(&topology);
hwloc_topology_load(topology);
cpuset = hwloc_bitmap_alloc();
int spec_threads = 0;
if (job->batch) {
jnpus = job->cpus;
job->cpus_per_task = job->cpus;
} else
jnpus = jntasks * job->cpus_per_task;
bind_type = job->cpu_bind_type;
if ((conf->task_plugin_param & CPU_BIND_VERBOSE) ||
(bind_type & CPU_BIND_VERBOSE))
bind_verbose = 1 ;
if ( hwloc_get_type_depth(topology, HWLOC_OBJ_NODE) >
hwloc_get_type_depth(topology, HWLOC_OBJ_SOCKET) ) {
/* One socket contains multiple NUMA-nodes
* like AMD Opteron 6000 series etc.
* In such case, use NUMA-node instead of socket. */
socket_or_node = HWLOC_OBJ_NODE;
} else {
socket_or_node = HWLOC_OBJ_SOCKET;
}
if (bind_type & CPU_BIND_NONE) {
if (bind_verbose)
info("task/cgroup: task[%u] is requesting no affinity",
taskid);
return 0;
} else if (bind_type & CPU_BIND_TO_THREADS) {
if (bind_verbose)
info("task/cgroup: task[%u] is requesting "
"thread level binding",taskid);
req_hwtype = HWLOC_OBJ_PU;
} else if (bind_type & CPU_BIND_TO_CORES) {
if (bind_verbose)
info("task/cgroup: task[%u] is requesting "
"core level binding",taskid);
req_hwtype = HWLOC_OBJ_CORE;
} else if (bind_type & CPU_BIND_TO_SOCKETS) {
if (bind_verbose)
info("task/cgroup: task[%u] is requesting "
"socket level binding",taskid);
req_hwtype = socket_or_node;
} else if (bind_type & CPU_BIND_TO_LDOMS) {
if (bind_verbose)
info("task/cgroup: task[%u] is requesting "
"ldom level binding",taskid);
req_hwtype = HWLOC_OBJ_NODE;
} else if (bind_type & CPU_BIND_TO_BOARDS) {
if (bind_verbose)
info("task/cgroup: task[%u] is requesting "
"board level binding",taskid);
req_hwtype = HWLOC_OBJ_GROUP;
} else if (bind_type & bind_mode_ldom) {
req_hwtype = HWLOC_OBJ_NODE;
} else {
if (bind_verbose)
info("task/cgroup: task[%u] using core level binding"
" by default",taskid);
req_hwtype = HWLOC_OBJ_CORE;
}
/*
* Perform the topology detection. It will only get allowed PUs.
* Detect in the same time the granularity to use for binding.
* The granularity can be relaxed from threads to cores if enough
* cores are available as with hyperthread support, ntasks-per-core
* param can let us have access to more threads per core for each
* task
* Revert back to machine granularity if no finer-grained granularity
* matching the request is found. This will result in no affinity
* applied.
* The detected granularity will be used to find where to best place
* the task, then the cpu_bind option will be used to relax the
* affinity constraint and use more PUs. (i.e. use a core granularity
* to dispatch the tasks across the sockets and then provide access
* to each task to the cores of its socket.)
*/
npus = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_PU);
ncores = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_CORE);
nsockets = (uint32_t) hwloc_get_nbobjs_by_type(topology,
socket_or_node);
nldoms = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_NODE);
//info("PU:%d CORE:%d SOCK:%d LDOM:%d", npus, ncores, nsockets, nldoms);
hwtype = HWLOC_OBJ_MACHINE;
nobj = 1;
if ((job->job_core_spec != NO_VAL16) &&
(job->job_core_spec & CORE_SPEC_THREAD) &&
(job->job_core_spec != CORE_SPEC_THREAD)) {
spec_threads = job->job_core_spec & (~CORE_SPEC_THREAD);
}
/* Set this to PU but realise it could be overridden later if we can
* fill up a core.
*/
if (npus >= (jnpus + spec_threads)) {
hwtype = HWLOC_OBJ_PU;
nobj = npus;
}
/* Force to bind to Threads */
if (bind_type & CPU_BIND_TO_THREADS) {
hwtype = HWLOC_OBJ_PU;
nobj = npus;
} else if (ncores >= jnpus || bind_type & CPU_BIND_TO_CORES) {
hwtype = HWLOC_OBJ_CORE;
nobj = ncores;
}
if (nsockets >= jntasks &&
bind_type & CPU_BIND_TO_SOCKETS) {
hwtype = socket_or_node;
nobj = nsockets;
}
/*
* HWLOC returns all the NUMA nodes available regardless of the
* number of underlying sockets available (regardless of the allowed
* resources). So there is no guarantee that each ldom will be populated
* with usable sockets. So add a simple check that at least ensure that
* we have as many sockets as ldoms before moving to ldoms granularity
*/
if (nldoms >= jntasks &&
nsockets >= nldoms &&
bind_type & (CPU_BIND_TO_LDOMS | bind_mode_ldom)) {
hwtype = HWLOC_OBJ_NODE;
nobj = nldoms;
}
/*
* If not enough objects to do the job, revert to no affinity mode
*/
if (hwloc_compare_types(hwtype, HWLOC_OBJ_MACHINE) == 0) {
info("task/cgroup: task[%u] disabling affinity because of %s "
"granularity",taskid, hwloc_obj_type_string(hwtype));
if (job->cpu_bind_type & CPU_BIND_VERBOSE)
fprintf(stderr,"task/cgroup: task[%u] disabling "
"affinity because of %s granularity\n",
taskid, hwloc_obj_type_string(hwtype));
} else if ((hwloc_compare_types(hwtype, HWLOC_OBJ_CORE) >= 0) &&
(nobj < jnpus)) {
info("task/cgroup: task[%u] not enough %s objects (%d < %d), "
"disabling affinity",
taskid, hwloc_obj_type_string(hwtype), nobj, jnpus);
if (job->cpu_bind_type & CPU_BIND_VERBOSE)
fprintf(stderr, "task/cgroup: task[%u] not enough %s "
"objects (%d < %d), disabling affinity\n",
taskid, hwloc_obj_type_string(hwtype),
nobj, jnpus);
} else if (bind_type & bind_mode) {
/*
* Explicit binding mode specified by the user
* Bind the taskid in accordance with the specified mode
*/
obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_MACHINE, 0);
if (bind_verbose) {
info("task/cgroup: task[%u] is requesting "
"explicit binding mode", taskid);
}
_get_sched_cpuset(topology, hwtype, req_hwtype, &ts, job);
tssize = sizeof(cpu_set_t);
fstatus = SLURM_SUCCESS;
_validate_mask(taskid, obj, &ts);
if ((rc = sched_setaffinity(pid, tssize, &ts))) {
error("task/cgroup: task[%u] unable to set "
"mask 0x%s", taskid,
task_cpuset_to_str(&ts, mstr));
error("sched_setaffinity rc = %d", rc);
fstatus = SLURM_ERROR;
} else if (bind_verbose) {
info("task/cgroup: task[%u] mask 0x%s",
taskid, task_cpuset_to_str(&ts, mstr));
}
task_slurm_chkaffinity(&ts, job, rc);
} else {
/*
* Bind the detected object to the taskid, respecting the
* granularity, using the designated or default distribution
* method (block or cyclic).
*/
char *str = NULL;
if (bind_verbose) {
info("task/cgroup: task[%u] using %s granularity dist %u",
taskid, hwloc_obj_type_string(hwtype),
job->task_dist);
}
/*
* See srun man page for detailed information on --distribution
* option.
*
* You can see the equivalent code for the
* task/affinity plugin in
* src/plugins/task/affinity/dist_tasks.c, around line 368
*/
switch (job->task_dist & SLURM_DIST_NODESOCKMASK) {
case SLURM_DIST_BLOCK_BLOCK:
case SLURM_DIST_CYCLIC_BLOCK:
case SLURM_DIST_PLANE:
/* tasks are distributed in blocks within a plane */
_task_cgroup_cpuset_dist_block(topology,
hwtype, req_hwtype,
nobj, job, bind_verbose, cpuset);
break;
case SLURM_DIST_ARBITRARY:
case SLURM_DIST_BLOCK:
case SLURM_DIST_CYCLIC:
case SLURM_DIST_UNKNOWN:
if (slurm_get_select_type_param()
& CR_CORE_DEFAULT_DIST_BLOCK) {
_task_cgroup_cpuset_dist_block(topology,
hwtype, req_hwtype,
nobj, job, bind_verbose, cpuset);
break;
}
/*
* We want to fall through here if we aren't doing a
* default dist block.
*/
default:
_task_cgroup_cpuset_dist_cyclic(topology,
hwtype, req_hwtype,
job, bind_verbose, cpuset);
break;
}
hwloc_bitmap_asprintf(&str, cpuset);
tssize = sizeof(cpu_set_t);
if (hwloc_cpuset_to_glibc_sched_affinity(topology, cpuset,
&ts, tssize) == 0) {
fstatus = SLURM_SUCCESS;
if ((rc = sched_setaffinity(pid, tssize, &ts))) {
error("task/cgroup: task[%u] unable to set "
"taskset '%s'", taskid, str);
fstatus = SLURM_ERROR;
} else if (bind_verbose) {
info("task/cgroup: task[%u] set taskset '%s'",
taskid, str);
}
task_slurm_chkaffinity(&ts, job, rc);
} else {
error("task/cgroup: task[%u] unable to build "
"taskset '%s'",taskid,str);
fstatus = SLURM_ERROR;
}
if (str)
free(str);
}
/* Destroy hwloc objects */
hwloc_bitmap_free(cpuset);
hwloc_topology_destroy(topology);
return fstatus;
#endif
}
