PASTIX_INT sopalin_bindthread(PASTIX_INT cpu)
{
#ifdef MARCEL
{
marcel_vpset_t vpset = MARCEL_VPSET_ZERO;
marcel_vpset_vp(&vpset, cpu);
marcel_apply_vpset(&vpset);
}
#else /* Dans les autres cas on se preoccupe de l'archi */
#ifdef WITH_HWLOC
{
hwloc_topology_t topology; /* Topology object */
hwloc_obj_t obj; /* Hwloc object */
hwloc_cpuset_t cpuset; /* HwLoc cpuset */
/* Allocate and initialize topology object. */
hwloc_topology_init(&topology);
/* Perform the topology detection. */
hwloc_topology_load(topology);
/* Get last one. */
obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, cpu);
if (!obj)
return 0;
/* Get a copy of its cpuset that we may modify. */
/* Get only one logical processor (in case the core is SMT/hyperthreaded). */
#if !defined(HWLOC_BITMAP_H)
cpuset = hwloc_cpuset_dup(obj->cpuset);
hwloc_cpuset_singlify(cpuset);
#else
cpuset = hwloc_bitmap_dup(obj->cpuset);
hwloc_bitmap_singlify(cpuset);
#endif
/* And try to bind ourself there. */
if (hwloc_set_cpubind(topology, cpuset, HWLOC_CPUBIND_THREAD)) {
char *str = NULL;
#if !defined(HWLOC_BITMAP_H)
hwloc_cpuset_asprintf(&str, obj->cpuset);
#else
hwloc_bitmap_asprintf(&str, obj->cpuset);
#endif
printf("Couldn't bind to cpuset %s\n", str);
free(str);
}
/* Get the number at Proc level */
cpu = obj->children[0]->os_index;
/* Free our cpuset copy */
#if !defined(HWLOC_BITMAP_H)
hwloc_cpuset_free(cpuset);
#else
hwloc_bitmap_free(cpuset);
#endif
/* Destroy topology object. */
hwloc_topology_destroy(topology);
}
#else /* WITH_HWLOC */
#ifdef X_ARCHpower_ibm_aix
{
tid_t self_ktid = thread_self ();
bindprocessor(BINDTHREAD, self_ktid, cpu);
}
#elif (defined X_ARCHalpha_compaq_osf1)
{
bind_to_cpu_id(getpid(), cpu, 0);
}
#elif (defined X_ARCHi686_pc_linux)
#ifndef X_ARCHi686_mac
{
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(cpu, &mask);
#ifdef HAVE_OLD_SCHED_SETAFFINITY
if(sched_setaffinity(0,&mask) < 0)
#else /* HAVE_OLD_SCHED_SETAFFINITY */
if(sched_setaffinity(0,sizeof(mask),&mask) < 0)
#endif /* HAVE_OLD_SCHED_SETAFFINITY */
{
perror("sched_setaffinity");
EXIT(MOD_SOPALIN, INTERNAL_ERR);
}
}
#else /* X_ARCHi686_mac */
{
thread_affinity_policy_data_t ap;
int ret;
ap.affinity_tag = 1; /* non-null affinity tag */
ret = thread_policy_set(
mach_thread_self(),
THREAD_AFFINITY_POLICY,
(integer_t*) &ap,
THREAD_AFFINITY_POLICY_COUNT
);
if(ret != 0)
{
perror("thread_policy_set");
EXIT(MOD_SOPALIN, INTERNAL_ERR);
}
}
#endif /* X_ARCHi686_mac */
#endif /* X_ACHIxxx */
#endif /* WITH_HWLOC */
#endif /* MARCEL */
return cpu;
}
/* user to have to play with the cgroup hierarchy to modify it */
extern int task_cgroup_cpuset_set_task_affinity(slurmd_job_t *job)
{
int fstatus = SLURM_ERROR;
#ifndef HAVE_HWLOC
error("task/cgroup: plugin not compiled with hwloc support, "
"skipping affinity.");
return fstatus;
#else
uint32_t i;
uint32_t nldoms;
uint32_t nsockets;
uint32_t ncores;
uint32_t npus;
uint32_t nobj;
uint32_t pfirst,plast;
uint32_t taskid = job->envtp->localid;
uint32_t jntasks = job->node_tasks;
uint32_t jnpus = jntasks * job->cpus_per_task;
pid_t pid = job->envtp->task_pid;
cpu_bind_type_t bind_type;
int verbose;
hwloc_topology_t topology;
#if HWLOC_API_VERSION <= 0x00010000
hwloc_cpuset_t cpuset,ct;
#else
hwloc_bitmap_t cpuset,ct;
#endif
hwloc_obj_t obj;
struct hwloc_obj *pobj;
hwloc_obj_type_t hwtype;
hwloc_obj_type_t req_hwtype;
int hwdepth;
size_t tssize;
cpu_set_t ts;
bind_type = job->cpu_bind_type ;
if (conf->task_plugin_param & CPU_BIND_VERBOSE ||
bind_type & CPU_BIND_VERBOSE)
verbose = 1 ;
if (bind_type & CPU_BIND_NONE) {
if (verbose)
info("task/cgroup: task[%u] is requesting no affinity",
taskid);
return 0;
} else if (bind_type & CPU_BIND_TO_THREADS) {
if (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 (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 (verbose)
info("task/cgroup: task[%u] is requesting "
"socket level binding",taskid);
req_hwtype = HWLOC_OBJ_SOCKET;
} else if (bind_type & CPU_BIND_TO_LDOMS) {
if (verbose)
info("task/cgroup: task[%u] is requesting "
"ldom level binding",taskid);
req_hwtype = HWLOC_OBJ_NODE;
} else {
if (verbose)
info("task/cgroup: task[%u] using core level binding"
" by default",taskid);
req_hwtype = HWLOC_OBJ_CORE;
}
/* Allocate and initialize hwloc objects */
hwloc_topology_init(&topology);
#if HWLOC_API_VERSION <= 0x00010000
cpuset = hwloc_cpuset_alloc() ;
#else
cpuset = hwloc_bitmap_alloc() ;
#endif
/*
* 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.)
*/
hwloc_topology_load(topology);
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,
HWLOC_OBJ_SOCKET);
nldoms = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_NODE);
hwtype = HWLOC_OBJ_MACHINE;
nobj = 1;
if (npus >= jnpus || bind_type & CPU_BIND_TO_THREADS) {
hwtype = HWLOC_OBJ_PU;
nobj = npus;
}
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 = HWLOC_OBJ_SOCKET;
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) {
hwtype = HWLOC_OBJ_NODE;
nobj = nldoms;
}
/*
* Perform a block binding on the detected object respecting the
* granularity.
* 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));
} else if (hwloc_compare_types(hwtype,HWLOC_OBJ_CORE) >= 0 &&
jnpus > nobj) {
info("task/cgroup: task[%u] not enough %s objects, disabling "
"affinity",taskid,hwloc_obj_type_string(hwtype));
} else {
if (verbose) {
info("task/cgroup: task[%u] using %s granularity",
taskid,hwloc_obj_type_string(hwtype));
}
if (hwloc_compare_types(hwtype,HWLOC_OBJ_CORE) >= 0) {
/* cores or threads granularity */
pfirst = taskid * job->cpus_per_task ;
plast = pfirst + job->cpus_per_task - 1;
} else {
/* sockets or ldoms granularity */
pfirst = taskid;
plast = pfirst;
}
hwdepth = hwloc_get_type_depth(topology,hwtype);
for (i = pfirst; i <= plast && i < nobj ; i++) {
obj = hwloc_get_obj_by_depth(topology,hwdepth,(int)i);
/* if requested binding overlap the granularity */
/* use the ancestor cpuset instead of the object one */
if (hwloc_compare_types(hwtype,req_hwtype) > 0) {
/* Get the parent object of req_hwtype or the */
/* one just above if not found (meaning of >0)*/
/* (useful for ldoms binding with !NUMA nodes)*/
pobj = obj->parent;
while (pobj != NULL &&
hwloc_compare_types(pobj->type,
req_hwtype) > 0)
pobj = pobj->parent;
if (pobj != NULL) {
if (verbose)
info("task/cgroup: task[%u] "
"higher level %s found",
taskid,
hwloc_obj_type_string(
pobj->type));
#if HWLOC_API_VERSION <= 0x00010000
ct = hwloc_cpuset_dup(pobj->
allowed_cpuset);
hwloc_cpuset_or(cpuset,cpuset,ct);
hwloc_cpuset_free(ct);
#else
ct = hwloc_bitmap_dup(pobj->
allowed_cpuset);
hwloc_bitmap_or(cpuset,cpuset,ct);
hwloc_bitmap_free(ct);
#endif
} else {
/* should not be executed */
if (verbose)
info("task/cgroup: task[%u] "
"no higher level found",
taskid);
#if HWLOC_API_VERSION <= 0x00010000
ct = hwloc_cpuset_dup(obj->
allowed_cpuset);
hwloc_cpuset_or(cpuset,cpuset,ct);
hwloc_cpuset_free(ct);
#else
ct = hwloc_bitmap_dup(obj->
allowed_cpuset);
hwloc_bitmap_or(cpuset,cpuset,ct);
hwloc_bitmap_free(ct);
#endif
}
} else {
#if HWLOC_API_VERSION <= 0x00010000
ct = hwloc_cpuset_dup(obj->allowed_cpuset);
hwloc_cpuset_or(cpuset,cpuset,ct);
hwloc_cpuset_free(ct);
#else
ct = hwloc_bitmap_dup(obj->allowed_cpuset);
hwloc_bitmap_or(cpuset,cpuset,ct);
hwloc_bitmap_free(ct);
#endif
}
}
char *str;
#if HWLOC_API_VERSION <= 0x00010000
hwloc_cpuset_asprintf(&str,cpuset);
#else
hwloc_bitmap_asprintf(&str,cpuset);
#endif
tssize = sizeof(cpu_set_t);
if (hwloc_cpuset_to_glibc_sched_affinity(topology,cpuset,
&ts,tssize) == 0) {
fstatus = SLURM_SUCCESS;
if (sched_setaffinity(pid,tssize,&ts)) {
error("task/cgroup: task[%u] unable to set "
"taskset '%s'",taskid,str);
fstatus = SLURM_ERROR;
} else if (verbose) {
info("task/cgroup: task[%u] taskset '%s' is set"
,taskid,str);
}
} else {
error("task/cgroup: task[%u] unable to build "
"taskset '%s'",taskid,str);
fstatus = SLURM_ERROR;
}
free(str);
}
/* Destroy hwloc objects */
#if HWLOC_API_VERSION <= 0x00010000
hwloc_cpuset_free(cpuset);
#else
hwloc_bitmap_free(cpuset);
#endif
hwloc_topology_destroy(topology);
return fstatus;
#endif
}
