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; }