static void create_xstream(int idx)
{
ABT_pool pool;
ABT_xstream_create(ABT_SCHED_NULL, &g_xstreams[idx]);
ABT_xstream_get_main_pools(g_xstreams[idx], 1, &pool);
ABT_thread_create(pool, thread_add_sched, (void *)(intptr_t)idx,
ABT_THREAD_ATTR_NULL, NULL);
}
void accalt_tasklet_creation_to(void(*thread_func)(void *), void *arg, ACCALT_tasklet *new_ult, int dest) {
#ifdef ARGOBOTS
ABT_pool pool;
ABT_xstream_get_main_pools(main_team->team[dest], 1, &pool);
ABT_task_create(pool, thread_func, arg, new_ult);
#endif
#ifdef MASSIVETHREADS
accalt_ult_creation(thread_func, arg, new_ult);
#endif
#ifdef QTHREADS
qthread_fork_to((void *) thread_func, arg, new_ult, dest);
#endif
}
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 accalt_tasklet_creation(void(*thread_func)(void *), void *arg, ACCALT_tasklet *new_ult) {
#ifdef ARGOBOTS
ABT_xstream xstream;
ABT_xstream_self(&xstream);
ABT_pool pool;
ABT_xstream_get_main_pools(xstream, 1, &pool);
ABT_task_create(pool, thread_func, arg, new_ult);
#endif
#ifdef MASSIVETHREADS
*new_ult = myth_create((void *) thread_func, arg);
#endif
#ifdef QTHREADS
qthread_fork((void *) thread_func, arg, new_ult);
#endif
}
static void gen_work(void *arg)
{
int idx = (size_t)arg;
int num_pools = g_data.num_pools[idx];
ABT_pool *my_pools = g_data.pools[idx];
ABT_bool flag;
int i, ret;
unsigned seed = time(NULL);
ABT_test_printf(1, "[E%d] creating work units\n", idx);
/* Create work units on the current ES */
/* TODO: add work units to pools of other ESs */
for (i = 0; i < num_units; i++) {
unit_arg_t *my_arg = (unit_arg_t *)malloc(sizeof(unit_arg_t));
my_arg->es_id = idx;
my_arg->my_id = i;
my_arg->prio = rand_r(&seed) % num_pools;
if (i & 1) {
ret = ABT_thread_create(my_pools[my_arg->prio],
thread_func, (void *)my_arg,
ABT_THREAD_ATTR_NULL, NULL);
ABT_TEST_ERROR(ret, "ABT_thread_create");
} else {
ret = ABT_task_create(my_pools[my_arg->prio],
task_func, (void *)my_arg,
NULL);
ABT_TEST_ERROR(ret, "ABT_task_create");
}
}
/* Stack the priority scheduler if it is associated with PW pools */
ret = ABT_self_on_primary_xstream(&flag);
ABT_TEST_ERROR(ret, "ABT_self_on_primary_stream");
if (flag == ABT_FALSE) {
if (accesses[idx] == ABT_POOL_ACCESS_PRIV ||
accesses[idx] == ABT_POOL_ACCESS_SPSC ||
accesses[idx] == ABT_POOL_ACCESS_SPMC) {
ABT_pool main_pool;
ret = ABT_xstream_get_main_pools(g_data.xstreams[idx],
1, &main_pool);
ABT_TEST_ERROR(ret, "ABT_xstream_get_main_pools");
ret = ABT_pool_add_sched(main_pool, g_data.scheds[idx]);
ABT_TEST_ERROR(ret, "ABT_pool_add_sched");
}
}
}
static void create_work_units(void)
{
int i;
int ret;
for (i = 0; i < g_data.num_scheds; i++) {
/* Create a ULT in the first main pool */
ABT_pool main_pool;
ret = ABT_xstream_get_main_pools(g_data.xstreams[i], 1, &main_pool);
ABT_TEST_ERROR(ret, "ABT_xstream_get_main_pools");
ret = ABT_thread_create(main_pool, gen_work, (void *)(size_t)i,
ABT_THREAD_ATTR_NULL, NULL);
ABT_TEST_ERROR(ret, "ABT_thread_create");
}
}
/* This function is the second callback function for the event,
* ABT_EVENT_ADD_XSTREAM. After all the first callback functions registered
* for ABT_EVENT_ADD_XSTREAM return ABT_TRUE for the target ES, the Argobots
* runtime will call this second callback function to notify that we have
* reached an agreement. For now, the creation of the target ES needs to be
* happened in this callback function.
*
* Parameters:
* [in] user_arg: user-provided argument
* [in] abt_arg : runtime-provided argument, the rank of ES to create
*/
static ABT_bool rt1_act_add_xstream(void *user_arg, void *abt_arg)
{
rt1_data_t *my_data = (rt1_data_t *)user_arg;
int tar_rank = (int)(intptr_t)abt_arg;
ABT_bool result = ABT_TRUE;
ABT_pool pool;
ABT_xstream tar_xstream;
int rank, ret;
/* Create a new ES */
if (tar_rank == ABT_XSTREAM_ANY_RANK) {
ret = ABT_xstream_create(ABT_SCHED_NULL, &tar_xstream);
if (ret != ABT_SUCCESS) {
result = ABT_FALSE;
goto fn_exit;
}
ABT_xstream_get_rank(tar_xstream, &rank);
} else {
rank = tar_rank;
ret = ABT_xstream_create_with_rank(ABT_SCHED_NULL, rank, &tar_xstream);
if (ret != ABT_SUCCESS) {
printf("ES%d: failed to create\n", rank);
result = ABT_FALSE;
goto fn_exit;
}
}
ABT_mutex_spinlock(my_data->mutex);
assert(rank < my_data->max_xstreams &&
my_data->xstreams[rank] == ABT_XSTREAM_NULL);
my_data->xstreams[rank] = tar_xstream;
my_data->num_xstreams++;
g_xstreams[rank] = tar_xstream;
ABT_mutex_unlock(my_data->mutex);
ABT_xstream_get_main_pools(tar_xstream, 1, &pool);
ABT_thread_create(pool, rt1_launcher, (void *)(intptr_t)rank,
ABT_THREAD_ATTR_NULL, NULL);
printf("ES%d: created\n", rank);
fn_exit:
return result;
}
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_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[])
{
int i, j;
int ret, expected;
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_mutex mutex;
ABT_xstream *xstreams;
thread_arg_t **args;
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * num_xstreams);
assert(xstreams != NULL);
args = (thread_arg_t **)malloc(sizeof(thread_arg_t *) * num_xstreams);
assert(args != NULL);
for (i = 0; i < num_xstreams; i++) {
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 a mutex */
ret = ABT_mutex_create(&mutex);
ABT_TEST_ERROR(ret, "ABT_mutex_create");
/* 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].mutex = mutex;
ret = ABT_thread_create(pools[i],
thread_func, (void *)&args[i][j], ABT_THREAD_ATTR_NULL,
NULL);
ABT_TEST_ERROR(ret, "ABT_thread_create");
}
}
/* Switch to other user level threads */
ABT_thread_yield();
/* Join Execution Streams */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_join(xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_join");
}
/* Free the mutex */
ret = ABT_mutex_free(&mutex);
ABT_TEST_ERROR(ret, "ABT_mutex_free");
/* Free Execution Streams */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_free(&xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_free");
}
/* Validation */
expected = num_xstreams * num_threads;
if (g_counter != expected) {
printf("g_counter = %d\n", g_counter);
}
/* Finalize */
ret = ABT_test_finalize(g_counter != expected);
for (i = 0; i < num_xstreams; i++) {
free(args[i]);
}
free(args);
free(xstreams);
free(pools);
return ret;
}
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;
}
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[])
{
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;
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * num_xstreams);
ABT_pool *pools;
pools = (ABT_pool *)malloc(sizeof(ABT_pool) * num_xstreams);
/* 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 */
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++) {
size_t tid = i * num_threads + j + 1;
ret = ABT_thread_create(pools[i],
thread_func, (void *)tid, ABT_THREAD_ATTR_NULL,
NULL);
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 Execution Streams */
for (i = 1; i < num_xstreams; i++) {
ret = ABT_xstream_free(&xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_free");
}
/* Finalize */
ret = ABT_test_finalize(0);
free(pools);
free(xstreams);
return ret;
}
int main(int argc, char *argv[])
{
// Argobots definitions
int ret, i;
num_threads = 0;
// Sockets Definitions
int fd, cfd;
struct sockaddr_in svaddr;
struct sockaddr_storage claddr;
socklen_t addrlen;
signal(SIGINT, sighandler);
ABT_init(argc, argv);
int abts = 0;//ABT_snoozer_xstream_self_set();
if (abts != 0){
fprintf(stderr, "%s\n", "ABT snoozer xstream self error");
exit(-1);
}
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * CORES);
ret = ABT_xstream_self(&xstreams[0]);
if(ret != 0){
fprintf(stderr, "%s\n", "ABT xstream self error");
exit(-1);
}
ret = ABT_xstream_get_main_pools(xstreams[0], 1, &pool);
if(ret != 0){
fprintf(stderr, "%s\n", "ABT xstream pool error");
exit(-1);
}
ABT_pool_create_basic(ABT_POOL_FIFO, ABT_POOL_ACCESS_MPMC, ABT_TRUE, &g_pool);
/* ES creation */
ABT_xstream_self(&xstreams[0]);
ABT_xstream_set_main_sched_basic(xstreams[0], ABT_SCHED_DEFAULT,
1, &g_pool);
for (i = 1; i < CORES; i++) {
ABT_xstream_create_basic(ABT_SCHED_DEFAULT, 1, &g_pool,
ABT_SCHED_CONFIG_NULL, &xstreams[i]);
ABT_xstream_start(xstreams[i]);
}
//abtio = abt_io_init(CORES);
//assert(abtio != NULL);
fd = socket(AF_INET, SOCK_STREAM, 0);
if(fd < 0){
fprintf(stderr, "%s\n", "Socket creating error");
exit(-1);
}
memset(&svaddr, 0, sizeof(struct sockaddr_in));
svaddr.sin_family = AF_INET;
svaddr.sin_addr.s_addr = INADDR_ANY;
svaddr.sin_port = htons(PORTNUM);
ret = bind(fd, (struct sockaddr *) &svaddr, sizeof(struct sockaddr_in));
if(ret < 0){
fprintf(stderr, "%s\n", "Socket binding error");
exit(-1);
}
if( listen(fd, BACKLOG) == -1)
{
fprintf(stderr, "%s\n", "Socket listening error");
exit(-1);
}
int aio_sock = abt_io_socket_initialize(1000);
if(aio_sock <= 0)
printf("Initialize io_sock error\n");
//printf("USer: main: epoll fd = %d\n", aio_sock);
addrlen = sizeof(struct sockaddr_storage);
while(1){
cfd = accept(fd, (struct sockaddr *)&claddr, &addrlen);
if(cfd == -1){
fprintf(stderr, "%s\n", "Socket accepting error");
exit(-1);
}
//printf("accepted client on file descriptor %d\n", cfd);
struct thread_args* ta = (struct thread_args*) malloc (sizeof(ta));
ta->epfd = aio_sock;
ta->fd = cfd;
ABT_thread_create(g_pool, handle_client, (void *) ta, ABT_THREAD_ATTR_NULL, threads[num_threads++]);
}
return 0;
}
int main(int argc, char *argv[])
{
ABT_xstream xstream;
ABT_pool pool;
ABT_timer timer;
int i, iter;
double t_overhead;
ABT_test_read_args(argc, argv);
iter = ABT_test_get_arg_val(ABT_TEST_ARG_N_ITER);
ABT_timer_create(&timer);
ABT_timer_start(timer);
ABT_timer_stop(timer);
ABT_timer_get_overhead(&t_overhead);
for (i = 0; i < T_LAST; i++) t_timers[i] = 0.0;
/* measure init/finalize time (cold) */
ABT_timer_start(timer);
ABT_init(argc, argv);
ABT_finalize();
ABT_timer_stop_and_read(timer, &t_timers[T_INIT_FINALIZE_COLD]);
t_timers[T_INIT_FINALIZE_COLD] -= t_overhead;
/* measure init/finalize time */
for (i = 0; i < iter; i++) {
ABT_timer_start(timer);
ABT_init(argc, argv);
ABT_timer_stop_and_add(timer, &t_timers[T_INIT]);
ABT_timer_start(timer);
ABT_finalize();
ABT_timer_stop_and_add(timer, &t_timers[T_FINALIZE]);
}
t_timers[T_INIT] /= iter;
t_timers[T_INIT] -= t_overhead;
t_timers[T_FINALIZE] /= iter;
t_timers[T_FINALIZE] -= t_overhead;
t_timers[T_INIT_FINALIZE] = t_timers[T_INIT] + t_timers[T_FINALIZE];
/* measure time of init/finalize with work */
for (i = 0; i < iter; i++) {
ABT_timer_start(timer);
ABT_init(argc, argv);
ABT_timer_stop_and_add(timer, &t_timers[T_INIT_FINALIZE_WITH_WORK]);
ABT_xstream_create(ABT_SCHED_NULL, &xstream);
ABT_xstream_get_main_pools(xstream, 1, &pool);
ABT_thread_create(pool, thread_func, NULL, ABT_THREAD_ATTR_NULL,
NULL);
ABT_xstream_join(xstream);
ABT_xstream_free(&xstream);
ABT_timer_start(timer);
ABT_finalize();
ABT_timer_stop_and_add(timer, &t_timers[T_INIT_FINALIZE_WITH_WORK]);
}
t_timers[T_INIT_FINALIZE_WITH_WORK] /= iter;
t_timers[T_INIT_FINALIZE_WITH_WORK] -= t_overhead;
/* output */
int line_size = 45;
ABT_test_print_line(stdout, '-', line_size);
printf("Avg. execution time (in seconds, %d times)\n", iter);
ABT_test_print_line(stdout, '-', line_size);
for (i = 0; i < T_LAST; i++) {
printf("%-23s %.9f\n", t_names[i], t_timers[i]);
}
ABT_test_print_line(stdout, '-', line_size);
ABT_timer_free(&timer);
return EXIT_SUCCESS;
}
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[])
{
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;
}
