int main(int argc, char **argv)
{
struct prog_args pargs = {0};
argp_parse(&argp, argc, argv, 0, 0, &pargs);
switch (pargs.mode) {
case (PROV_MODE_PID):
return prov_pid(pargs.pid, &pargs);
break;
case (PROV_MODE_CMD):
printf("Launching programs not supported yet\n");
printf("Would have launched %s with args:", pargs.cmd);
if (pargs.cmd_args)
for (int i = 0; pargs.cmd_args[i]; i++)
printf(" %s", pargs.cmd_args[i]);
printf("\n");
return 0;
break;
case (PROV_MODE_SHOW):
printf("Show mode not supported yet, using ghetto interface\n\n");
sys_provision(-1, 0, 0);
return 0;
break;
default:
return -1;
}
}
static void run_process_and_wait(int argc, const char * const *argv,
const struct core_set *cores)
{
int pid, status;
size_t max_cores = ros_total_cores();
struct core_set pvcores;
pid = sys_proc_create(argv[0], strlen(argv[0]), argv, NULL, 0);
if (pid < 0) {
perror(argv[0]);
exit(1);
}
ros_get_low_latency_core_set(&pvcores);
ros_not_core_set(&pvcores);
ros_and_core_sets(&pvcores, cores);
for (size_t i = 0; i < max_cores; i++) {
if (ros_get_bit(&pvcores, i)) {
if (sys_provision(pid, RES_CORES, i)) {
fprintf(stderr,
"Unable to provision CPU %lu to PID %d: cmd='%s'\n",
i, pid, argv[0]);
exit(1);
}
}
}
sys_proc_run(pid);
waitpid(pid, &status, 0);
}
/* Used by both -p and -c modes (-c will use it after creating pid) */
static int prov_pid(pid_t pid, struct prog_args *pargs)
{
unsigned int kernel_res_type;
int retval;
switch (pargs->res_type) {
case ('c'):
if (pargs->max) {
/* TODO: don't guess the LL/CG layout and num pcores */
#if 1
for (int i = 1; i < max_vcores() + 1; i++) {
if ((retval = sys_provision(pid, RES_CORES, i))) {
perror("Failed max provisioning");
return retval;
}
}
#else
/* To force a vcore shuffle / least optimal ordering, change
* the if 1 to 0. Normally, we provision out in a predictable,
* VCn->PCn+1 ordering. This splits the odd and even VCs
* across sockets on a 32 PC machine (c89). This is only for
* perf debugging, when using the lockprov.sh script. */
retval = 0;
retval |= sys_provision(pid, RES_CORES, 1);
retval |= sys_provision(pid, RES_CORES, 16);
retval |= sys_provision(pid, RES_CORES, 2);
retval |= sys_provision(pid, RES_CORES, 17);
retval |= sys_provision(pid, RES_CORES, 3);
retval |= sys_provision(pid, RES_CORES, 18);
retval |= sys_provision(pid, RES_CORES, 4);
retval |= sys_provision(pid, RES_CORES, 19);
retval |= sys_provision(pid, RES_CORES, 5);
retval |= sys_provision(pid, RES_CORES, 20);
retval |= sys_provision(pid, RES_CORES, 6);
retval |= sys_provision(pid, RES_CORES, 21);
retval |= sys_provision(pid, RES_CORES, 7);
retval |= sys_provision(pid, RES_CORES, 22);
retval |= sys_provision(pid, RES_CORES, 8);
retval |= sys_provision(pid, RES_CORES, 23);
retval |= sys_provision(pid, RES_CORES, 9);
retval |= sys_provision(pid, RES_CORES, 24);
retval |= sys_provision(pid, RES_CORES, 10);
retval |= sys_provision(pid, RES_CORES, 25);
retval |= sys_provision(pid, RES_CORES, 11);
retval |= sys_provision(pid, RES_CORES, 26);
retval |= sys_provision(pid, RES_CORES, 12);
retval |= sys_provision(pid, RES_CORES, 27);
retval |= sys_provision(pid, RES_CORES, 13);
retval |= sys_provision(pid, RES_CORES, 28);
retval |= sys_provision(pid, RES_CORES, 14);
retval |= sys_provision(pid, RES_CORES, 29);
retval |= sys_provision(pid, RES_CORES, 15);
retval |= sys_provision(pid, RES_CORES, 31);
retval |= sys_provision(pid, RES_CORES, 30);
return retval;
#endif
} else {
if ((retval = sys_provision(pid, RES_CORES, pargs->res_val))) {
perror("Failed single provision");
return retval;
}
}
kernel_res_type = RES_CORES;
break;
case ('m'):
printf("Provisioning memory is not supported yet\n");
return -1;
break;
default:
if (!pargs->res_type)
printf("No resource type selected. Use -t\n");
else
printf("Unsupported resource type %c\n", pargs->res_type);
return -1;
}
sys_poke_ksched(pid, kernel_res_type);
return 0;
}
