static void switch_set_index(hwloc_bitmap_t set, unsigned old_index, unsigned new_index)
{
if (hwloc_bitmap_isset(set, old_index)) {
hwloc_bitmap_clr(set, old_index);
hwloc_bitmap_set(set, new_index);
}
}
static int _task_cgroup_cpuset_dist_block(
hwloc_topology_t topology, hwloc_obj_type_t hwtype,
hwloc_obj_type_t req_hwtype, uint32_t nobj,
stepd_step_rec_t *job, int bind_verbose, hwloc_bitmap_t cpuset)
{
hwloc_obj_t obj;
uint32_t core_loop, ntskip, npdist;
uint32_t i, j, pfirst, plast;
uint32_t taskid = job->envtp->localid;
int hwdepth;
uint32_t npus, ncores, nsockets;
int spec_thread_cnt = 0;
bitstr_t *spec_threads = NULL;
uint32_t *thread_idx;
uint32_t core_idx;
bool core_fcyclic, core_block;
nsockets = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_SOCKET);
ncores = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_CORE);
npus = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_PU);
core_block = (job->task_dist & SLURM_DIST_COREMASK) ==
SLURM_DIST_COREBLOCK ? true : false;
core_fcyclic = (job->task_dist & SLURM_DIST_COREMASK) ==
SLURM_DIST_CORECFULL ? true : false;
thread_idx = xmalloc(ncores * sizeof(uint32_t));
if (bind_verbose) {
info("task/cgroup: task[%u] using block distribution, "
"task_dist 0x%x", taskid, job->task_dist);
}
if ((hwloc_compare_types(hwtype, HWLOC_OBJ_PU) == 0) && !core_block) {
thread_idx = xmalloc(ncores * sizeof(uint32_t));
ntskip = taskid;
npdist = job->cpus_per_task;
i = 0; j = 0;
core_idx = 0;
core_loop = 0;
while (i < ntskip + 1 && core_loop < npdist + 1) {
while ((core_idx < ncores) && (j < npdist)) {
obj = hwloc_get_obj_below_by_type(
topology, HWLOC_OBJ_CORE, core_idx,
hwtype, thread_idx[core_idx]);
if (obj != NULL) {
thread_idx[core_idx]++;
j++;
if (i == ntskip)
_add_hwloc_cpuset(hwtype,
req_hwtype, obj, taskid,
bind_verbose, cpuset);
if ((j < npdist) && core_fcyclic)
core_idx++;
} else {
core_idx++;
}
}
if (j == npdist) {
i++; j = 0;
core_idx++; // no validity check, handled by the while
core_loop = 0;
} else {
core_loop++;
core_idx = 0;
}
}
xfree(thread_idx);
/* should never happen in normal scenario */
if (core_loop > npdist) {
error("task/cgroup: task[%u] infinite loop broken while "
"trying to provision compute elements using %s",
taskid, format_task_dist_states(job->task_dist));
return XCGROUP_ERROR;
} else
return XCGROUP_SUCCESS;
}
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);
if ((job->job_core_spec != (uint16_t) NO_VAL) &&
(job->job_core_spec & CORE_SPEC_THREAD) &&
(job->job_core_spec != CORE_SPEC_THREAD) &&
(nsockets != 0)) {
/* Skip specialized threads as needed */
int i, t, c, s;
int cores = MAX(1, (ncores / nsockets));
int threads = npus / cores;
spec_thread_cnt = job->job_core_spec & (~CORE_SPEC_THREAD);
spec_threads = bit_alloc(npus);
for (t = threads - 1;
((t >= 0) && (spec_thread_cnt > 0)); t--) {
for (c = cores - 1;
((c >= 0) && (spec_thread_cnt > 0)); c--) {
for (s = nsockets - 1;
((s >= 0) && (spec_thread_cnt > 0)); s--) {
i = s * cores + c;
i = (i * threads) + t;
bit_set(spec_threads, i);
spec_thread_cnt--;
}
}
}
if (hwtype == HWLOC_OBJ_PU) {
for (i = 0; i <= pfirst && i < npus; i++) {
if (bit_test(spec_threads, i))
pfirst++;
};
}
}
for (i = pfirst; i <= plast && i < nobj ; i++) {
obj = hwloc_get_obj_by_depth(topology, hwdepth, (int)i);
_add_hwloc_cpuset(hwtype, req_hwtype, obj, taskid,
bind_verbose, cpuset);
}
if (spec_threads) {
for (i = 0; i < npus; i++) {
if (bit_test(spec_threads, i)) {
hwloc_bitmap_clr(cpuset, i);
}
};
FREE_NULL_BITMAP(spec_threads);
}
return XCGROUP_SUCCESS;
}
static int _task_cgroup_cpuset_dist_cyclic(
hwloc_topology_t topology, hwloc_obj_type_t hwtype,
hwloc_obj_type_t req_hwtype, stepd_step_rec_t *job, int bind_verbose,
hwloc_bitmap_t cpuset)
{
hwloc_obj_t obj;
uint32_t s_ix; /* socket index */
uint32_t *c_ixc; /* core index by socket (current taskid) */
uint32_t *c_ixn; /* core index by socket (next taskid) */
uint32_t *t_ix; /* thread index by core by socket */
uint32_t npus, ncores, nsockets;
uint32_t taskid = job->envtp->localid;
int spec_thread_cnt = 0;
bitstr_t *spec_threads = NULL;
uint32_t obj_idxs[3], nthreads, cps,
tpc, i, j, sock_loop, ntskip, npdist;;
bool core_cyclic, core_fcyclic, sock_fcyclic;
nsockets = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_SOCKET);
ncores = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_CORE);
nthreads = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_PU);
cps = ncores/nsockets;
tpc = nthreads/ncores;
sock_fcyclic = (job->task_dist & SLURM_DIST_SOCKMASK) ==
SLURM_DIST_SOCKCFULL ? true : false;
core_cyclic = (job->task_dist & SLURM_DIST_COREMASK) ==
SLURM_DIST_CORECYCLIC ? true : false;
core_fcyclic = (job->task_dist & SLURM_DIST_COREMASK) ==
SLURM_DIST_CORECFULL ? true : false;
if (bind_verbose) {
info("task/cgroup: task[%u] using %s distribution "
"(task_dist=0x%x)", taskid,
format_task_dist_states(job->task_dist), job->task_dist);
}
npus = (uint32_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_PU);
t_ix = xmalloc(ncores * sizeof(uint32_t));
c_ixc = xmalloc(nsockets * sizeof(uint32_t));
c_ixn = xmalloc(nsockets * sizeof(uint32_t));
if (hwloc_compare_types(hwtype, HWLOC_OBJ_CORE) >= 0) {
/* cores or threads granularity */
ntskip = taskid;
npdist = job->cpus_per_task;
} else {
/* sockets or ldoms granularity */
ntskip = taskid;
npdist = 1;
}
if ((job->job_core_spec != (uint16_t) NO_VAL) &&
(job->job_core_spec & CORE_SPEC_THREAD) &&
(job->job_core_spec != CORE_SPEC_THREAD)){
/* Skip specialized threads as needed */
int i, t, c, s;
int cores = ncores / nsockets;
int threads = npus / cores;
spec_thread_cnt = job->job_core_spec & (~CORE_SPEC_THREAD);
spec_threads = bit_alloc(npus);
for (t = threads - 1;
((t >= 0) && (spec_thread_cnt > 0)); t--) {
for (c = cores - 1;
((c >= 0) && (spec_thread_cnt > 0)); c--) {
for (s = nsockets - 1;
((s >= 0) && (spec_thread_cnt > 0)); s--) {
i = s * cores + c;
i = (i * threads) + t;
bit_set(spec_threads, i);
spec_thread_cnt--;
}
}
}
if (hwtype == HWLOC_OBJ_PU) {
for (i = 0; i <= ntskip && i < npus; i++) {
if (bit_test(spec_threads, i))
ntskip++;
};
}
}
/* skip objs for lower taskids, then add them to the
current task cpuset. To prevent infinite loop, check
that we do not loop more than npdist times around the available
sockets, which is the worst scenario we should afford here. */
i = j = s_ix = sock_loop = 0;
while (i < ntskip + 1 && (sock_loop/tpc) < npdist + 1) {
/* fill one or multiple sockets using block mode, unless
otherwise stated in the job->task_dist field */
while ((s_ix < nsockets) && (j < npdist)) {
obj = hwloc_get_obj_below_by_type(
topology, HWLOC_OBJ_SOCKET, s_ix,
hwtype, c_ixc[s_ix]);
if (obj != NULL) {
if (hwloc_compare_types(hwtype, HWLOC_OBJ_PU)
>= 0) {
/* granularity is thread */
obj_idxs[0]=s_ix;
obj_idxs[1]=c_ixc[s_ix];
obj_idxs[2]=t_ix[(s_ix*cps)+c_ixc[s_ix]];
obj = hwloc_get_obj_below_array_by_type(
topology, 3, obj_types, obj_idxs);
if (obj != NULL) {
t_ix[(s_ix*cps)+c_ixc[s_ix]]++;
j++;
if (i == ntskip)
_add_hwloc_cpuset(hwtype,
req_hwtype, obj, taskid,
bind_verbose, cpuset);
if (j < npdist) {
if (core_cyclic) {
c_ixn[s_ix] =
c_ixc[s_ix] + 1;
} else if (core_fcyclic){
c_ixc[s_ix]++;
c_ixn[s_ix] =
c_ixc[s_ix];
}
if (sock_fcyclic)
s_ix++;
}
} else {
c_ixc[s_ix]++;
if (c_ixc[s_ix] == cps)
s_ix++;
}
} else {
/* granularity is core or larger */
c_ixc[s_ix]++;
j++;
if (i == ntskip)
_add_hwloc_cpuset(hwtype,
req_hwtype, obj, taskid,
bind_verbose, cpuset);
if ((j < npdist) && (sock_fcyclic))
s_ix++;
}
} else
s_ix++;
}
/* if it succeeds, switch to the next task, starting
* with the next available socket, otherwise, loop back
* from the first socket trying to find available slots. */
if (j == npdist) {
i++;
j = 0;
s_ix++; // no validity check, handled by the while
sock_loop = 0;
} else {
sock_loop++;
s_ix = 0;
}
}
xfree(t_ix);
xfree(c_ixc);
xfree(c_ixn);
if (spec_threads) {
for (i = 0; i < npus; i++) {
if (bit_test(spec_threads, i)) {
hwloc_bitmap_clr(cpuset, i);
}
};
FREE_NULL_BITMAP(spec_threads);
}
/* should never happen in normal scenario */
if (sock_loop > npdist) {
error("task/cgroup: task[%u] infinite loop broken while trying "
"to provision compute elements using %s", taskid,
format_task_dist_states(job->task_dist));
return XCGROUP_ERROR;
} else
return XCGROUP_SUCCESS;
}
int main(void)
{
hwloc_bitmap_t set;
/* check an empty bitmap */
set = hwloc_bitmap_alloc();
assert(hwloc_bitmap_to_ulong(set) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
/* check a non-empty bitmap */
hwloc_bitmap_from_ith_ulong(set, 4, 0xff);
assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0xff);
assert(hwloc_bitmap_to_ulong(set) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
/* check a zeroed bitmap */
hwloc_bitmap_zero(set);
assert(hwloc_bitmap_to_ulong(set) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
hwloc_bitmap_free(set);
/* check a full bitmap */
set = hwloc_bitmap_alloc_full();
assert(hwloc_bitmap_to_ulong(set) == ~0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 0) == ~0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 1) == ~0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 23) == ~0UL);
/* check a almost full bitmap */
hwloc_bitmap_set_ith_ulong(set, 4, 0xff);
assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0xff);
assert(hwloc_bitmap_to_ulong(set) == ~0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 0) == ~0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 1) == ~0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 23) == ~0UL);
/* check a almost empty bitmap */
hwloc_bitmap_from_ith_ulong(set, 4, 0xff);
assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0xff);
assert(hwloc_bitmap_to_ulong(set) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
hwloc_bitmap_free(set);
/* check ranges */
set = hwloc_bitmap_alloc();
assert(hwloc_bitmap_weight(set) == 0);
/* 23-45 */
hwloc_bitmap_set_range(set, 23, 45);
assert(hwloc_bitmap_weight(set) == 23);
/* 23-45,78- */
hwloc_bitmap_set_range(set, 78, -1);
assert(hwloc_bitmap_weight(set) == -1);
/* 23- */
hwloc_bitmap_set_range(set, 44, 79);
assert(hwloc_bitmap_weight(set) == -1);
assert(hwloc_bitmap_first(set) == 23);
assert(!hwloc_bitmap_isfull(set));
/* 0- */
hwloc_bitmap_set_range(set, 0, 22);
assert(hwloc_bitmap_weight(set) == -1);
assert(hwloc_bitmap_isfull(set));
/* 0-34,57- */
hwloc_bitmap_clr_range(set, 35, 56);
assert(hwloc_bitmap_weight(set) == -1);
assert(!hwloc_bitmap_isfull(set));
/* 0-34,57 */
hwloc_bitmap_clr_range(set, 58, -1);
assert(hwloc_bitmap_weight(set) == 36);
assert(hwloc_bitmap_last(set) == 57);
assert(hwloc_bitmap_next(set, 34) == 57);
/* 0-34 */
hwloc_bitmap_clr(set, 57);
assert(hwloc_bitmap_weight(set) == 35);
assert(hwloc_bitmap_last(set) == 34);
/* empty */
hwloc_bitmap_clr_range(set, 0, 34);
assert(hwloc_bitmap_weight(set) == 0);
assert(hwloc_bitmap_first(set) == -1);
hwloc_bitmap_free(set);
return 0;
}
static int
hwloc_look_kstat(struct hwloc_topology *topology)
{
/* FIXME this assumes that all packages are identical */
char *CPUType = hwloc_solaris_get_chip_type();
char *CPUModel = hwloc_solaris_get_chip_model();
kstat_ctl_t *kc = kstat_open();
kstat_t *ksp;
kstat_named_t *stat;
unsigned look_cores = 1, look_chips = 1;
unsigned Pproc_max = 0;
unsigned Pproc_alloc = 256;
struct hwloc_solaris_Pproc {
unsigned Lpkg, Ppkg, Lcore, Lproc;
} * Pproc = malloc(Pproc_alloc * sizeof(*Pproc));
unsigned Lproc_num = 0;
unsigned Lproc_alloc = 256;
struct hwloc_solaris_Lproc {
unsigned Pproc;
} * Lproc = malloc(Lproc_alloc * sizeof(*Lproc));
unsigned Lcore_num = 0;
unsigned Lcore_alloc = 256;
struct hwloc_solaris_Lcore {
unsigned Pcore, Ppkg;
} * Lcore = malloc(Lcore_alloc * sizeof(*Lcore));
unsigned Lpkg_num = 0;
unsigned Lpkg_alloc = 256;
struct hwloc_solaris_Lpkg {
unsigned Ppkg;
} * Lpkg = malloc(Lpkg_alloc * sizeof(*Lpkg));
unsigned pkgid, coreid, cpuid;
unsigned i;
for (i = 0; i < Pproc_alloc; i++) {
Pproc[i].Lproc = -1;
Pproc[i].Lpkg = -1;
Pproc[i].Ppkg = -1;
Pproc[i].Lcore = -1;
}
if (!kc) {
hwloc_debug("kstat_open failed: %s\n", strerror(errno));
free(Pproc);
free(Lproc);
free(Lcore);
free(Lpkg);
return 0;
}
for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next)
{
if (strncmp("cpu_info", ksp->ks_module, 8))
continue;
cpuid = ksp->ks_instance;
if (kstat_read(kc, ksp, NULL) == -1)
{
fprintf(stderr, "kstat_read failed for CPU%u: %s\n", cpuid, strerror(errno));
continue;
}
hwloc_debug("cpu%u\n", cpuid);
if (cpuid >= Pproc_alloc) {
struct hwloc_solaris_Pproc *tmp = realloc(Pproc, 2*Pproc_alloc * sizeof(*Pproc));
if (!tmp)
goto err;
Pproc = tmp;
Pproc_alloc *= 2;
for(i = Pproc_alloc/2; i < Pproc_alloc; i++) {
Pproc[i].Lproc = -1;
Pproc[i].Lpkg = -1;
Pproc[i].Ppkg = -1;
Pproc[i].Lcore = -1;
}
}
Pproc[cpuid].Lproc = Lproc_num;
if (Lproc_num >= Lproc_alloc) {
struct hwloc_solaris_Lproc *tmp = realloc(Lproc, 2*Lproc_alloc * sizeof(*Lproc));
if (!tmp)
goto err;
Lproc = tmp;
Lproc_alloc *= 2;
}
Lproc[Lproc_num].Pproc = cpuid;
Lproc_num++;
if (cpuid >= Pproc_max)
Pproc_max = cpuid + 1;
stat = (kstat_named_t *) kstat_data_lookup(ksp, "state");
if (!stat)
hwloc_debug("could not read state for CPU%u: %s\n", cpuid, strerror(errno));
else if (stat->data_type != KSTAT_DATA_CHAR)
hwloc_debug("unknown kstat type %d for cpu state\n", stat->data_type);
else
{
hwloc_debug("cpu%u's state is %s\n", cpuid, stat->value.c);
if (strcmp(stat->value.c, "on-line"))
/* not online */
hwloc_bitmap_clr(topology->levels[0][0]->online_cpuset, cpuid);
}
if (look_chips) do {
/* Get Chip ID */
stat = (kstat_named_t *) kstat_data_lookup(ksp, "chip_id");
if (!stat)
{
if (Lpkg_num)
fprintf(stderr, "could not read package id for CPU%u: %s\n", cpuid, strerror(errno));
else
hwloc_debug("could not read package id for CPU%u: %s\n", cpuid, strerror(errno));
look_chips = 0;
continue;
}
switch (stat->data_type) {
case KSTAT_DATA_INT32:
pkgid = stat->value.i32;
break;
case KSTAT_DATA_UINT32:
pkgid = stat->value.ui32;
break;
#ifdef _INT64_TYPE
case KSTAT_DATA_UINT64:
pkgid = stat->value.ui64;
break;
case KSTAT_DATA_INT64:
pkgid = stat->value.i64;
break;
#endif
default:
fprintf(stderr, "chip_id type %d unknown\n", stat->data_type);
look_chips = 0;
continue;
}
Pproc[cpuid].Ppkg = pkgid;
for (i = 0; i < Lpkg_num; i++)
if (pkgid == Lpkg[i].Ppkg)
break;
Pproc[cpuid].Lpkg = i;
hwloc_debug("%u on package %u (%u)\n", cpuid, i, pkgid);
if (i == Lpkg_num) {
if (Lpkg_num == Lpkg_alloc) {
struct hwloc_solaris_Lpkg *tmp = realloc(Lpkg, 2*Lpkg_alloc * sizeof(*Lpkg));
if (!tmp)
goto err;
Lpkg = tmp;
Lpkg_alloc *= 2;
}
Lpkg[Lpkg_num++].Ppkg = pkgid;
}
} while(0);
if (look_cores) do {
/* Get Core ID */
stat = (kstat_named_t *) kstat_data_lookup(ksp, "core_id");
if (!stat)
{
if (Lcore_num)
fprintf(stderr, "could not read core id for CPU%u: %s\n", cpuid, strerror(errno));
else
hwloc_debug("could not read core id for CPU%u: %s\n", cpuid, strerror(errno));
look_cores = 0;
continue;
}
switch (stat->data_type) {
case KSTAT_DATA_INT32:
coreid = stat->value.i32;
break;
case KSTAT_DATA_UINT32:
coreid = stat->value.ui32;
break;
#ifdef _INT64_TYPE
case KSTAT_DATA_UINT64:
coreid = stat->value.ui64;
break;
case KSTAT_DATA_INT64:
coreid = stat->value.i64;
break;
#endif
default:
fprintf(stderr, "core_id type %d unknown\n", stat->data_type);
look_cores = 0;
continue;
}
for (i = 0; i < Lcore_num; i++)
if (coreid == Lcore[i].Pcore && Pproc[cpuid].Ppkg == Lcore[i].Ppkg)
break;
Pproc[cpuid].Lcore = i;
hwloc_debug("%u on core %u (%u)\n", cpuid, i, coreid);
if (i == Lcore_num) {
if (Lcore_num == Lcore_alloc) {
struct hwloc_solaris_Lcore *tmp = realloc(Lcore, 2*Lcore_alloc * sizeof(*Lcore));
if (!tmp)
goto err;
Lcore = tmp;
Lcore_alloc *= 2;
}
Lcore[Lcore_num].Ppkg = Pproc[cpuid].Ppkg;
Lcore[Lcore_num++].Pcore = coreid;
}
} while(0);
/* Note: there is also clog_id for the Thread ID (not unique) and
* pkg_core_id for the core ID (not unique). They are not useful to us
* however. */
}
if (look_chips) {
struct hwloc_obj *obj;
unsigned j,k;
hwloc_debug("%d Packages\n", Lpkg_num);
for (j = 0; j < Lpkg_num; j++) {
obj = hwloc_alloc_setup_object(HWLOC_OBJ_PACKAGE, Lpkg[j].Ppkg);
if (CPUType)
hwloc_obj_add_info(obj, "CPUType", CPUType);
if (CPUModel)
hwloc_obj_add_info(obj, "CPUModel", CPUModel);
obj->cpuset = hwloc_bitmap_alloc();
for(k=0; k<Pproc_max; k++)
if (Pproc[k].Lpkg == j)
hwloc_bitmap_set(obj->cpuset, k);
hwloc_debug_1arg_bitmap("Package %d has cpuset %s\n", j, obj->cpuset);
hwloc_insert_object_by_cpuset(topology, obj);
}
hwloc_debug("%s", "\n");
}
if (look_cores) {
struct hwloc_obj *obj;
unsigned j,k;
hwloc_debug("%d Cores\n", Lcore_num);
for (j = 0; j < Lcore_num; j++) {
obj = hwloc_alloc_setup_object(HWLOC_OBJ_CORE, Lcore[j].Pcore);
obj->cpuset = hwloc_bitmap_alloc();
for(k=0; k<Pproc_max; k++)
if (Pproc[k].Lcore == j)
hwloc_bitmap_set(obj->cpuset, k);
hwloc_debug_1arg_bitmap("Core %d has cpuset %s\n", j, obj->cpuset);
hwloc_insert_object_by_cpuset(topology, obj);
}
hwloc_debug("%s", "\n");
}
if (Lproc_num) {
struct hwloc_obj *obj;
unsigned j,k;
hwloc_debug("%d PUs\n", Lproc_num);
for (j = 0; j < Lproc_num; j++) {
obj = hwloc_alloc_setup_object(HWLOC_OBJ_PU, Lproc[j].Pproc);
obj->cpuset = hwloc_bitmap_alloc();
for(k=0; k<Pproc_max; k++)
if (Pproc[k].Lproc == j)
hwloc_bitmap_set(obj->cpuset, k);
hwloc_debug_1arg_bitmap("PU %d has cpuset %s\n", j, obj->cpuset);
hwloc_insert_object_by_cpuset(topology, obj);
}
hwloc_debug("%s", "\n");
}
kstat_close(kc);
free(Pproc);
free(Lproc);
free(Lcore);
free(Lpkg);
return Lproc_num > 0;
err:
kstat_close(kc);
free(Pproc);
free(Lproc);
free(Lcore);
free(Lpkg);
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 int _task_cgroup_cpuset_dist_cyclic(
hwloc_topology_t topology, hwloc_obj_type_t hwtype,
hwloc_obj_type_t req_hwtype, stepd_step_rec_t *job, int bind_verbose,
hwloc_bitmap_t cpuset)
{
hwloc_obj_t obj;
uint32_t s_ix; /* socket index */
uint32_t *c_ixc; /* core index by socket (current taskid) */
uint32_t *c_ixn; /* core index by socket (next taskid) */
uint32_t *t_ix; /* thread index by core by socket */
uint16_t npus = 0, nboards = 0, nthreads = 0, ncores = 0, nsockets = 0;
uint32_t taskid = job->envtp->localid;
int spec_thread_cnt = 0;
bitstr_t *spec_threads = NULL;
uint32_t obj_idxs[3], cps, tpc, i, j, sock_loop, ntskip, npdist;
bool core_cyclic, core_fcyclic, sock_fcyclic;
bool hwloc_success = true;
/*
* We can't trust the slurmd_conf_t *conf here as we need actual
* hardware instead of whatever is possibly configured. So we need to
* look it up again.
*/
if (get_cpuinfo(&npus, &nboards, &nsockets, &ncores, &nthreads,
NULL, NULL, NULL) != SLURM_SUCCESS) {
/*
* Fall back to use allocated resources, but this may result
* in incorrect layout due to a uneven task distribution
* (e.g. 4 cores on socket 0 and 3 cores on socket 1)
*/
nsockets = (uint16_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_SOCKET);
ncores = (uint16_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_CORE);
nthreads = (uint16_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_PU);
npus = (uint16_t) hwloc_get_nbobjs_by_type(topology,
HWLOC_OBJ_PU);
} else {
/* Translate cores-per-socket to total core count, etc. */
nsockets *= nboards;
ncores *= nsockets;
nthreads *= ncores;
}
if ((nsockets == 0) || (ncores == 0))
return XCGROUP_ERROR;
cps = (ncores + nsockets - 1) / nsockets;
tpc = (nthreads + ncores - 1) / ncores;
sock_fcyclic = (job->task_dist & SLURM_DIST_SOCKMASK) ==
SLURM_DIST_SOCKCFULL ? true : false;
core_cyclic = (job->task_dist & SLURM_DIST_COREMASK) ==
SLURM_DIST_CORECYCLIC ? true : false;
core_fcyclic = (job->task_dist & SLURM_DIST_COREMASK) ==
SLURM_DIST_CORECFULL ? true : false;
if (bind_verbose) {
info("task/cgroup: task[%u] using %s distribution "
"(task_dist=0x%x)", taskid,
format_task_dist_states(job->task_dist), job->task_dist);
}
t_ix = xmalloc(ncores * sizeof(uint32_t));
c_ixc = xmalloc(nsockets * sizeof(uint32_t));
c_ixn = xmalloc(nsockets * sizeof(uint32_t));
if (hwloc_compare_types(hwtype, HWLOC_OBJ_CORE) >= 0) {
/* cores or threads granularity */
ntskip = taskid;
npdist = job->cpus_per_task;
} else {
/* sockets or ldoms granularity */
ntskip = taskid;
npdist = 1;
}
if ((job->job_core_spec != NO_VAL16) &&
(job->job_core_spec & CORE_SPEC_THREAD) &&
(job->job_core_spec != CORE_SPEC_THREAD)) {
/* Skip specialized threads as needed */
int i, t, c, s;
int cores = (ncores + nsockets - 1) / nsockets;
int threads = (npus + cores - 1) / cores;
spec_thread_cnt = job->job_core_spec & (~CORE_SPEC_THREAD);
spec_threads = bit_alloc(npus);
for (t = threads - 1;
((t >= 0) && (spec_thread_cnt > 0)); t--) {
for (c = cores - 1;
((c >= 0) && (spec_thread_cnt > 0)); c--) {
for (s = nsockets - 1;
((s >= 0) && (spec_thread_cnt > 0)); s--) {
i = s * cores + c;
i = (i * threads) + t;
bit_set(spec_threads, i);
spec_thread_cnt--;
}
}
}
if (hwtype == HWLOC_OBJ_PU) {
for (i = 0; i <= ntskip && i < npus; i++) {
if (bit_test(spec_threads, i))
ntskip++;
};
}
}
/* skip objs for lower taskids, then add them to the
current task cpuset. To prevent infinite loop, check
that we do not loop more than npdist times around the available
sockets, which is the worst scenario we should afford here. */
i = j = s_ix = sock_loop = 0;
while (i < ntskip + 1 && (sock_loop/tpc) < npdist + 1) {
/* fill one or multiple sockets using block mode, unless
otherwise stated in the job->task_dist field */
while ((s_ix < nsockets) && (j < npdist)) {
obj = hwloc_get_obj_below_by_type(
topology, HWLOC_OBJ_SOCKET, s_ix,
hwtype, c_ixc[s_ix]);
if ((obj == NULL) && (s_ix == 0) && (c_ixc[s_ix] == 0))
hwloc_success = false; /* Complete failure */
if ((obj != NULL) &&
(hwloc_bitmap_first(obj->allowed_cpuset) != -1)) {
if (hwloc_compare_types(hwtype, HWLOC_OBJ_PU)
>= 0) {
/* granularity is thread */
obj_idxs[0]=s_ix;
obj_idxs[1]=c_ixc[s_ix];
obj_idxs[2]=t_ix[(s_ix*cps)+c_ixc[s_ix]];
obj = hwloc_get_obj_below_array_by_type(
topology, 3, obj_types, obj_idxs);
if ((obj != NULL) &&
(hwloc_bitmap_first(
obj->allowed_cpuset) != -1)) {
t_ix[(s_ix*cps)+c_ixc[s_ix]]++;
j++;
if (i == ntskip)
_add_hwloc_cpuset(hwtype,
req_hwtype, obj, taskid,
bind_verbose, cpuset);
if (j < npdist) {
if (core_cyclic) {
c_ixn[s_ix] =
c_ixc[s_ix] + 1;
} else if (core_fcyclic){
c_ixc[s_ix]++;
c_ixn[s_ix] =
c_ixc[s_ix];
}
if (sock_fcyclic)
s_ix++;
}
} else {
c_ixc[s_ix]++;
if (c_ixc[s_ix] == cps)
s_ix++;
}
} else {
/* granularity is core or larger */
c_ixc[s_ix]++;
j++;
if (i == ntskip)
_add_hwloc_cpuset(hwtype,
req_hwtype, obj, taskid,
bind_verbose, cpuset);
if ((j < npdist) && (sock_fcyclic))
s_ix++;
}
} else
s_ix++;
}
/* if it succeeds, switch to the next task, starting
* with the next available socket, otherwise, loop back
* from the first socket trying to find available slots. */
if (j == npdist) {
i++;
j = 0;
s_ix++; // no validity check, handled by the while
sock_loop = 0;
} else {
sock_loop++;
s_ix = 0;
}
}
xfree(t_ix);
xfree(c_ixc);
xfree(c_ixn);
if (spec_threads) {
for (i = 0; i < npus; i++) {
if (bit_test(spec_threads, i)) {
hwloc_bitmap_clr(cpuset, i);
}
};
FREE_NULL_BITMAP(spec_threads);
}
/* should never happen in normal scenario */
if ((sock_loop > npdist) && !hwloc_success) {
/* hwloc_get_obj_below_by_type() fails if no CPU set
* configured, see hwloc documentation for details */
error("task/cgroup: hwloc_get_obj_below_by_type() failing, "
"task/affinity plugin may be required to address bug "
"fixed in HWLOC version 1.11.5");
return XCGROUP_ERROR;
} else if (sock_loop > npdist) {
char buf[128] = "";
hwloc_bitmap_snprintf(buf, sizeof(buf), cpuset);
error("task/cgroup: task[%u] infinite loop broken while trying "
"to provision compute elements using %s (bitmap:%s)",
taskid, format_task_dist_states(job->task_dist), buf);
return XCGROUP_ERROR;
} else
return XCGROUP_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;
}
