// 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;
}
Codebase Browser
llvm