/* Function to compute Fibonacci numbers */
void fibonacci_thread(void *arguments)
{
int n, *n1, *n2;
thread_args a1, a2;
ABT_eventual eventual, f1, f2;
thread_args *args = (thread_args *)arguments;
n = args->n;
eventual = args->eventual;
/* checking for base cases */
if (n <= 2)
args->result = 1;
else {
ABT_eventual_create(sizeof(int), &f1);
a1.n = n - 1;
a1.eventual = f1;
ABT_thread_create(g_pool, fibonacci_thread, &a1, ABT_THREAD_ATTR_NULL,
NULL);
ABT_eventual_create(sizeof(int), &f2);
a2.n = n - 2;
a2.eventual = f2;
ABT_thread_create(g_pool, fibonacci_thread, &a2, ABT_THREAD_ATTR_NULL,
NULL);
ABT_eventual_wait(f1, (void **)&n1);
ABT_eventual_wait(f2, (void **)&n2);
args->result = *n1 + *n2;
ABT_eventual_free(&f1);
ABT_eventual_free(&f2);
}
/* checking whether to signal the eventual */
if (eventual != ABT_EVENTUAL_NULL) {
ABT_eventual_set(eventual, &args->result, sizeof(int));
}
}
int main(int argc, char *argv[])
{
int ret;
ABT_xstream xstream;
/* init and thread creation */
ABT_test_init(argc, argv);
ret = ABT_xstream_self(&xstream);
ABT_TEST_ERROR(ret, "ABT_xstream_self");
/* Get the pools attached to an execution stream */
ABT_pool pool;
ret = ABT_xstream_get_main_pools(xstream, 1, &pool);
ABT_TEST_ERROR(ret, "ABT_xstream_get_main_pools");
ret = ABT_thread_create(pool, fn1, NULL, ABT_THREAD_ATTR_NULL, &th1);
ABT_TEST_ERROR(ret, "ABT_thread_create");
ret = ABT_thread_create(pool, fn2, NULL, ABT_THREAD_ATTR_NULL, &th2);
ABT_TEST_ERROR(ret, "ABT_thread_create");
ret = ABT_thread_create(pool, fn3, NULL, ABT_THREAD_ATTR_NULL, &th3);
ABT_TEST_ERROR(ret, "ABT_thread_create");
ret = ABT_eventual_create(EVENTUAL_SIZE, &myeventual);
ABT_TEST_ERROR(ret, "ABT_eventual_create");
ABT_test_printf(1, "START\n");
void *data;
ABT_test_printf(1, "Thread main iteration %d waiting for eventual\n", 0);
ABT_eventual_wait(myeventual,&data);
ABT_test_printf(1, "Thread main continue iteration %d returning from "
"eventual\n", 0);
/* switch to other user-level threads */
ABT_thread_yield();
/* join other threads */
ret = ABT_thread_join(th1);
ABT_TEST_ERROR(ret, "ABT_thread_join");
ret = ABT_thread_join(th2);
ABT_TEST_ERROR(ret, "ABT_thread_join");
ret = ABT_thread_join(th3);
ABT_TEST_ERROR(ret, "ABT_thread_join");
ABT_test_printf(1, "END\n");
ret = ABT_test_finalize(0);
return ret;
}
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);
}
