| // RUN: %libomp-cxx-compile-and-run | |
| // RUN: %libomp-cxx-compile -DFLG=1 && %libomp-run | |
| // GCC-5 is needed for OpenMP 4.0 support (taskgroup) | |
| // XFAIL: gcc-4 | |
| #include <cstdio> | |
| #include <cmath> | |
| #include <cassert> | |
| #include <omp.h> | |
| // Total number of loop iterations, should be multiple of T for this test | |
| #define N 10000 | |
| // Flag to request lazy (1) or eager (0) allocation of reduction objects | |
| #ifndef FLG | |
| #define FLG 0 | |
| #endif | |
| /* | |
| // initial user's code that corresponds to pseudo code of the test | |
| #pragma omp taskgroup task_reduction(+:i,j) task_reduction(*:x) | |
| { | |
| for( int l = 0; l < N; ++l ) { | |
| #pragma omp task firstprivate(l) in_reduction(+:i) in_reduction(*:x) | |
| { | |
| i += l; | |
| if( l%2 ) | |
| x *= 1.0 / (l + 1); | |
| else | |
| x *= (l + 1); | |
| } | |
| } | |
| #pragma omp taskgroup task_reduction(-:i,k) task_reduction(+:y) | |
| { | |
| for( int l = 0; l < N; ++l ) { | |
| #pragma omp task firstprivate(l) in_reduction(+:j,y) \ | |
| in_reduction(*:x) in_reduction(-:k) | |
| { | |
| j += l; | |
| k -= l; | |
| y += (double)l; | |
| if( l%2 ) | |
| x *= 1.0 / (l + 1); | |
| else | |
| x *= (l + 1); | |
| } | |
| #pragma omp task firstprivate(l) in_reduction(+:y) in_reduction(-:i,k) | |
| { | |
| i -= l; | |
| k -= l; | |
| y += (double)l; | |
| } | |
| #pragma omp task firstprivate(l) in_reduction(+:j) in_reduction(*:x) | |
| { | |
| j += l; | |
| if( l%2 ) | |
| x *= 1.0 / (l + 1); | |
| else | |
| x *= (l + 1); | |
| } | |
| } | |
| } // inner reduction | |
| for( int l = 0; l < N; ++l ) { | |
| #pragma omp task firstprivate(l) in_reduction(+:j) | |
| j += l; | |
| } | |
| } // outer reduction | |
| */ | |
| //------------------------------------------------ | |
| // OpenMP runtime library routines | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| extern void* __kmpc_task_reduction_get_th_data(int gtid, void* tg, void* item); | |
| extern void* __kmpc_task_reduction_init(int gtid, int num, void* data); | |
| extern int __kmpc_global_thread_num(void*); | |
| #ifdef __cplusplus | |
| } | |
| #endif | |
| //------------------------------------------------ | |
| // Compiler-generated code | |
| typedef struct _task_red_item { | |
| void *shar; // shared reduction item | |
| size_t size; // size of data item | |
| void *f_init; // data initialization routine | |
| void *f_fini; // data finalization routine | |
| void *f_comb; // data combiner routine | |
| unsigned flags; | |
| } _task_red_item_t; | |
| // int:+ no need in init/fini callbacks, valid for subtraction | |
| void __red_int_add_comb(void *lhs, void *rhs) // combiner | |
| { *(int*)lhs += *(int*)rhs; } | |
| // long long:+ no need in init/fini callbacks, valid for subtraction | |
| void __red_llong_add_comb(void *lhs, void *rhs) // combiner | |
| { *(long long*)lhs += *(long long*)rhs; } | |
| // double:* no need in fini callback | |
| void __red_dbl_mul_init(void *data) // initializer | |
| { *(double*)data = 1.0; } | |
| void __red_dbl_mul_comb(void *lhs, void *rhs) // combiner | |
| { *(double*)lhs *= *(double*)rhs; } | |
| // double:+ no need in init/fini callbacks | |
| void __red_dbl_add_comb(void *lhs, void *rhs) // combiner | |
| { *(double*)lhs += *(double*)rhs; } | |
| // ============================== | |
| void calc_serial(int *pi, long long *pj, double *px, long long *pk, double *py) | |
| { | |
| for( int l = 0; l < N; ++l ) { | |
| *pi += l; | |
| if( l%2 ) | |
| *px *= 1.0 / (l + 1); | |
| else | |
| *px *= (l + 1); | |
| } | |
| for( int l = 0; l < N; ++l ) { | |
| *pj += l; | |
| *pk -= l; | |
| *py += (double)l; | |
| if( l%2 ) | |
| *px *= 1.0 / (l + 1); | |
| else | |
| *px *= (l + 1); | |
| *pi -= l; | |
| *pk -= l; | |
| *py += (double)l; | |
| *pj += l; | |
| if( l%2 ) | |
| *px *= 1.0 / (l + 1); | |
| else | |
| *px *= (l + 1); | |
| } | |
| for( int l = 0; l < N; ++l ) { | |
| *pj += l; | |
| } | |
| } | |
| //------------------------------------------------ | |
| // Test case | |
| int main() | |
| { | |
| int nthreads = omp_get_max_threads(); | |
| int err = 0; | |
| void** ptrs = (void**)malloc(nthreads*sizeof(void*)); | |
| // user's code ====================================== | |
| // variables for serial calculations: | |
| int is = 3; | |
| long long js = -9999999; | |
| double xs = 99999.0; | |
| long long ks = 99999999; | |
| double ys = -99999999.0; | |
| // variables for parallel calculations: | |
| int ip = 3; | |
| long long jp = -9999999; | |
| double xp = 99999.0; | |
| long long kp = 99999999; | |
| double yp = -99999999.0; | |
| calc_serial(&is, &js, &xs, &ks, &ys); | |
| // ================================================== | |
| for (int i = 0; i < nthreads; ++i) | |
| ptrs[i] = NULL; | |
| #pragma omp parallel | |
| { | |
| #pragma omp single nowait | |
| { | |
| // outer taskgroup reduces (i,j,x) | |
| #pragma omp taskgroup // task_reduction(+:i,j) task_reduction(*:x) | |
| { | |
| _task_red_item_t red_data[3]; | |
| red_data[0].shar = &ip; | |
| red_data[0].size = sizeof(ip); | |
| red_data[0].f_init = NULL; // RTL will zero thread-specific objects | |
| red_data[0].f_fini = NULL; // no destructors needed | |
| red_data[0].f_comb = (void*)&__red_int_add_comb; | |
| red_data[0].flags = FLG; | |
| red_data[1].shar = &jp; | |
| red_data[1].size = sizeof(jp); | |
| red_data[1].f_init = NULL; // RTL will zero thread-specific objects | |
| red_data[1].f_fini = NULL; // no destructors needed | |
| red_data[1].f_comb = (void*)&__red_llong_add_comb; | |
| red_data[1].flags = FLG; | |
| red_data[2].shar = &xp; | |
| red_data[2].size = sizeof(xp); | |
| red_data[2].f_init = (void*)&__red_dbl_mul_init; | |
| red_data[2].f_fini = NULL; // no destructors needed | |
| red_data[2].f_comb = (void*)&__red_dbl_mul_comb; | |
| red_data[2].flags = FLG; | |
| int gtid = __kmpc_global_thread_num(NULL); | |
| void* tg1 = __kmpc_task_reduction_init(gtid, 3, red_data); | |
| for( int l = 0; l < N; l += 2 ) { | |
| // 2 iterations per task to get correct x value; actually any even | |
| // number of iters per task will work, otherwise x looses precision | |
| #pragma omp task firstprivate(l) //in_reduction(+:i) in_reduction(*:x) | |
| { | |
| int gtid = __kmpc_global_thread_num(NULL); | |
| int *p_ip = (int*)__kmpc_task_reduction_get_th_data(gtid, tg1, &ip); | |
| double *p_xp = (double*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg1, &xp); | |
| if (!ptrs[gtid]) ptrs[gtid] = p_xp; | |
| // user's pseudo-code ============================== | |
| *p_ip += l; | |
| *p_xp *= (l + 1); | |
| *p_ip += l + 1; | |
| *p_xp *= 1.0 / (l + 2); | |
| // ================================================== | |
| } | |
| } | |
| // inner taskgroup reduces (i,k,y), i is same object as in outer one | |
| #pragma omp taskgroup // task_reduction(-:i,k) task_reduction(+:y) | |
| { | |
| _task_red_item_t red_data[3]; | |
| red_data[0].shar = &ip; | |
| red_data[0].size = sizeof(ip); | |
| red_data[0].f_init = NULL; // RTL will zero thread-specific objects | |
| red_data[0].f_fini = NULL; // no destructors needed | |
| red_data[0].f_comb = (void*)&__red_int_add_comb; | |
| red_data[0].flags = FLG; | |
| red_data[1].shar = &kp; | |
| red_data[1].size = sizeof(kp); | |
| red_data[1].f_init = NULL; // RTL will zero thread-specific objects | |
| red_data[1].f_fini = NULL; // no destructors needed | |
| red_data[1].f_comb = (void*)&__red_llong_add_comb; // same for + and - | |
| red_data[1].flags = FLG; | |
| red_data[2].shar = &yp; | |
| red_data[2].size = sizeof(yp); | |
| red_data[2].f_init = NULL; // RTL will zero thread-specific objects | |
| red_data[2].f_fini = NULL; // no destructors needed | |
| red_data[2].f_comb = (void*)&__red_dbl_add_comb; | |
| red_data[2].flags = FLG; | |
| int gtid = __kmpc_global_thread_num(NULL); | |
| void* tg2 = __kmpc_task_reduction_init(gtid, 3, red_data); | |
| for( int l = 0; l < N; l += 2 ) { | |
| #pragma omp task firstprivate(l) | |
| // in_reduction(+:j,y) in_reduction(*:x) in_reduction(-:k) | |
| { | |
| int gtid = __kmpc_global_thread_num(NULL); | |
| long long *p_jp = (long long*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg1, &jp); | |
| long long *p_kp = (long long*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg2, &kp); | |
| double *p_xp = (double*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg1, &xp); | |
| double *p_yp = (double*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg2, &yp); | |
| // user's pseudo-code ============================== | |
| *p_jp += l; | |
| *p_kp -= l; | |
| *p_yp += (double)l; | |
| *p_xp *= (l + 1); | |
| *p_jp += l + 1; | |
| *p_kp -= l + 1; | |
| *p_yp += (double)(l + 1); | |
| *p_xp *= 1.0 / (l + 2); | |
| // ================================================= | |
| { | |
| // the following code is here just to check __kmpc_task_reduction_get_th_data: | |
| int tid = omp_get_thread_num(); | |
| void *addr1; | |
| void *addr2; | |
| addr1 = __kmpc_task_reduction_get_th_data(gtid, tg1, &xp); // from shared | |
| addr2 = __kmpc_task_reduction_get_th_data(gtid, tg1, addr1); // from private | |
| if (addr1 != addr2) { | |
| #pragma omp atomic | |
| ++err; | |
| printf("Wrong thread-specific addresses %d s:%p p:%p\n", tid, addr1, addr2); | |
| } | |
| // from neighbour w/o taskgroup (should start lookup from current tg2) | |
| if (tid > 0) { | |
| if (ptrs[tid-1]) { | |
| addr2 = __kmpc_task_reduction_get_th_data(gtid, NULL, ptrs[tid-1]); | |
| if (addr1 != addr2) { | |
| #pragma omp atomic | |
| ++err; | |
| printf("Wrong thread-specific addresses %d s:%p n:%p\n", | |
| tid, addr1, addr2); | |
| } | |
| } | |
| } else { | |
| if (ptrs[nthreads-1]) { | |
| addr2 = __kmpc_task_reduction_get_th_data(gtid, NULL, ptrs[nthreads-1]); | |
| if (addr1 != addr2) { | |
| #pragma omp atomic | |
| ++err; | |
| printf("Wrong thread-specific addresses %d s:%p n:%p\n", | |
| tid, addr1, addr2); | |
| } | |
| } | |
| } | |
| // ---------------------------------------------- | |
| } | |
| } | |
| #pragma omp task firstprivate(l) | |
| // in_reduction(+:y) in_reduction(-:i,k) | |
| { | |
| int gtid = __kmpc_global_thread_num(NULL); | |
| int *p_ip = (int*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg2, &ip); | |
| long long *p_kp = (long long*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg2, &kp); | |
| double *p_yp = (double*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg2, &yp); | |
| // user's pseudo-code ============================== | |
| *p_ip -= l; | |
| *p_kp -= l; | |
| *p_yp += (double)l; | |
| *p_ip -= l + 1; | |
| *p_kp -= l + 1; | |
| *p_yp += (double)(l + 1); | |
| // ================================================= | |
| } | |
| #pragma omp task firstprivate(l) | |
| // in_reduction(+:j) in_reduction(*:x) | |
| { | |
| int gtid = __kmpc_global_thread_num(NULL); | |
| long long *p_jp = (long long*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg1, &jp); | |
| double *p_xp = (double*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg1, &xp); | |
| // user's pseudo-code ============================== | |
| *p_jp += l; | |
| *p_xp *= (l + 1); | |
| *p_jp += l + 1; | |
| *p_xp *= 1.0 / (l + 2); | |
| // ================================================= | |
| } | |
| } | |
| } // inner reduction | |
| for( int l = 0; l < N; l += 2 ) { | |
| #pragma omp task firstprivate(l) // in_reduction(+:j) | |
| { | |
| int gtid = __kmpc_global_thread_num(NULL); | |
| long long *p_jp = (long long*)__kmpc_task_reduction_get_th_data( | |
| gtid, tg1, &jp); | |
| // user's pseudo-code ============================== | |
| *p_jp += l; | |
| *p_jp += l + 1; | |
| // ================================================= | |
| } | |
| } | |
| } // outer reduction | |
| } // end single | |
| } // end parallel | |
| // check results | |
| #if _DEBUG | |
| printf("reduction flags = %u\n", FLG); | |
| #endif | |
| if (ip == is && jp == js && ks == kp && | |
| fabs(xp - xs) < 0.01 && fabs(yp - ys) < 0.01) | |
| printf("passed\n"); | |
| else | |
| printf("failed,\n ser:(%d %lld %f %lld %f)\n par:(%d %lld %f %lld %f)\n", | |
| is, js, xs, ks, ys, | |
| ip, jp, xp, kp, yp); | |
| return 0; | |
| } |