GLT_func_prefix void glt_finalize() {
for (int i = 1; i < main_team->num_xstreams; i++) {
CHECK(ABT_xstream_join(main_team->team[i]),ABT_SUCCESS);
CHECK(ABT_xstream_free(&main_team->team[i]),ABT_SUCCESS);
}
CHECK(ABT_finalize(),ABT_SUCCESS);
}
int main(int argc, char *argv[])
{
ABT_xstream xstreams[NUM_XSTREAMS];
ABT_sched scheds[NUM_XSTREAMS];
int num_pools[NUM_XSTREAMS];
ABT_pool *pools[NUM_XSTREAMS];
int i, k;
ABT_init(argc, argv);
/* Create schedulers */
for (i = 0; i < NUM_XSTREAMS; i++) {
ABT_sched_predef predef;
predef = (i % 2) ? ABT_SCHED_BASIC : ABT_SCHED_PRIO;
ABT_sched_create_basic(predef, 0, NULL, ABT_SCHED_CONFIG_NULL,
&scheds[i]);
}
/* Create ESs */
ABT_xstream_self(&xstreams[0]);
ABT_xstream_set_main_sched(xstreams[0], scheds[0]);
for (i = 1; i < NUM_XSTREAMS; i++) {
ABT_xstream_create(scheds[i], &xstreams[i]);
}
/* Get the pools associated with each scheduler */
for (i = 0; i < NUM_XSTREAMS; i++) {
ABT_sched_get_num_pools(scheds[i], &num_pools[i]);
pools[i] = (ABT_pool *)malloc(num_pools[i] * sizeof(ABT_pool));
ABT_sched_get_pools(scheds[i], num_pools[i], 0, pools[i]);
}
/* Create ULTs */
for (i = 0; i < NUM_XSTREAMS; i++) {
for (k = num_pools[i] - 1; k >= 0; k--) {
size_t tid = (i + 1) * 10 + k;
ABT_thread_create(pools[i][k], thread_hello, (void *)tid,
ABT_THREAD_ATTR_NULL, NULL);
}
}
/* Join & Free */
for (i = 1; i < NUM_XSTREAMS; i++) {
ABT_xstream_join(xstreams[i]);
ABT_xstream_free(&xstreams[i]);
}
for (i = 0; i < NUM_XSTREAMS; i++) {
free(pools[i]);
}
ABT_finalize();
return 0;
}
void accalt_finalize() {
#ifdef ARGOBOTS
for (int i = 1; i < main_team->num_xstreams; i++) {
ABT_xstream_join(main_team->team[i]);
ABT_xstream_free(&main_team->team[i]);
}
ABT_finalize();
#endif
#ifdef MASSIVETHREADS
myth_fini(); //MassiveThreads
#endif
}
void
__kmp_global_destroy(void)
{
int i;
ABT_mutex_free(&__kmp_global.stdio_lock);
ABT_mutex_free(&__kmp_global.cat_lock);
ABT_mutex_free(&__kmp_global.initz_lock);
ABT_mutex_free(&__kmp_global.task_team_lock);
for (i = 0; i < KMP_NUM_CRIT_LOCKS; i++) {
ABT_mutex_free(&__kmp_global.crit_lock[i]);
}
ABT_finalize();
__kmp_init_global = FALSE;
}
int main(int argc, char *argv[])
{
if (argc != 5) {
printf("Usage: %s <max # of ESs> <timeout> <server> <port>\n", argv[0]);
return EXIT_SUCCESS;
}
max_xstreams = atoi(argv[1]);
if (max_xstreams < 1) {
max_xstreams = 1;
}
num_xstreams = max_xstreams;
g_timeout = atof(argv[2]);
printf("# of ESs : %d\n", max_xstreams);
printf("Timeout : %.1f sec.\n", g_timeout);
abt_connect(argv[3], argv[4]);
/* Initialize */
ABT_init(argc, argv);
init(num_xstreams);
thread_add_sched((void *)0);
finalize();
/* Finalize */
ABT_finalize();
abt_disconnect();
printf("Done.\n"); fflush(stdout);
return EXIT_SUCCESS;
}
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);
}
static void
abt_fini(void)
{
ABT_finalize();
}
/* 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;
}
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;
}
/* 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;
}
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;
}
int main(int argc, char *argv[])
{
int i, j;
int ntasks;
int start, end;
int num_xstreams;
ABT_xstream *xstreams;
vector_scal_task_args_t *args;
struct timeval t_start, t_end, t_end2;
char *str, *endptr;
float *a;
num_xstreams = argc > 1 ? atoi(argv[1]) : NUM_XSTREAMS;
if (argc > 2) {
str = argv[2];
}
ntasks = argc > 2 ? strtoll(str, &endptr, 10) : NUM_TASKS;
if (ntasks < num_xstreams) {
ntasks = num_xstreams;
}
printf("# of ESs: %d\n", num_xstreams);
xstreams = (ABT_xstream *)malloc(sizeof(ABT_xstream) * num_xstreams);
args = (vector_scal_task_args_t *)malloc(sizeof(vector_scal_task_args_t)
* num_xstreams);
g_pools = (ABT_pool *)malloc(sizeof(ABT_pool) * num_xstreams);
a = malloc(sizeof(float) * ntasks);
for (i = 0; i < ntasks; i++) {
a[i] = i + 100.0f;
}
/* 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]);
}
/* Work here */
start = end = 0;
int bloc = ntasks / num_xstreams;
int rest = ntasks % num_xstreams;
gettimeofday(&t_start, NULL);
for (j = 0; j < num_xstreams; j++) {
start = end;
end = start + bloc;
if (j < rest) {
end++;
}
args[j].ptr = a;
args[j].value = 0.9f;
args[j].start = start;
args[j].end = end;
args[j].id = j;
ABT_thread_create_on_xstream(xstreams[j], task_creator,
(void *)&args[j], ABT_THREAD_ATTR_NULL,
NULL);
}
gettimeofday(&t_end2, NULL);
for (i = 0; i < num_xstreams; i++) {
size_t size;
do {
ABT_thread_yield();
ABT_pool_get_size(g_pools[i], &size);
} while (size != 0);
}
gettimeofday(&t_end, NULL);
for (i = 0; i < ntasks; i++) {
if (a[i] != (i + 100.0f) * 0.9f) {
printf("error: a[%d]\n", i);
}
}
double time = (t_end.tv_sec * 1000000 + t_end.tv_usec)
- (t_start.tv_sec * 1000000 + t_start.tv_usec);
double time2 = (t_end2.tv_sec * 1000000 + t_end2.tv_usec)
- (t_start.tv_sec * 1000000 + t_start.tv_usec);
printf("nxstreams: %d\nntasks %d\nTime(s): %f\n",
num_xstreams, ntasks, time / 1000000.0);
/* join ESs */
for (i = 1; i < num_xstreams; i++) {
ABT_xstream_join(xstreams[i]);
ABT_xstream_free(&xstreams[i]);
}
printf("Creation time=%f\n", time2 / 1000000.0);
ABT_finalize();
free(xstreams);
return EXIT_SUCCESS;
}
