void accalt_ult_join(ACCALT_ult *ult) {
#ifdef ARGOBOTS
ABT_thread_free(ult);
#endif
#ifdef MASSIVETHREADS
myth_join(*ult, NULL);
#endif
#ifdef QTHREADS
qthread_readFF(NULL, ult);
#endif
}
void thread_create(void *arg)
{
int rank, i, ret;
ABT_thread self;
ABT_thread_id id;
ABT_pool my_pool;
ABT_thread *threads;
assert((size_t)arg == 0);
ret = ABT_xstream_self_rank(&rank);
ABT_TEST_ERROR(ret, "ABT_xstream_self_rank");
ret = ABT_thread_self(&self);
ABT_TEST_ERROR(ret, "ABT_thread_self");
ret = ABT_thread_get_id(self, &id);
ABT_TEST_ERROR(ret, "ABT_thread_get_id");
ret = ABT_thread_get_last_pool(self, &my_pool);
ABT_TEST_ERROR(ret, "ABT_thread_get_last_pool");
threads = (ABT_thread *)malloc(num_threads * sizeof(ABT_thread));
/* Create ULTs */
for (i = 0; i < num_threads; i++) {
ret = ABT_thread_create(my_pool, thread_func, (void *)1,
ABT_THREAD_ATTR_NULL, &threads[i]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
}
ABT_test_printf(1, "[U%lu:E%u]: created %d ULTs\n", id, rank, num_threads);
/* Join ULTs */
for (i = 0; i < num_threads; i++) {
ret = ABT_thread_join(threads[i]);
ABT_TEST_ERROR(ret, "ABT_thread_join");
}
ABT_test_printf(1, "[U%lu:E%u]: joined %d ULTs\n", id, rank, num_threads);
/* Revive ULTs with a different function */
for (i = 0; i < num_threads; i++) {
ret = ABT_thread_revive(my_pool, thread_func2, (void *)2, &threads[i]);
ABT_TEST_ERROR(ret, "ABT_thread_revive");
}
ABT_test_printf(1, "[U%lu:E%u]: revived %d ULTs\n", id, rank, num_threads);
/* Join and free ULTs */
for (i = 0; i < num_threads; i++) {
ret = ABT_thread_free(&threads[i]);
ABT_TEST_ERROR(ret, "ABT_thread_free");
}
ABT_test_printf(1, "[U%lu:E%u]: freed %d ULTs\n", id, rank, num_threads);
free(threads);
}
void test_yield(void *arg)
{
int eid = (int)(size_t)arg;
ABT_pool my_pool = g_pools[eid];
ABT_thread *my_threads = g_threads[eid];
int i;
for (i = 0; i < num_threads; i++) {
ABT_thread_create(my_pool, thread_func_yield, NULL,
ABT_THREAD_ATTR_NULL, &my_threads[i]);
}
ABT_THREAD_JOIN_MANY(num_threads, my_threads);
for (i = 0; i < num_threads; i++) {
ABT_thread_free(&my_threads[i]);
}
}
void test_create_join(void *arg)
{
int eid = (int)(size_t)arg;
ABT_pool my_pool = g_pools[eid];
ABT_thread *my_threads = g_threads[eid];
int i, t;
for (i = 0; i < iter; i++) {
for (t = 0; t < num_threads; t++) {
ABT_thread_create(my_pool, thread_func, NULL,
ABT_THREAD_ATTR_NULL, &my_threads[t]);
}
ABT_THREAD_JOIN_MANY(num_threads, my_threads);
for (t = 0; t < num_threads; t++) {
ABT_thread_free(&my_threads[t]);
}
}
}
void test_yield_to(void *arg)
{
int eid = (int)(size_t)arg;
ABT_pool my_pool = g_pools[eid];
ABT_thread *my_threads = g_threads[eid];
int i;
arg_t *args = (arg_t *)malloc(num_threads * sizeof(arg_t));
for (i = 0; i < num_threads; i++) {
args[i].eid = eid;
args[i].tid = i;
ABT_thread_create(my_pool, thread_func_yield_to, (void *)&args[i],
ABT_THREAD_ATTR_NULL, &my_threads[i]);
}
ABT_THREAD_JOIN_MANY(num_threads, my_threads);
for (i = 0; i < num_threads; i++) {
ABT_thread_free(&my_threads[i]);
}
free(args);
}
void sighandler(int sig)
{
printf("%s\n", "Caught signal for terminating...");
printf("%s\n", "Joining threads...");
int i;
/* join other threads */
for(i = 0; i < num_threads;i++){
ABT_thread_join(threads[i]);
ABT_thread_free(&threads[i]);
}
printf("%s\n", "Joining streams...");
/* join ESs */
for (i = 1; i < CORES; i++) {
ABT_xstream_join(xstreams[i]);
ABT_xstream_free(&xstreams[i]);
}
ABT_finalize();
abt_io_finalize(abtio);
free(xstreams);
exit(0);
}
/* Main function */
int main(int argc, char *argv[])
{
int n, i, expected;
int num_xstreams;
ABT_xstream *xstreams;
ABT_thread thread;
thread_args args;
if (argc > 1 && strcmp(argv[1], "-h") == 0) {
printf("Usage: %s [N=10] [num_ES=4]\n", argv[0]);
return EXIT_SUCCESS;
}
n = argc > 1 ? atoi(argv[1]) : N;
num_xstreams = argc > 2 ? atoi(argv[2]) : NUM_XSTREAMS;
printf("# of ESs: %d\n", num_xstreams);
/* initialization */
ABT_init(argc, argv);
/* shared pool creation */
ABT_pool_create_basic(ABT_POOL_FIFO, ABT_POOL_ACCESS_MPMC, ABT_TRUE,
&g_pool);
/* ES creation */
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * num_xstreams);
ABT_xstream_self(&xstreams[0]);
ABT_xstream_set_main_sched_basic(xstreams[0], ABT_SCHED_DEFAULT,
1, &g_pool);
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_create_basic(ABT_SCHED_DEFAULT, 1, &g_pool,
ABT_SCHED_CONFIG_NULL, &xstreams[i]);
ABT_xstream_start(xstreams[i]);
}
args.n = n;
args.future = ABT_FUTURE_NULL;
ABT_thread_create(g_pool, fibonacci, &args, ABT_THREAD_ATTR_NULL, &thread);
/* join the thread */
ABT_thread_join(thread);
ABT_thread_free(&thread);
/* join ESs */
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_join(xstreams[i]);
ABT_xstream_free(&xstreams[i]);
}
ABT_finalize();
free(xstreams);
printf("Fib(%d): %d\n", n, args.result);
expected = verify(n);
if (args.result != expected) {
fprintf(stderr, "ERROR: expected=%d\n", expected);
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int i, provided;
int ret;
int num_threads = DEFAULT_NUM_THREADS;
if (argc > 1)
num_threads = atoi(argv[1]);
if (num_threads % 2 != 0) {
if (rank == 0)
printf("number of user level threads should be even\n");
exit(0);
}
assert(num_threads >= 0);
num_loop = NUM_LOOP;
if (argc > 2)
num_loop = atoi(argv[2]);
assert(num_loop >= 0);
buf_size = BUF_SIZE;
if (argc > 3)
buf_size = atoi(argv[3]);
assert(buf_size >= 0);
/* Initialize */
ret = ABT_init(argc, argv);
if (ret != ABT_SUCCESS) {
printf("Failed to initialize Argobots\n");
return EXIT_FAILURE;
}
ret = MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
if (provided != MPI_THREAD_MULTIPLE) {
printf("Cannot initialize with MPI_THREAD_MULTIPLE\n");
return EXIT_FAILURE;
}
send_buf = (int *) malloc(buf_size * sizeof(int));
recv_buf = (int *) malloc(buf_size * sizeof(int));
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
if (profiling)
t1 = MPI_Wtime();
ABT_xstream xstream;
ABT_pool pools;
ABT_thread *threads = (ABT_thread *) malloc(num_threads * sizeof(ABT_thread));
ABT_xstream_self(&xstream);
ABT_xstream_get_main_pools(xstream, 1, &pools);
for (i = 0; i < num_threads; i++) {
size_t tid = i + 1;
if (i % 2 == 0) {
ret = ABT_thread_create(pools,
thread_send_func, (void *) tid,
ABT_THREAD_ATTR_NULL, &threads[i]);
} else {
ret = ABT_thread_create(pools,
thread_recv_func, (void *) tid,
ABT_THREAD_ATTR_NULL, &threads[i]);
}
HANDLE_ERROR(ret, "ABT_thread_create");
}
/* Join and free the ULT children */
for (i = 0; i < num_threads; i++)
ABT_thread_free(&threads[i]);
if (profiling) {
t2 = MPI_Wtime();
if (rank == 0) {
fprintf(stdout, "%*s%*f\n", FIELD_WIDTH, "Time", FIELD_WIDTH, t2 - t1);
}
}
/* Finalize */
free(threads);
free(send_buf);
free(recv_buf);
MPI_Finalize();
ABT_finalize();
return EXIT_SUCCESS;
}
/* Main function */
int main(int argc, char *argv[])
{
int n, i, result, expected;
int num_xstreams;
ABT_xstream *xstreams;
ABT_thread thread;
thread_args args_thread;
ABT_task task;
task_args *args_task;
if (argc > 1 && strcmp(argv[1], "-h") == 0) {
printf("Usage: %s [N=10] [num_ES=4]\n", argv[0]);
return EXIT_SUCCESS;
}
n = argc > 1 ? atoi(argv[1]) : N;
num_xstreams = argc > 2 ? atoi(argv[2]) : NUM_XSTREAMS;
printf("# of ESs: %d\n", num_xstreams);
if (n <= 2) {
result = 1;
goto fn_result;
}
/* initialization */
ABT_init(argc, argv);
/* shared pool creation */
ABT_pool_create_basic(ABT_POOL_FIFO, ABT_POOL_ACCESS_MPMC, ABT_TRUE,
&g_pool);
/* ES creation */
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * num_xstreams);
ABT_xstream_self(&xstreams[0]);
ABT_xstream_set_main_sched_basic(xstreams[0], ABT_SCHED_DEFAULT,
1, &g_pool);
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_create_basic(ABT_SCHED_DEFAULT, 1, &g_pool,
ABT_SCHED_CONFIG_NULL, &xstreams[i]);
ABT_xstream_start(xstreams[i]);
}
/* creating thread */
args_thread.n = n - 1;
args_thread.eventual = ABT_EVENTUAL_NULL;
ABT_thread_create(g_pool, fibonacci_thread, &args_thread, ABT_THREAD_ATTR_NULL, &thread);
/* creating task */
args_task = (task_args *)malloc(sizeof(task_args));
args_task->n = n - 2;
args_task->result = 0;
ABT_mutex_create(&args_task->mutex);
args_task->parent = NULL;
ABT_task_create(g_pool, fibonacci_task, args_task, &task);
/* switch to other user-level threads */
ABT_thread_yield();
/* join other threads */
ABT_thread_join(thread);
ABT_thread_free(&thread);
/* join ESs */
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_join(xstreams[i]);
ABT_xstream_free(&xstreams[i]);
}
result = args_thread.result + args_task->result;
free(args_task);
ABT_finalize();
free(xstreams);
fn_result:
printf("Fib(%d): %d\n", n, result);
expected = verify(n);
if (result != expected) {
fprintf(stderr, "ERROR: expected=%d\n", expected);
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
/* Create a work-stealing scheduler and push it to the pool */
static void thread_add_sched(void *arg)
{
int idx = (int)(intptr_t)arg;
int i;
ABT_thread cur_thread;
ABT_pool cur_pool;
ABT_pool *my_pools;
ABT_sched_config config;
ABT_sched sched;
size_t size;
double t_start, t_end;
ABT_sched_config_var cv_event_freq = {
.idx = 0,
.type = ABT_SCHED_CONFIG_INT
};
ABT_sched_config_var cv_idx = {
.idx = 1,
.type = ABT_SCHED_CONFIG_INT
};
ABT_sched_def sched_def = {
.type = ABT_SCHED_TYPE_ULT,
.init = sched_init,
.run = sched_run,
.free = sched_free,
.get_migr_pool = NULL
};
/* Create a scheduler */
ABT_sched_config_create(&config,
cv_event_freq, 10,
cv_idx, idx,
ABT_sched_config_var_end);
my_pools = (ABT_pool *)malloc(sizeof(ABT_pool) * max_xstreams);
for (i = 0; i < max_xstreams; i++) {
my_pools[i] = g_pools[(idx + i) % max_xstreams];
}
ABT_sched_create(&sched_def, max_xstreams, my_pools, config, &sched);
/* Create a ULT for the new scheduler */
ABT_thread_create(my_pools[0], thread_work, arg, ABT_THREAD_ATTR_NULL,
NULL);
/* Push the scheduler to the current pool */
ABT_thread_self(&cur_thread);
ABT_thread_get_last_pool(cur_thread, &cur_pool);
ABT_pool_add_sched(cur_pool, sched);
/* Free */
ABT_thread_release(cur_thread);
ABT_sched_config_free(&config);
free(my_pools);
t_start = ABT_get_wtime();
while (1) {
ABT_thread_yield();
ABT_pool_get_total_size(cur_pool, &size);
if (size == 0) {
ABT_sched_free(&sched);
break;
}
t_end = ABT_get_wtime();
if ((t_end - t_start) > g_timeout) {
ABT_sched_finish(sched);
}
}
}
static void thread_work(void *arg)
{
int idx = (int)(intptr_t)arg;
int i;
ABT_thread cur_thread;
ABT_pool cur_pool;
ABT_thread *threads;
int num_threads;
double t_start, t_end;
ABT_thread_self(&cur_thread);
ABT_thread_get_last_pool(cur_thread, &cur_pool);
ABT_thread_release(cur_thread);
t_start = ABT_get_wtime();
while (1) {
num_threads = 2;
threads = (ABT_thread *)malloc(sizeof(ABT_thread) * num_threads);
for (i = 0; i < num_threads; i++) {
ABT_thread_create(cur_pool, thread_hello, NULL,
ABT_THREAD_ATTR_NULL, &threads[i]);
}
for (i = 0; i < num_threads; i++) {
ABT_thread_free(&threads[i]);
}
free(threads);
if (g_signal[idx]) {
ABT_xstream xstream;
ABT_xstream_self(&xstream);
ABT_xstream_cancel(xstream);
g_signal[idx] = 0;
break;
}
t_end = ABT_get_wtime();
if ((t_end - t_start) > g_timeout) {
break;
}
}
}
static void test_printf(const char *format, ...)
{
#if 0
va_start(list, format);
vprintf(format, list);
va_end(list);
fflush(stdout);
#endif
}
int main(int argc, char *argv[])
{
int i, j, r;
int num_xstreams;
char *str, *endptr;
ABT_xstream *xstreams;
ABT_thread *threads;
vector_scal_task_args_t *args;
int inner_xstreams;
double *time, avg_time = 0.0;
num_xstreams = (argc > 1) ? atoi(argv[1]) : NUM_XSTREAMS;
inner_xstreams = (argc > 2) ? atoi(argv[2]) : NUM_XSTREAMS;
int rep = (argc > 3) ? atoi(argv[3]) : NUM_REPS;
time = (double *)malloc(sizeof(double) * rep);
init();
g_pools = (ABT_pool *)malloc(sizeof(ABT_pool) * num_xstreams);
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * num_xstreams);
threads = (ABT_thread *)malloc(sizeof(ABT_thread) * num_xstreams);
args = (vector_scal_task_args_t *)malloc(sizeof(vector_scal_task_args_t)
* num_xstreams);
/* initialization */
ABT_init(argc, argv);
for (i = 0; i < num_xstreams; i++) {
ABT_pool_create_basic(ABT_POOL_FIFO, ABT_POOL_ACCESS_MPMC, ABT_TRUE,
&g_pools[i]);
}
/* ES creation */
ABT_xstream_self(&xstreams[0]);
ABT_xstream_set_main_sched_basic(xstreams[0], ABT_SCHED_DEFAULT,
1, &g_pools[0]);
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_create_basic(ABT_SCHED_DEFAULT, 1, &g_pools[i],
ABT_SCHED_CONFIG_NULL, &xstreams[i]);
ABT_xstream_start(xstreams[i]);
}
/* Each task is created on the xstream which is going to execute it */
for (r = 0; r < rep; r++) {
time[r] = ABT_get_wtime();
int bloc = NUM / (num_xstreams);
int rest = NUM % (num_xstreams);
int start = 0;
int end = 0;
for (j = 0; j < num_xstreams; j++) {
start = end;
int inc = (j < rest) ? 1 : 0;
end += bloc + inc;
args[j].start = start;
args[j].end = end;
args[j].it = NUM;
args[j].nxstreams = inner_xstreams;
if (j > 0) {
ABT_thread_create(g_pools[j], vector_scal_launch,
(void *)&args[j], ABT_THREAD_ATTR_NULL,
&threads[j]);
}
}
vector_scal_launch((void *)&args[0]);
for (j = 1; j < num_xstreams; j++) {
ABT_thread_free(&threads[j]);
}
time[r] = ABT_get_wtime() - time[r];
avg_time += time[r];
}
avg_time /= rep;
printf("%d %d %f\n", num_xstreams, inner_xstreams, avg_time);
check();
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_join(xstreams[i]);
ABT_xstream_free(&xstreams[i]);
}
ABT_finalize();
free(g_pools);
free(xstreams);
free(threads);
free(args);
free(time);
return EXIT_SUCCESS;
}
void eventual_test(void *arg)
{
int i, t, ret;
size_t pid = (size_t)arg;
int eid = (int)pid;
ABT_thread *threads;
arg_t *thread_args;
int *nbytes;
ABT_eventual *evs1;
ABT_thread *waiters;
arg_t *waiter_args;
ABT_task *tasks;
arg_t *task_args;
ABT_eventual *evs2;
ABT_test_printf(1, "[M%u] start\n", (unsigned)(size_t)arg);
assert(num_tasks * 2 == num_threads);
threads = (ABT_thread *)malloc(num_threads * sizeof(ABT_thread));
thread_args = (arg_t *)malloc(num_threads * sizeof(arg_t));
nbytes = (int *)malloc(num_tasks * sizeof(int));
evs1 = (ABT_eventual *)malloc(num_tasks * sizeof(ABT_eventual));
assert(threads && thread_args && nbytes && evs1);
waiters = (ABT_thread *)malloc(num_tasks * sizeof(ABT_thread));
waiter_args = (arg_t *)malloc(num_tasks * sizeof(arg_t));
tasks = (ABT_task *)malloc(num_tasks * sizeof(ABT_task));
task_args = (arg_t *)malloc(num_tasks * sizeof(arg_t));
evs2 = (ABT_eventual *)malloc(num_tasks * sizeof(ABT_eventual));
assert(waiters && waiter_args && tasks && task_args && evs2);
for (t = 0; t < num_tasks; t++) {
nbytes[t] = (t & 1) ? sizeof(int) : 0;
ret = ABT_eventual_create(nbytes[t], &evs1[t]);
ABT_TEST_ERROR(ret, "ABT_eventual_create");
ret = ABT_eventual_create(nbytes[t], &evs2[t]);
ABT_TEST_ERROR(ret, "ABT_eventual_create");
}
for (i = 0; i < num_iter; i++) {
ABT_test_printf(2, "[M%u] iter=%d\n", (unsigned)(size_t)arg, i);
/* Use eventual between ULTs */
for (t = 0; t < num_threads; t += 2) {
thread_args[t].eid = eid;
thread_args[t].tid = t;
thread_args[t].ev = evs1[t/2];
thread_args[t].nbytes = nbytes[t/2];
thread_args[t].op_type = OP_WAIT;
ret = ABT_thread_create(pools[pid], thread_func, &thread_args[t],
ABT_THREAD_ATTR_NULL, &threads[t]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
pid = (pid + 1) % num_xstreams;
thread_args[t+1].eid = eid;
thread_args[t+1].tid = t + 1;
thread_args[t+1].ev = evs1[t/2];
thread_args[t+1].nbytes = nbytes[t/2];
thread_args[t+1].op_type = OP_SET;
ret = ABT_thread_create(pools[pid], thread_func, &thread_args[t+1],
ABT_THREAD_ATTR_NULL, &threads[t+1]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
pid = (pid + 1) % num_xstreams;
}
/* Use eventual between ULT and tasklet */
for (t = 0; t < num_tasks; t++) {
waiter_args[t].ev = evs2[t];
waiter_args[t].nbytes = nbytes[t];
waiter_args[t].op_type = OP_WAIT;
ret = ABT_thread_create(pools[pid], thread_func, &waiter_args[t],
ABT_THREAD_ATTR_NULL, &waiters[t]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
pid = (pid + 1) % num_xstreams;
task_args[t].ev = evs2[t];
task_args[t].nbytes = nbytes[t];
task_args[t].op_type = OP_SET;
ret = ABT_task_create(pools[pid], task_func, &task_args[t], &tasks[t]);
ABT_TEST_ERROR(ret, "ABT_task_create");
pid = (pid + 1) % num_xstreams;
}
for (t = 0; t < num_threads; t++) {
ret = ABT_thread_free(&threads[t]);
ABT_TEST_ERROR(ret, "ABT_thread_free");
}
for (t = 0; t < num_tasks; t++) {
ret = ABT_thread_free(&waiters[t]);
ABT_TEST_ERROR(ret, "ABT_thread_free");
ret = ABT_task_free(&tasks[t]);
ABT_TEST_ERROR(ret, "ABT_task_free");
}
for (t = 0; t < num_tasks; t++) {
ret = ABT_eventual_reset(evs1[t]);
ABT_TEST_ERROR(ret, "ABT_eventual_reset");
ret = ABT_eventual_reset(evs2[t]);
ABT_TEST_ERROR(ret, "ABT_eventual_reset");
}
}
for (t = 0; t < num_tasks; t++) {
ret = ABT_eventual_free(&evs1[t]);
ABT_TEST_ERROR(ret, "ABT_eventual_free");
ret = ABT_eventual_free(&evs2[t]);
ABT_TEST_ERROR(ret, "ABT_eventual_free");
}
free(threads);
free(thread_args);
free(nbytes);
free(evs1);
free(waiters);
free(waiter_args);
free(tasks);
free(task_args);
free(evs2);
ABT_test_printf(1, "[M%u] end\n", (unsigned)(size_t)arg);
}
int main(int argc, char *argv[])
{
int i, j, ret;
int num_xstreams = DEFAULT_NUM_XSTREAMS;
int num_threads = DEFAULT_NUM_THREADS;
int num_tasks = DEFAULT_NUM_TASKS;
if (argc > 1) num_xstreams = atoi(argv[1]);
assert(num_xstreams >= 0);
if (argc > 2) num_threads = atoi(argv[2]);
assert(num_threads >= 0);
if (argc > 3) num_tasks = atoi(argv[3]);
assert(num_tasks >= 0);
ABT_xstream *xstreams;
ABT_thread **threads;
thread_arg_t **thread_args;
ABT_task *tasks;
task_arg_t *task_args;
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * num_xstreams);
threads = (ABT_thread **)malloc(sizeof(ABT_thread *) * num_xstreams);
thread_args = (thread_arg_t **)malloc(sizeof(thread_arg_t*) * num_xstreams);
for (i = 0; i < num_xstreams; i++) {
threads[i] = (ABT_thread *)malloc(sizeof(ABT_thread) * num_threads);
for (j = 0; j < num_threads; j++) {
threads[i][j] = ABT_THREAD_NULL;
}
thread_args[i] = (thread_arg_t *)malloc(sizeof(thread_arg_t) *
num_threads);
}
tasks = (ABT_task *)malloc(sizeof(ABT_task) * num_tasks);
task_args = (task_arg_t *)malloc(sizeof(task_arg_t) * num_tasks);
/* Initialize */
ABT_test_init(argc, argv);
/* Create Execution Streams */
ret = ABT_xstream_self(&xstreams[0]);
ABT_TEST_ERROR(ret, "ABT_xstream_self");
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_create(ABT_SCHED_NULL, &xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_create");
}
/* Get the pools attached to an execution stream */
ABT_pool *pools;
pools = (ABT_pool *)malloc(sizeof(ABT_pool) * num_xstreams);
for (i = 0; i < num_xstreams; i++) {
ret = ABT_xstream_get_main_pools(xstreams[i], 1, pools+i);
ABT_TEST_ERROR(ret, "ABT_xstream_get_main_pools");
}
/* Create threads */
for (i = 0; i < num_xstreams; i++) {
for (j = 0; j < num_threads; j++) {
int tid = i * num_threads + j + 1;
thread_args[i][j].id = tid;
thread_args[i][j].num_threads = num_threads;
thread_args[i][j].threads = &threads[i][0];
ret = ABT_thread_create(pools[i],
thread_func, (void *)&thread_args[i][j],
ABT_THREAD_ATTR_NULL,
&threads[i][j]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
}
}
/* Create tasks with task_func1 */
for (i = 0; i < num_tasks; i++) {
size_t num = 100 + i;
ret = ABT_task_create(pools[i % num_xstreams],
task_func1, (void *)num,
NULL);
ABT_TEST_ERROR(ret, "ABT_task_create");
}
/* Create tasks with task_func2 */
for (i = 0; i < num_tasks; i++) {
task_args[i].num = 100 + i;
ret = ABT_task_create(pools[i % num_xstreams],
task_func2, (void *)&task_args[i],
&tasks[i]);
ABT_TEST_ERROR(ret, "ABT_task_create");
}
/* Switch to other work units */
ABT_thread_yield();
/* Results of task_funcs2 */
for (i = 0; i < num_tasks; i++) {
ABT_task_state state;
do {
ABT_task_get_state(tasks[i], &state);
ABT_thread_yield();
} while (state != ABT_TASK_STATE_TERMINATED);
ABT_test_printf(1, "task_func2: num=%lu result=%llu\n",
task_args[i].num, task_args[i].result);
/* Free named tasks */
ret = ABT_task_free(&tasks[i]);
ABT_TEST_ERROR(ret, "ABT_task_free");
}
/* Join Execution Streams */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_join(xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_join");
}
/* Free Execution Streams */
for (i = 0; i < num_xstreams; i++) {
for (j = 0; j < num_threads; j++) {
ret = ABT_thread_free(&threads[i][j]);
ABT_TEST_ERROR(ret, "ABT_thread_free");
}
if (i == 0) continue;
ret = ABT_xstream_free(&xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_free");
}
/* Finalize */
ret = ABT_test_finalize(0);
for (i = 0; i < num_xstreams; i++) {
free(thread_args[i]);
free(threads[i]);
}
free(thread_args);
free(threads);
free(task_args);
free(tasks);
free(pools);
free(xstreams);
return ret;
}
int main(int argc, char *argv[])
{
int i, ret;
ABT_xstream *xstreams;
ABT_pool *pools;
ABT_thread *threads;
int num_xstreams = DEFAULT_NUM_XSTREAMS;
/* Initialize */
ABT_test_init(argc, argv);
if (argc >= 2) {
num_xstreams = ABT_test_get_arg_val(ABT_TEST_ARG_N_ES);
num_threads = ABT_test_get_arg_val(ABT_TEST_ARG_N_ULT);
}
ABT_test_printf(1, "# of ESs : %d\n", num_xstreams);
ABT_test_printf(1, "# of ULTs/ES: %d\n", num_threads);
xstreams = (ABT_xstream *)malloc(num_xstreams * sizeof(ABT_xstream));
pools = (ABT_pool *)malloc(num_xstreams * sizeof(ABT_pool));
threads = (ABT_thread *)malloc(num_xstreams * sizeof(ABT_thread));
/* Create Execution Streams */
ret = ABT_xstream_self(&xstreams[0]);
ABT_TEST_ERROR(ret, "ABT_xstream_self");
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_create(ABT_SCHED_NULL, &xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_create");
}
/* Get the first pool of each ES */
for (i = 0; i < num_xstreams; i++) {
ret = ABT_xstream_get_main_pools(xstreams[i], 1, &pools[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_get_main_pools");
}
/* Create one ULT for each ES */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_thread_create(pools[i], thread_create, (void *)0,
ABT_THREAD_ATTR_NULL, &threads[i]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
}
thread_create((void *)0);
/* Join and free ULTs */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_thread_free(&threads[i]);
ABT_TEST_ERROR(ret, "ABT_thread_free");
}
/* Join and free ESs */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_join(xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_join");
ret = ABT_xstream_free(&xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_free");
}
/* Finalize */
ret = ABT_test_finalize(0);
free(xstreams);
free(pools);
free(threads);
return ret;
}
int main(int argc, char *argv[])
{
ABT_pool (*all_pools)[2];
ABT_sched *scheds;
ABT_thread *top_threads;
size_t i, t;
uint64_t t_start;
/* initialize */
ABT_test_init(argc, argv);
for (i = 0; i < T_LAST; i++) {
t_times[i] = 0;
}
/* read command-line arguments */
num_xstreams = ABT_test_get_arg_val(ABT_TEST_ARG_N_ES);
num_threads = ABT_test_get_arg_val(ABT_TEST_ARG_N_ULT);
iter = ABT_test_get_arg_val(ABT_TEST_ARG_N_ITER);
g_xstreams = (ABT_xstream *)malloc(num_xstreams * sizeof(ABT_xstream));
g_pools = (ABT_pool *)malloc(num_xstreams * sizeof(ABT_pool));
g_threads = (ABT_thread **)malloc(num_xstreams * sizeof(ABT_thread *));
for (i = 0; i < num_xstreams; i++) {
g_threads[i] = (ABT_thread *)malloc(num_threads * sizeof(ABT_thread));
}
all_pools = (ABT_pool (*)[2])malloc(num_xstreams * sizeof(ABT_pool) * 2);
scheds = (ABT_sched *)malloc(num_xstreams * sizeof(ABT_sched));
top_threads = (ABT_thread *)malloc(num_xstreams * sizeof(ABT_thread));
/* create pools and schedulers */
for (i = 0; i < num_xstreams; i++) {
ABT_pool_create_basic(ABT_POOL_FIFO, ABT_POOL_ACCESS_MPSC, ABT_TRUE,
&all_pools[i][0]);
ABT_pool_create_basic(ABT_POOL_FIFO, ABT_POOL_ACCESS_PRIV, ABT_TRUE,
&all_pools[i][1]);
g_pools[i] = all_pools[i][1];
ABT_sched_create_basic(ABT_SCHED_DEFAULT, 2, all_pools[i],
ABT_SCHED_CONFIG_NULL, &scheds[i]);
}
/* create ESs */
ABT_xstream_self(&g_xstreams[0]);
ABT_xstream_set_main_sched(g_xstreams[0], scheds[0]);
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_create(scheds[i], &g_xstreams[i]);
}
/* benchmarking */
for (t = 0; t < T_LAST; t++) {
void (*test_fn)(void *);
if (t == T_YIELD) {
if (t_times[T_YIELD_ALL] > t_times[T_YIELD_OVERHEAD]) {
t_times[t] = t_times[T_YIELD_ALL] - t_times[T_YIELD_OVERHEAD];
} else {
t_times[t] = 0;
}
continue;
} else if (t == T_YIELD_TO) {
if (t_times[T_YIELD_TO_ALL] > t_times[T_YIELD_TO_OVERHEAD]) {
t_times[t] = t_times[T_YIELD_TO_ALL] - t_times[T_YIELD_TO_OVERHEAD];
} else {
t_times[t] = 0;
}
continue;
}
switch (t) {
case T_CREATE_JOIN: test_fn = test_create_join;
break;
case T_CREATE_UNNAMED: test_fn = test_create_unnamed;
break;
case T_YIELD_OVERHEAD: test_fn = test_yield_overhead;
break;
case T_YIELD_ALL: test_fn = test_yield;
break;
case T_YIELD_TO_OVERHEAD: test_fn = test_yield_to_overhead;
break;
case T_YIELD_TO_ALL: test_fn = test_yield_to;
break;
#ifdef TEST_MIGRATE_TO
case T_MIGRATE_TO_XSTREAM: test_fn = test_migrate_to_xstream;
break;
#endif
default: assert(0);
}
/* warm-up */
for (i = 0; i < num_xstreams; i++) {
ABT_thread_create(all_pools[i][0], test_fn, (void *)i,
ABT_THREAD_ATTR_NULL, &top_threads[i]);
}
for (i = 0; i < num_xstreams; i++) {
ABT_thread_free(&top_threads[i]);
}
/* measurement */
#ifdef USE_TIME
t_start = ABT_get_wtime();
#else
t_start = ABT_test_get_cycles();
#endif
for (i = 0; i < num_xstreams; i++) {
ABT_thread_create(all_pools[i][0], test_fn, (void *)i,
ABT_THREAD_ATTR_NULL, &top_threads[i]);
}
for (i = 0; i < num_xstreams; i++) {
ABT_thread_free(&top_threads[i]);
}
#ifdef USE_TIME
t_times[t] = ABT_get_wtime() - t_start;
#else
t_times[t] = ABT_test_get_cycles() - t_start;
#endif
}
/* join and free */
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_join(g_xstreams[i]);
ABT_xstream_free(&g_xstreams[i]);
}
/* finalize */
ABT_test_finalize(0);
/* compute the execution time for one iteration */
for (i = 0; i < T_LAST; i++) {
t_times[i] = t_times[i] / iter / num_threads;
}
/* output */
int line_size = 56;
ABT_test_print_line(stdout, '-', line_size);
printf("%s\n", "Argobots");
ABT_test_print_line(stdout, '-', line_size);
printf("# of ESs : %d\n", num_xstreams);
printf("# of ULTs per ES: %d\n", num_threads);
ABT_test_print_line(stdout, '-', line_size);
printf("Avg. execution time (in seconds, %d times)\n", iter);
ABT_test_print_line(stdout, '-', line_size);
printf("%-20s %-s\n", "operation", "time");
ABT_test_print_line(stdout, '-', line_size);
for (i = 0; i < T_LAST; i++) {
#ifdef USE_TIME
printf("%-19s %.9lf\n", t_names[i], t_times[i]);
#else
printf("%-19s %11" PRIu64 "\n", t_names[i], t_times[i]);
#endif
}
ABT_test_print_line(stdout, '-', line_size);
free(g_xstreams);
free(g_pools);
for (i = 0; i < num_xstreams; i++) {
free(g_threads[i]);
}
free(g_threads);
free(all_pools);
free(scheds);
free(top_threads);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int i, j;
int ret;
int num_xstreams = DEFAULT_NUM_XSTREAMS;
int num_threads = DEFAULT_NUM_THREADS;
if (argc > 1) num_xstreams = atoi(argv[1]);
assert(num_xstreams >= 0);
if (argc > 2) num_threads = atoi(argv[2]);
assert(num_threads >= 0);
ABT_xstream *xstreams;
ABT_thread **threads;
thread_arg_t **args;
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * num_xstreams);
threads = (ABT_thread **)malloc(sizeof(ABT_thread *) * num_xstreams);
args = (thread_arg_t **)malloc(sizeof(thread_arg_t *) * num_xstreams);
for (i = 0; i < num_xstreams; i++) {
threads[i] = (ABT_thread *)malloc(sizeof(ABT_thread) * num_threads);
for (j = 0; j < num_threads; j++) {
threads[i][j] = ABT_THREAD_NULL;
}
args[i] = (thread_arg_t *)malloc(sizeof(thread_arg_t) * num_threads);
}
/* Initialize */
ABT_test_init(argc, argv);
/* Create Execution Streams */
ret = ABT_xstream_self(&xstreams[0]);
ABT_TEST_ERROR(ret, "ABT_xstream_self");
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_create(ABT_SCHED_NULL, &xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_create");
}
/* Get the pools attached to an execution stream */
ABT_pool *pools;
pools = (ABT_pool *)malloc(sizeof(ABT_pool) * num_xstreams);
for (i = 0; i < num_xstreams; i++) {
ret = ABT_xstream_get_main_pools(xstreams[i], 1, pools+i);
ABT_TEST_ERROR(ret, "ABT_xstream_get_main_pools");
}
/* Create threads */
for (i = 0; i < num_xstreams; i++) {
for (j = 0; j < num_threads; j++) {
int tid = i * num_threads + j + 1;
args[i][j].id = tid;
args[i][j].num_threads = num_threads;
args[i][j].threads = &threads[i][0];
ret = ABT_thread_create(pools[i],
thread_func, (void *)&args[i][j], ABT_THREAD_ATTR_NULL,
&threads[i][j]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
}
}
/* Join Execution Streams */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_join(xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_join");
}
/* Free threads and Execution Streams */
for (i = 0; i < num_xstreams; i++) {
for (j = 0; j < num_threads; j++) {
ret = ABT_thread_free(&threads[i][j]);
ABT_TEST_ERROR(ret, "ABT_thread_free");
}
if (i == 0) continue;
ret = ABT_xstream_free(&xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_free");
}
/* Finalize */
ret = ABT_test_finalize(0);
for (i = 0; i < num_xstreams; i++) {
free(args[i]);
free(threads[i]);
}
free(args);
free(threads);
free(pools);
free(xstreams);
return ret;
}
int main(int argc, char *argv[])
{
ABT_xstream *xstreams;
ABT_pool *pools;
ABT_thread *threads;
int num_xstreams;
int es = 0;
int *args;
int i, j, iter, t;
int ret;
/* Initialize */
ABT_test_init(argc, argv);
if (argc < 2) {
num_xstreams = 4;
N = 10;
iter = 100;
} else {
num_xstreams = ABT_test_get_arg_val(ABT_TEST_ARG_N_ES);
N = ABT_test_get_arg_val(ABT_TEST_ARG_N_ULT);
iter = ABT_test_get_arg_val(ABT_TEST_ARG_N_ITER);
}
ABT_test_printf(1, "# of ESs : %d\n", num_xstreams);
ABT_test_printf(1, "# of ULTs: %d\n", N * N);
ABT_test_printf(1, "# of iter: %d\n", iter);
xstreams = (ABT_xstream *)malloc(num_xstreams * sizeof(ABT_xstream));
pools = (ABT_pool *)malloc(num_xstreams * sizeof(ABT_pool));
threads = (ABT_thread *)malloc(N * N * sizeof(ABT_thread));
values = (int *)malloc(N * sizeof(int));
row_barrier = (ABT_barrier *)malloc(N * sizeof(ABT_barrier));
col_barrier = (ABT_barrier *)malloc(N * sizeof(ABT_barrier));
/* Create the values and barriers */
for (i = 0; i < N; i++) {
ret = ABT_barrier_create((size_t)N, &row_barrier[i]);
ABT_TEST_ERROR(ret, "ABT_barrier_create");
ret = ABT_barrier_create((size_t)N, &col_barrier[i]);
ABT_TEST_ERROR(ret, "ABT_barrier_create");
}
ret = ABT_barrier_create((size_t)N * N, &global_barrier);
ABT_TEST_ERROR(ret, "ABT_barrier_create");
args = (int *)malloc(2 * N * N * sizeof(int));
/* Create ESs */
for (t = 0; t < iter; t++) {
ABT_test_printf(1, "iter=%d\n", t);
ret = ABT_xstream_self(&xstreams[0]);
ABT_TEST_ERROR(ret, "ABT_xstream_self");
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_create(ABT_SCHED_NULL, &xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_create");
}
/* Get the first pool of each ES */
for (i = 0; i < num_xstreams; i++) {
ret = ABT_xstream_get_main_pools(xstreams[i], 1, &pools[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_get_main_pools");
}
/* Create ULTs */
for (i = 0; i < N; i++) {
values[i] = i;
}
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
args[2*(i*N+j)] = i;
args[2*(i*N+j)+1] = j;
ret = ABT_thread_create(pools[es], run, (void *)&args[2*(i*N+j)],
ABT_THREAD_ATTR_NULL, &threads[i*N+j]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
es = (es + 1) % num_xstreams;
}
}
/* Join and free ULTs */
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
ret = ABT_thread_free(&threads[i*N+j]);
ABT_TEST_ERROR(ret, "ABT_thread_free");
}
}
/* Join ESs */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_join(xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_join");
}
/* Free ESs */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_free(&xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_free");
}
}
/* Free the barriers */
for (i = 0; i < N; i++) {
ret = ABT_barrier_free(&row_barrier[i]);
ABT_TEST_ERROR(ret, "ABT_barrier_create");
ret = ABT_barrier_free(&col_barrier[i]);
ABT_TEST_ERROR(ret, "ABT_barrier_create");
}
ret = ABT_barrier_free(&global_barrier);
ABT_TEST_ERROR(ret, "ABT_barrier_free");
/* Finalize */
ret = ABT_test_finalize(0);
free(xstreams);
free(pools);
free(threads);
free(values);
free(row_barrier);
free(col_barrier);
free(args);
return ret;
}
int main(int argc, char *argv[])
{
ABT_xstream *xstreams;
ABT_thread *masters;
int i, ret;
/* Initialize */
ABT_test_init(argc, argv);
if (argc < 2) {
num_xstreams = DEFAULT_NUM_XSTREAMS;
num_threads = DEFAULT_NUM_THREADS;
num_tasks = DEFAULT_NUM_TASKS;
num_iter = DEFAULT_NUM_ITER;
} else {
num_xstreams = ABT_test_get_arg_val(ABT_TEST_ARG_N_ES);
num_tasks = ABT_test_get_arg_val(ABT_TEST_ARG_N_TASK);
num_threads = num_tasks * 2;
num_iter = ABT_test_get_arg_val(ABT_TEST_ARG_N_ITER);
}
ABT_test_printf(1, "# of ESs : %d\n", num_xstreams);
ABT_test_printf(1, "# of ULTs/ES : %d\n", num_threads + num_tasks);
ABT_test_printf(1, "# of tasklets/ES: %d\n", num_tasks);
ABT_test_printf(1, "# of iter : %d\n", num_iter);
xstreams = (ABT_xstream *)malloc(num_xstreams * sizeof(ABT_xstream));
pools = (ABT_pool *)malloc(num_xstreams * sizeof(ABT_pool));
masters = (ABT_thread *)malloc(num_xstreams * sizeof(ABT_thread));
/* Create Execution Streams */
ret = ABT_xstream_self(&xstreams[0]);
ABT_TEST_ERROR(ret, "ABT_xstream_self");
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_create(ABT_SCHED_NULL, &xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_create");
}
/* Get the main pool of each ES */
for (i = 0; i < num_xstreams; i++) {
ret = ABT_xstream_get_main_pools(xstreams[i], 1, &pools[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_get_main_pools");
}
/* Create a master ULT for each ES */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_thread_create(pools[i], eventual_test, (void *)(size_t)i,
ABT_THREAD_ATTR_NULL, &masters[i]);
ABT_TEST_ERROR(ret, "ABT_thread_create");
}
eventual_test((void *)0);
/* Join master ULTs */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_thread_free(&masters[i]);
ABT_TEST_ERROR(ret, "ABT_thread_free");
}
/* Join and free Execution Streams */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_join(xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_join");
ret = ABT_xstream_free(&xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_free");
}
/* Finalize */
ret = ABT_test_finalize(0);
free(xstreams);
free(pools);
free(masters);
return ret;
}