This is an archive of the discontinued LLVM Phabricator instance.

Differential D60976

[OpenMP] Implement task modifier for reduction clause
ClosedPublic

Authored by jlpeyton on Apr 22 2019, 12:00 PM.

Details

Reviewers
tlwilmar
hbae
Commits
rOMP359710: [OpenMP] Implement task modifier for reduction clause
rGa8426ac8c2db: [OpenMP] Implement task modifier for reduction clause
rL359710: [OpenMP] Implement task modifier for reduction clause
Summary

Implemented task modifier in two versions - one without taking into account
omp_orig variable (the omp_orig still can be processed by compiler without help
of the library, but each reduction object will need separate initializer with
global access to omp_orig), another with omp_orig variable included into
interface (single initializer can be used for multiple reduction objects of
the same type). Second version can be used when the omp_orig is not globally
accessible, or to optimize code in case of multiple reduction objects
of the same type.

Patch by Andrey Churbanov

Diff Detail

Repository
rL LLVM

Event Timeline

jlpeyton created this revision.Apr 22 2019, 12:00 PM
Herald added subscribers: jdoerfert, jfb, guansong. · View Herald TranscriptApr 22 2019, 12:00 PM
hbae added a comment.Apr 24 2019, 2:19 PM

Just a few typos in the comment.

runtime/src/kmp_tasking.cpp
2043 ↗(On Diff #196110)

set us by -> set up by

2049 ↗(On Diff #196110)

paramemter -> parameter

2066 ↗(On Diff #196110)

paramemters -> parameters

2072 ↗(On Diff #196110)

set us by -> set up by

2081 ↗(On Diff #196110)

paramemters -> parameters

2164 ↗(On Diff #196110)

note than -> note that

jlpeyton updated this revision to Diff 197398.Apr 30 2019, 12:02 PM

Fixed spelling errors

hbae accepted this revision.Apr 30 2019, 1:27 PM

LGTM.

This revision is now accepted and ready to land.Apr 30 2019, 1:27 PM
Closed by commit rL359710: [OpenMP] Implement task modifier for reduction clause (authored by jlpeyton). · Explain WhyMay 1 2019, 10:51 AM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptMay 1 2019, 10:51 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript

Revision Contents

Diff 197594

openmp/trunk/runtime/src/dllexports

Show First 20 Lines • Show All 398 Lines • ▼ Show 20 Lines
# OpenMP 5.0 entry points # OpenMP 5.0 entry points
%ifndef stub %ifndef stub
%ifdef OMP_50 %ifdef OMP_50
__kmpc_task_reduction_init 268 __kmpc_task_reduction_init 268
__kmpc_task_reduction_get_th_data 269 __kmpc_task_reduction_get_th_data 269
# USED FOR 4.5 __kmpc_critical_with_hint 270 # USED FOR 4.5 __kmpc_critical_with_hint 270
__kmpc_get_target_offload 271 __kmpc_get_target_offload 271
__kmpc_omp_reg_task_with_affinity 272 __kmpc_omp_reg_task_with_affinity 272
__kmpc_pause_resource 273 __kmpc_pause_resource 273
__kmpc_task_reduction_modifier_init 274
__kmpc_task_reduction_modifier_fini 275
# __kmpc_task_allow_completion_event 276
__kmpc_taskred_init 277
__kmpc_taskred_modifier_init 278
%endif %endif
%endif %endif
# User API entry points that have both lower- and upper- case versions for Fortran. # User API entry points that have both lower- and upper- case versions for Fortran.
# Number for lowercase version is indicated. Number for uppercase is obtained by adding 1000. # Number for lowercase version is indicated. Number for uppercase is obtained by adding 1000.
# User API entry points are entry points that start with 'kmp_' or 'omp_'. # User API entry points are entry points that start with 'kmp_' or 'omp_'.
omp_destroy_lock 700 omp_destroy_lock 700
▲ Show 20 Lines • Show All 818 Lines • Show Last 20 Lines

openmp/trunk/runtime/src/kmp.h

Show First 20 Lines • Show All 2,676 Lines • ▼ Show 20 Lines
typedef struct KMP_ALIGN_CACHE kmp_base_team { typedef struct KMP_ALIGN_CACHE kmp_base_team {
// Synchronization Data // Synchronization Data
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
KMP_ALIGN_CACHE kmp_ordered_team_t t_ordered; KMP_ALIGN_CACHE kmp_ordered_team_t t_ordered;
kmp_balign_team_t t_bar[bs_last_barrier]; kmp_balign_team_t t_bar[bs_last_barrier];
std::atomic<int> t_construct; // count of single directive encountered by team std::atomic<int> t_construct; // count of single directive encountered by team
char pad[sizeof(kmp_lock_t)]; // padding to maintain performance on big iron char pad[sizeof(kmp_lock_t)]; // padding to maintain performance on big iron
// [0] - parallel / [1] - worksharing task reduction data shared by taskgroups
std::atomic<void *> t_tg_reduce_data[2]; // to support task modifier
std::atomic<int> t_tg_fini_counter[2]; // sync end of task reductions
// Master only // Master only
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
KMP_ALIGN_CACHE int t_master_tid; // tid of master in parent team KMP_ALIGN_CACHE int t_master_tid; // tid of master in parent team
int t_master_this_cons; // "this_construct" single counter of master in parent int t_master_this_cons; // "this_construct" single counter of master in parent
// team // team
ident_t *t_ident; // if volatile, have to change too much other crud to ident_t *t_ident; // if volatile, have to change too much other crud to
// volatile too // volatile too
kmp_team_p *t_parent; // parent team kmp_team_p *t_parent; // parent team
▲ Show 20 Lines • Show All 1,120 Lines • ▼ Show 20 Lines
KMP_EXPORT void __kmpc_taskloop(ident_t *loc, kmp_int32 gtid, kmp_task_t *task, KMP_EXPORT void __kmpc_taskloop(ident_t *loc, kmp_int32 gtid, kmp_task_t *task,
kmp_int32 if_val, kmp_uint64 *lb, kmp_int32 if_val, kmp_uint64 *lb,
kmp_uint64 *ub, kmp_int64 st, kmp_int32 nogroup, kmp_uint64 *ub, kmp_int64 st, kmp_int32 nogroup,
kmp_int32 sched, kmp_uint64 grainsize, kmp_int32 sched, kmp_uint64 grainsize,
void *task_dup); void *task_dup);
#endif #endif
#if OMP_50_ENABLED #if OMP_50_ENABLED
KMP_EXPORT void *__kmpc_task_reduction_init(int gtid, int num_data, void *data); KMP_EXPORT void *__kmpc_task_reduction_init(int gtid, int num_data, void *data);
KMP_EXPORT void *__kmpc_taskred_init(int gtid, int num_data, void *data);
KMP_EXPORT void *__kmpc_task_reduction_get_th_data(int gtid, void *tg, void *d); KMP_EXPORT void *__kmpc_task_reduction_get_th_data(int gtid, void *tg, void *d);
KMP_EXPORT void *__kmpc_task_reduction_modifier_init(ident_t *loc, int gtid,
int is_ws, int num,
void *data);
KMP_EXPORT void *__kmpc_taskred_modifier_init(ident_t *loc, int gtid, int is_ws,
int num, void *data);
KMP_EXPORT void __kmpc_task_reduction_modifier_fini(ident_t *loc, int gtid,
int is_ws);
KMP_EXPORT kmp_int32 __kmpc_omp_reg_task_with_affinity( KMP_EXPORT kmp_int32 __kmpc_omp_reg_task_with_affinity(
ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *new_task, kmp_int32 naffins, ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *new_task, kmp_int32 naffins,
kmp_task_affinity_info_t *affin_list); kmp_task_affinity_info_t *affin_list);
#endif #endif
#endif #endif
/* Lock interface routines (fast versions with gtid passed in) */ /* Lock interface routines (fast versions with gtid passed in) */
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

openmp/trunk/runtime/src/kmp_tasking.cpp

Show First 20 Lines • Show All 2,013 Lines • ▼ Show 20 Lines KA_TRACE(10, ("__kmpc_omp_taskyield(exit): T#%d task %p resuming, "
"returning TASK_CURRENT_NOT_QUEUED\n", "returning TASK_CURRENT_NOT_QUEUED\n",
gtid, taskdata)); gtid, taskdata));
return TASK_CURRENT_NOT_QUEUED; return TASK_CURRENT_NOT_QUEUED;
} }
#if OMP_50_ENABLED #if OMP_50_ENABLED
// Task Reduction implementation // Task Reduction implementation
//
// Note: initial implementation didn't take into account the possibility
// to specify omp_orig for initializer of the UDR (user defined reduction).
// Corrected implementation takes into account the omp_orig object.
// Compiler is free to use old implementation if omp_orig is not specified.
typedef struct kmp_task_red_flags { /*!
unsigned lazy_priv : 1; // hint: (1) use lazy allocation (big objects) @ingroup BASIC_TYPES
unsigned reserved31 : 31; @{
} kmp_task_red_flags_t; */
// internal structure for reduction data item related info /*!
typedef struct kmp_task_red_data { Flags for special info per task reduction item.
void *reduce_shar; // shared reduction item */
size_t reduce_size; // size of data item typedef struct kmp_taskred_flags {
void *reduce_priv; // thread specific data /*! 1 - use lazy alloc/init (e.g. big objects, #tasks < #threads) */
void *reduce_pend; // end of private data for comparison op unsigned lazy_priv : 1;
void *reduce_init; // data initialization routine unsigned reserved31 : 31;
void *reduce_fini; // data finalization routine } kmp_taskred_flags_t;
void *reduce_comb; // data combiner routine
kmp_task_red_flags_t flags; // flags for additional info from compiler
} kmp_task_red_data_t;
// structure sent us by compiler - one per reduction item /*!
Internal struct for reduction data item related info set up by compiler.
*/
typedef struct kmp_task_red_input { typedef struct kmp_task_red_input {
void *reduce_shar; // shared reduction item void *reduce_shar; /**< shared between tasks item to reduce into */
size_t reduce_size; // size of data item size_t reduce_size; /**< size of data item in bytes */
void *reduce_init; // data initialization routine // three compiler-generated routines (init, fini are optional):
void *reduce_fini; // data finalization routine void *reduce_init; /**< data initialization routine (single parameter) */
void *reduce_comb; // data combiner routine void *reduce_fini; /**< data finalization routine */
kmp_task_red_flags_t flags; // flags for additional info from compiler void *reduce_comb; /**< data combiner routine */
kmp_taskred_flags_t flags; /**< flags for additional info from compiler */
} kmp_task_red_input_t; } kmp_task_red_input_t;
/*! /*!
@ingroup TASKING Internal struct for reduction data item related info saved by the library.
@param gtid Global thread ID */
@param num Number of data items to reduce typedef struct kmp_taskred_data {
@param data Array of data for reduction void *reduce_shar; /**< shared between tasks item to reduce into */
@return The taskgroup identifier size_t reduce_size; /**< size of data item */
kmp_taskred_flags_t flags; /**< flags for additional info from compiler */
void *reduce_priv; /**< array of thread specific items */
void *reduce_pend; /**< end of private data for faster comparison op */
// three compiler-generated routines (init, fini are optional):
void *reduce_comb; /**< data combiner routine */
void *reduce_init; /**< data initialization routine (two parameters) */
void *reduce_fini; /**< data finalization routine */
void *reduce_orig; /**< original item (can be used in UDR initializer) */
} kmp_taskred_data_t;
Initialize task reduction for the taskgroup. /*!
Internal struct for reduction data item related info set up by compiler.
New interface: added reduce_orig field to provide omp_orig for UDR initializer.
*/ */
void *__kmpc_task_reduction_init(int gtid, int num, void *data) { typedef struct kmp_taskred_input {
void *reduce_shar; /**< shared between tasks item to reduce into */
void *reduce_orig; /**< original reduction item used for initialization */
size_t reduce_size; /**< size of data item */
// three compiler-generated routines (init, fini are optional):
void *reduce_init; /**< data initialization routine (two parameters) */
void *reduce_fini; /**< data finalization routine */
void *reduce_comb; /**< data combiner routine */
kmp_taskred_flags_t flags; /**< flags for additional info from compiler */
} kmp_taskred_input_t;
/*!
@}
*/
template <typename T> void __kmp_assign_orig(kmp_taskred_data_t &item, T &src);
template <>
void __kmp_assign_orig<kmp_task_red_input_t>(kmp_taskred_data_t &item,
kmp_task_red_input_t &src) {
item.reduce_orig = NULL;
}
template <>
void __kmp_assign_orig<kmp_taskred_input_t>(kmp_taskred_data_t &item,
kmp_taskred_input_t &src) {
if (src.reduce_orig != NULL) {
item.reduce_orig = src.reduce_orig;
} else {
item.reduce_orig = src.reduce_shar;
} // non-NULL reduce_orig means new interface used
}
template <typename T> void __kmp_call_init(kmp_taskred_data_t &item, int j);
template <>
void __kmp_call_init<kmp_task_red_input_t>(kmp_taskred_data_t &item,
int offset) {
((void (*)(void *))item.reduce_init)((char *)(item.reduce_priv) + offset);
}
template <>
void __kmp_call_init<kmp_taskred_input_t>(kmp_taskred_data_t &item,
int offset) {
((void (*)(void *, void *))item.reduce_init)(
(char *)(item.reduce_priv) + offset, item.reduce_orig);
}
template <typename T>
void *__kmp_task_reduction_init(int gtid, int num, T *data) {
kmp_info_t *thread = __kmp_threads[gtid]; kmp_info_t *thread = __kmp_threads[gtid];
kmp_taskgroup_t *tg = thread->th.th_current_task->td_taskgroup; kmp_taskgroup_t *tg = thread->th.th_current_task->td_taskgroup;
kmp_int32 nth = thread->th.th_team_nproc; kmp_int32 nth = thread->th.th_team_nproc;
kmp_task_red_input_t *input = (kmp_task_red_input_t *)data; kmp_taskred_data_t *arr;
kmp_task_red_data_t *arr;
// check input data just in case // check input data just in case
KMP_ASSERT(tg != NULL); KMP_ASSERT(tg != NULL);
KMP_ASSERT(data != NULL); KMP_ASSERT(data != NULL);
KMP_ASSERT(num > 0); KMP_ASSERT(num > 0);
if (nth == 1) { if (nth == 1) {
KA_TRACE(10, ("__kmpc_task_reduction_init: T#%d, tg %p, exiting nth=1\n", KA_TRACE(10, ("__kmpc_task_reduction_init: T#%d, tg %p, exiting nth=1\n",
gtid, tg)); gtid, tg));
return (void *)tg; return (void *)tg;
} }
KA_TRACE(10, ("__kmpc_task_reduction_init: T#%d, taskgroup %p, #items %d\n", KA_TRACE(10, ("__kmpc_task_reduction_init: T#%d, taskgroup %p, #items %d\n",
gtid, tg, num)); gtid, tg, num));
arr = (kmp_task_red_data_t *)__kmp_thread_malloc( arr = (kmp_taskred_data_t *)__kmp_thread_malloc(
thread, num * sizeof(kmp_task_red_data_t)); thread, num * sizeof(kmp_taskred_data_t));
for (int i = 0; i < num; ++i) { for (int i = 0; i < num; ++i) {
void (*f_init)(void *) = (void (*)(void *))(input[i].reduce_init); size_t size = data[i].reduce_size - 1;
size_t size = input[i].reduce_size - 1;
// round the size up to cache line per thread-specific item // round the size up to cache line per thread-specific item
size += CACHE_LINE - size % CACHE_LINE; size += CACHE_LINE - size % CACHE_LINE;
KMP_ASSERT(input[i].reduce_comb != NULL); // combiner is mandatory KMP_ASSERT(data[i].reduce_comb != NULL); // combiner is mandatory
arr[i].reduce_shar = input[i].reduce_shar; arr[i].reduce_shar = data[i].reduce_shar;
arr[i].reduce_size = size; arr[i].reduce_size = size;
arr[i].reduce_init = input[i].reduce_init; arr[i].flags = data[i].flags;
arr[i].reduce_fini = input[i].reduce_fini; arr[i].reduce_comb = data[i].reduce_comb;
arr[i].reduce_comb = input[i].reduce_comb; arr[i].reduce_init = data[i].reduce_init;
arr[i].flags = input[i].flags; arr[i].reduce_fini = data[i].reduce_fini;
if (!input[i].flags.lazy_priv) { __kmp_assign_orig<T>(arr[i], data[i]);
if (!arr[i].flags.lazy_priv) {
// allocate cache-line aligned block and fill it with zeros // allocate cache-line aligned block and fill it with zeros
arr[i].reduce_priv = __kmp_allocate(nth * size); arr[i].reduce_priv = __kmp_allocate(nth * size);
arr[i].reduce_pend = (char *)(arr[i].reduce_priv) + nth * size; arr[i].reduce_pend = (char *)(arr[i].reduce_priv) + nth * size;
if (f_init != NULL) { if (arr[i].reduce_init != NULL) {
// initialize thread-specific items // initialize all thread-specific items
for (int j = 0; j < nth; ++j) { for (int j = 0; j < nth; ++j) {
f_init((char *)(arr[i].reduce_priv) + j * size); __kmp_call_init<T>(arr[i], j * size);
} }
} }
} else { } else {
// only allocate space for pointers now, // only allocate space for pointers now,
// objects will be lazily allocated/initialized once requested // objects will be lazily allocated/initialized if/when requested
// note that __kmp_allocate zeroes the allocated memory
arr[i].reduce_priv = __kmp_allocate(nth * sizeof(void *)); arr[i].reduce_priv = __kmp_allocate(nth * sizeof(void *));
} }
} }
tg->reduce_data = (void *)arr; tg->reduce_data = (void *)arr;
tg->reduce_num_data = num; tg->reduce_num_data = num;
return (void *)tg; return (void *)tg;
} }
/*! /*!
@ingroup TASKING @ingroup TASKING
@param gtid Global thread ID @param gtid Global thread ID
@param num Number of data items to reduce
@param data Array of data for reduction
@return The taskgroup identifier
Initialize task reduction for the taskgroup.
Note: this entry supposes the optional compiler-generated initializer routine
has single parameter - pointer to object to be initialized. That means
the reduction either does not use omp_orig object, or the omp_orig is accessible
without help of the runtime library.
*/
void *__kmpc_task_reduction_init(int gtid, int num, void *data) {
return __kmp_task_reduction_init(gtid, num, (kmp_task_red_input_t *)data);
}
/*!
@ingroup TASKING
@param gtid Global thread ID
@param num Number of data items to reduce
@param data Array of data for reduction
@return The taskgroup identifier
Initialize task reduction for the taskgroup.
Note: this entry supposes the optional compiler-generated initializer routine
has two parameters, pointer to object to be initialized and pointer to omp_orig
*/
void *__kmpc_taskred_init(int gtid, int num, void *data) {
return __kmp_task_reduction_init(gtid, num, (kmp_taskred_input_t *)data);
}
// Copy task reduction data (except for shared pointers).
template <typename T>
void __kmp_task_reduction_init_copy(kmp_info_t *thr, int num, T *data,
kmp_taskgroup_t *tg, void *reduce_data) {
kmp_taskred_data_t *arr;
KA_TRACE(20, ("__kmp_task_reduction_init_copy: Th %p, init taskgroup %p,"
" from data %p\n",
thr, tg, reduce_data));
arr = (kmp_taskred_data_t *)__kmp_thread_malloc(
thr, num * sizeof(kmp_taskred_data_t));
// threads will share private copies, thunk routines, sizes, flags, etc.:
KMP_MEMCPY(arr, reduce_data, num * sizeof(kmp_taskred_data_t));
for (int i = 0; i < num; ++i) {
arr[i].reduce_shar = data[i].reduce_shar; // init unique shared pointers
}
tg->reduce_data = (void *)arr;
tg->reduce_num_data = num;
}
/*!
@ingroup TASKING
@param gtid Global thread ID
@param tskgrp The taskgroup ID (optional) @param tskgrp The taskgroup ID (optional)
@param data Shared location of the item @param data Shared location of the item
@return The pointer to per-thread data @return The pointer to per-thread data
Get thread-specific location of data item Get thread-specific location of data item
*/ */
void *__kmpc_task_reduction_get_th_data(int gtid, void *tskgrp, void *data) { void *__kmpc_task_reduction_get_th_data(int gtid, void *tskgrp, void *data) {
kmp_info_t *thread = __kmp_threads[gtid]; kmp_info_t *thread = __kmp_threads[gtid];
kmp_int32 nth = thread->th.th_team_nproc; kmp_int32 nth = thread->th.th_team_nproc;
if (nth == 1) if (nth == 1)
return data; // nothing to do return data; // nothing to do
kmp_taskgroup_t *tg = (kmp_taskgroup_t *)tskgrp; kmp_taskgroup_t *tg = (kmp_taskgroup_t *)tskgrp;
if (tg == NULL) if (tg == NULL)
tg = thread->th.th_current_task->td_taskgroup; tg = thread->th.th_current_task->td_taskgroup;
KMP_ASSERT(tg != NULL); KMP_ASSERT(tg != NULL);
kmp_task_red_data_t *arr = (kmp_task_red_data_t *)(tg->reduce_data); kmp_taskred_data_t *arr = (kmp_taskred_data_t *)(tg->reduce_data);
kmp_int32 num = tg->reduce_num_data; kmp_int32 num = tg->reduce_num_data;
kmp_int32 tid = thread->th.th_info.ds.ds_tid; kmp_int32 tid = thread->th.th_info.ds.ds_tid;
KMP_ASSERT(data != NULL); KMP_ASSERT(data != NULL);
while (tg != NULL) { while (tg != NULL) {
for (int i = 0; i < num; ++i) { for (int i = 0; i < num; ++i) {
if (!arr[i].flags.lazy_priv) { if (!arr[i].flags.lazy_priv) {
if (data == arr[i].reduce_shar || if (data == arr[i].reduce_shar ||
(data >= arr[i].reduce_priv && data < arr[i].reduce_pend)) (data >= arr[i].reduce_priv && data < arr[i].reduce_pend))
return (char *)(arr[i].reduce_priv) + tid * arr[i].reduce_size; return (char *)(arr[i].reduce_priv) + tid * arr[i].reduce_size;
} else { } else {
// check shared location first // check shared location first
void **p_priv = (void **)(arr[i].reduce_priv); void **p_priv = (void **)(arr[i].reduce_priv);
if (data == arr[i].reduce_shar) if (data == arr[i].reduce_shar)
goto found; goto found;
// check if we get some thread specific location as parameter // check if we get some thread specific location as parameter
for (int j = 0; j < nth; ++j) for (int j = 0; j < nth; ++j)
if (data == p_priv[j]) if (data == p_priv[j])
goto found; goto found;
continue; // not found, continue search continue; // not found, continue search
found: found:
if (p_priv[tid] == NULL) { if (p_priv[tid] == NULL) {
// allocate thread specific object lazily // allocate thread specific object lazily
void (*f_init)(void *) = (void (*)(void *))(arr[i].reduce_init);
p_priv[tid] = __kmp_allocate(arr[i].reduce_size); p_priv[tid] = __kmp_allocate(arr[i].reduce_size);
if (f_init != NULL) { if (arr[i].reduce_init != NULL) {
f_init(p_priv[tid]); if (arr[i].reduce_orig != NULL) { // new interface
((void (*)(void *, void *))arr[i].reduce_init)(
p_priv[tid], arr[i].reduce_orig);
} else { // old interface (single parameter)
((void (*)(void *))arr[i].reduce_init)(p_priv[tid]);
}
} }
} }
return p_priv[tid]; return p_priv[tid];
} }
} }
tg = tg->parent; tg = tg->parent;
arr = (kmp_task_red_data_t *)(tg->reduce_data); arr = (kmp_taskred_data_t *)(tg->reduce_data);
num = tg->reduce_num_data; num = tg->reduce_num_data;
} }
KMP_ASSERT2(0, "Unknown task reduction item"); KMP_ASSERT2(0, "Unknown task reduction item");
return NULL; // ERROR, this line never executed return NULL; // ERROR, this line never executed
} }
// Finalize task reduction. // Finalize task reduction.
// Called from __kmpc_end_taskgroup() // Called from __kmpc_end_taskgroup()
static void __kmp_task_reduction_fini(kmp_info_t *th, kmp_taskgroup_t *tg) { static void __kmp_task_reduction_fini(kmp_info_t *th, kmp_taskgroup_t *tg) {
kmp_int32 nth = th->th.th_team_nproc; kmp_int32 nth = th->th.th_team_nproc;
KMP_DEBUG_ASSERT(nth > 1); // should not be called if nth == 1 KMP_DEBUG_ASSERT(nth > 1); // should not be called if nth == 1
kmp_task_red_data_t *arr = (kmp_task_red_data_t *)tg->reduce_data; kmp_taskred_data_t *arr = (kmp_taskred_data_t *)tg->reduce_data;
kmp_int32 num = tg->reduce_num_data; kmp_int32 num = tg->reduce_num_data;
for (int i = 0; i < num; ++i) { for (int i = 0; i < num; ++i) {
void *sh_data = arr[i].reduce_shar; void *sh_data = arr[i].reduce_shar;
void (*f_fini)(void *) = (void (*)(void *))(arr[i].reduce_fini); void (*f_fini)(void *) = (void (*)(void *))(arr[i].reduce_fini);
void (*f_comb)(void *, void *) = void (*f_comb)(void *, void *) =
(void (*)(void *, void *))(arr[i].reduce_comb); (void (*)(void *, void *))(arr[i].reduce_comb);
if (!arr[i].flags.lazy_priv) { if (!arr[i].flags.lazy_priv) {
void *pr_data = arr[i].reduce_priv; void *pr_data = arr[i].reduce_priv;
Show All 16 Lines if (!arr[i].flags.lazy_priv) {
} }
} }
__kmp_free(arr[i].reduce_priv); __kmp_free(arr[i].reduce_priv);
} }
__kmp_thread_free(th, arr); __kmp_thread_free(th, arr);
tg->reduce_data = NULL; tg->reduce_data = NULL;
tg->reduce_num_data = 0; tg->reduce_num_data = 0;
} }
// Cleanup task reduction data for parallel or worksharing,
// do not touch task private data other threads still working with.
// Called from __kmpc_end_taskgroup()
static void __kmp_task_reduction_clean(kmp_info_t *th, kmp_taskgroup_t *tg) {
__kmp_thread_free(th, tg->reduce_data);
tg->reduce_data = NULL;
tg->reduce_num_data = 0;
}
template <typename T>
void *__kmp_task_reduction_modifier_init(ident_t *loc, int gtid, int is_ws,
int num, T *data) {
kmp_info_t *thr = __kmp_threads[gtid];
kmp_int32 nth = thr->th.th_team_nproc;
__kmpc_taskgroup(loc, gtid); // form new taskgroup first
if (nth == 1) {
KA_TRACE(10,
("__kmpc_reduction_modifier_init: T#%d, tg %p, exiting nth=1\n",
gtid, thr->th.th_current_task->td_taskgroup));
return (void *)thr->th.th_current_task->td_taskgroup;
}
kmp_team_t *team = thr->th.th_team;
void *reduce_data;
kmp_taskgroup_t *tg;
reduce_data = KMP_ATOMIC_LD_RLX(&team->t.t_tg_reduce_data[is_ws]);
if (reduce_data == NULL &&
__kmp_atomic_compare_store(&team->t.t_tg_reduce_data[is_ws], reduce_data,
(void *)1)) {
// single thread enters this block to initialize common reduction data
KMP_DEBUG_ASSERT(reduce_data == NULL);
// first initialize own data, then make a copy other threads can use
tg = (kmp_taskgroup_t *)__kmp_task_reduction_init<T>(gtid, num, data);
reduce_data = __kmp_thread_malloc(thr, num * sizeof(kmp_taskred_data_t));
KMP_MEMCPY(reduce_data, tg->reduce_data, num * sizeof(kmp_taskred_data_t));
// fini counters should be 0 at this point
KMP_DEBUG_ASSERT(KMP_ATOMIC_LD_RLX(&team->t.t_tg_fini_counter[0]) == 0);
KMP_DEBUG_ASSERT(KMP_ATOMIC_LD_RLX(&team->t.t_tg_fini_counter[1]) == 0);
KMP_ATOMIC_ST_REL(&team->t.t_tg_reduce_data[is_ws], reduce_data);
} else {
while (
(reduce_data = KMP_ATOMIC_LD_ACQ(&team->t.t_tg_reduce_data[is_ws])) ==
(void *)1) { // wait for task reduction initialization
KMP_CPU_PAUSE();
}
KMP_DEBUG_ASSERT(reduce_data > (void *)1); // should be valid pointer here
tg = thr->th.th_current_task->td_taskgroup;
__kmp_task_reduction_init_copy<T>(thr, num, data, tg, reduce_data);
}
return tg;
}
/*!
@ingroup TASKING
@param loc Source location info
@param gtid Global thread ID
@param is_ws Is 1 if the reduction is for worksharing, 0 otherwise
@param num Number of data items to reduce
@param data Array of data for reduction
@return The taskgroup identifier
Initialize task reduction for a parallel or worksharing.
Note: this entry supposes the optional compiler-generated initializer routine
has single parameter - pointer to object to be initialized. That means
the reduction either does not use omp_orig object, or the omp_orig is accessible
without help of the runtime library.
*/
void *__kmpc_task_reduction_modifier_init(ident_t *loc, int gtid, int is_ws,
int num, void *data) {
return __kmp_task_reduction_modifier_init(loc, gtid, is_ws, num,
(kmp_task_red_input_t *)data);
}
/*!
@ingroup TASKING
@param loc Source location info
@param gtid Global thread ID
@param is_ws Is 1 if the reduction is for worksharing, 0 otherwise
@param num Number of data items to reduce
@param data Array of data for reduction
@return The taskgroup identifier
Initialize task reduction for a parallel or worksharing.
Note: this entry supposes the optional compiler-generated initializer routine
has two parameters, pointer to object to be initialized and pointer to omp_orig
*/
void *__kmpc_taskred_modifier_init(ident_t *loc, int gtid, int is_ws, int num,
void *data) {
return __kmp_task_reduction_modifier_init(loc, gtid, is_ws, num,
(kmp_taskred_input_t *)data);
}
/*!
@ingroup TASKING
@param loc Source location info
@param gtid Global thread ID
@param is_ws Is 1 if the reduction is for worksharing, 0 otherwise
Finalize task reduction for a parallel or worksharing.
*/
void __kmpc_task_reduction_modifier_fini(ident_t *loc, int gtid, int is_ws) {
__kmpc_end_taskgroup(loc, gtid);
}
#endif #endif
#if OMP_40_ENABLED #if OMP_40_ENABLED
// __kmpc_taskgroup: Start a new taskgroup // __kmpc_taskgroup: Start a new taskgroup
void __kmpc_taskgroup(ident_t *loc, int gtid) { void __kmpc_taskgroup(ident_t *loc, int gtid) {
kmp_info_t *thread = __kmp_threads[gtid]; kmp_info_t *thread = __kmp_threads[gtid];
kmp_taskdata_t *taskdata = thread->th.th_current_task; kmp_taskdata_t *taskdata = thread->th.th_current_task;
kmp_taskgroup_t *tg_new = kmp_taskgroup_t *tg_new =
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
#if USE_ITT_BUILD #if USE_ITT_BUILD
if (itt_sync_obj != NULL) if (itt_sync_obj != NULL)
__kmp_itt_taskwait_finished(gtid, itt_sync_obj); __kmp_itt_taskwait_finished(gtid, itt_sync_obj);
#endif /* USE_ITT_BUILD */ #endif /* USE_ITT_BUILD */
} }
KMP_DEBUG_ASSERT(taskgroup->count == 0); KMP_DEBUG_ASSERT(taskgroup->count == 0);
#if OMP_50_ENABLED #if OMP_50_ENABLED
if (taskgroup->reduce_data != NULL) // need to reduce? if (taskgroup->reduce_data != NULL) { // need to reduce?
int cnt;
void *reduce_data;
kmp_team_t *t = thread->th.th_team;
kmp_taskred_data_t *arr = (kmp_taskred_data_t *)taskgroup->reduce_data;
// check if <priv> data of the first reduction variable shared for the team
void *priv0 = arr[0].reduce_priv;
if ((reduce_data = KMP_ATOMIC_LD_ACQ(&t->t.t_tg_reduce_data[0])) != NULL &&
((kmp_taskred_data_t *)reduce_data)[0].reduce_priv == priv0) {
// finishing task reduction on parallel
cnt = KMP_ATOMIC_INC(&t->t.t_tg_fini_counter[0]);
if (cnt == thread->th.th_team_nproc - 1) {
// we are the last thread passing __kmpc_reduction_modifier_fini()
// finalize task reduction:
__kmp_task_reduction_fini(thread, taskgroup);
// cleanup fields in the team structure:
// TODO: is relaxed store enough here (whole barrier should follow)?
__kmp_thread_free(thread, reduce_data);
KMP_ATOMIC_ST_REL(&t->t.t_tg_reduce_data[0], NULL);
KMP_ATOMIC_ST_REL(&t->t.t_tg_fini_counter[0], 0);
} else {
// we are not the last thread passing __kmpc_reduction_modifier_fini(),
// so do not finalize reduction, just clean own copy of the data
__kmp_task_reduction_clean(thread, taskgroup);
}
} else if ((reduce_data = KMP_ATOMIC_LD_ACQ(&t->t.t_tg_reduce_data[1])) !=
NULL &&
((kmp_taskred_data_t *)reduce_data)[0].reduce_priv == priv0) {
// finishing task reduction on worksharing
cnt = KMP_ATOMIC_INC(&t->t.t_tg_fini_counter[1]);
if (cnt == thread->th.th_team_nproc - 1) {
// we are the last thread passing __kmpc_reduction_modifier_fini()
__kmp_task_reduction_fini(thread, taskgroup); __kmp_task_reduction_fini(thread, taskgroup);
// cleanup fields in team structure:
// TODO: is relaxed store enough here (whole barrier should follow)?
__kmp_thread_free(thread, reduce_data);
KMP_ATOMIC_ST_REL(&t->t.t_tg_reduce_data[1], NULL);
KMP_ATOMIC_ST_REL(&t->t.t_tg_fini_counter[1], 0);
} else {
// we are not the last thread passing __kmpc_reduction_modifier_fini(),
// so do not finalize reduction, just clean own copy of the data
__kmp_task_reduction_clean(thread, taskgroup);
}
} else {
// finishing task reduction on taskgroup
__kmp_task_reduction_fini(thread, taskgroup);
}
}
#endif #endif
// Restore parent taskgroup for the current task // Restore parent taskgroup for the current task
taskdata->td_taskgroup = taskgroup->parent; taskdata->td_taskgroup = taskgroup->parent;
__kmp_thread_free(thread, taskgroup); __kmp_thread_free(thread, taskgroup);
KA_TRACE(10, ("__kmpc_end_taskgroup(exit): T#%d task %p finished waiting\n", KA_TRACE(10, ("__kmpc_end_taskgroup(exit): T#%d task %p finished waiting\n",
gtid, taskdata)); gtid, taskdata));
ANNOTATE_HAPPENS_AFTER(taskdata); ANNOTATE_HAPPENS_AFTER(taskdata);
▲ Show 20 Lines • Show All 1,952 Lines • Show Last 20 Lines

openmp/trunk/runtime/test/tasking/kmp_task_modifier_simple_par_new.cpp

// RUN: %libomp-cxx-compile-and-run
#include <stdio.h>
#include <omp.h>
#define NT 4
#define INIT 10
/*
The test emulates code generation needed for reduction with task modifier on
parallel construct.
Note: tasks could just use in_reduction clause, but compiler does not accept
this because of bug: it mistakenly requires reduction item to be shared, which
is only true for reduction on worksharing and wrong for task reductions.
*/
//------------------------------------------------
// 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_modifier_init(void *loc, int gtid, int
// is_ws, int num, void* data);
extern void *__kmpc_taskred_modifier_init(void *loc, int gtid, int is_ws,
int num, void *data);
extern void __kmpc_task_reduction_modifier_fini(void *loc, int gtid, int is_ws);
extern int __kmpc_global_thread_num(void *);
#ifdef __cplusplus
}
#endif
//------------------------------------------------
// Compiler-generated code
typedef struct red_input {
void *reduce_shar; /**< shared between tasks item to reduce into */
void *reduce_orig; /**< original reduction item used for initialization */
size_t reduce_size; /**< size of data item in bytes */
// three compiler-generated routines (init, fini are optional):
void *reduce_init; /**< data initialization routine (single paramemter) */
void *reduce_fini; /**< data finalization routine */
void *reduce_comb; /**< data combiner routine */
unsigned flags; /**< flags for additional info from compiler */
} red_input_t;
void i_comb(void *lhs, void *rhs) { *(int *)lhs += *(int *)rhs; }
int main() {
int var = INIT;
int *p_var_orig = &var;
omp_set_dynamic(0);
omp_set_num_threads(NT);
// #pragma omp parallel reduction(task,+:var)
#pragma omp parallel reduction(+ : var) shared(p_var_orig)
{
int gtid = __kmpc_global_thread_num(NULL);
void *tg; // pointer to taskgroup (optional)
red_input_t r_var;
r_var.reduce_shar = &var;
r_var.reduce_orig =
p_var_orig; // not used in this test but illustrates codegen
r_var.reduce_size = sizeof(var);
r_var.reduce_init = NULL;
r_var.reduce_fini = NULL;
r_var.reduce_comb = (void *)&i_comb;
tg = __kmpc_taskred_modifier_init(
NULL, // ident_t loc;
gtid,
0, // 1 - worksharing construct, 0 - parallel
1, // number of reduction objects
&r_var // related data
);
var++;
#pragma omp task /*in_reduction(+:var)*/ shared(var)
{
int gtid = __kmpc_global_thread_num(NULL);
int *p_var = (int *)__kmpc_task_reduction_get_th_data(gtid, tg, &var);
*p_var += 1;
}
if (omp_get_thread_num() > 0) {
#pragma omp task /*in_reduction(+:var)*/ shared(var)
{
int gtid = __kmpc_global_thread_num(NULL);
int *p_var = (int *)__kmpc_task_reduction_get_th_data(gtid, tg, &var);
*p_var += 1;
}
}
__kmpc_task_reduction_modifier_fini(NULL, gtid, 0);
}
if (var == INIT + NT * 3 - 1) {
printf("passed\n");
return 0;
} else {
printf("failed: var = %d (!= %d)\n", var, INIT + NT * 3 - 1);
return 1;
}
}

openmp/trunk/runtime/test/tasking/kmp_task_modifier_simple_par_old.cpp

// RUN: %libomp-cxx-compile-and-run
#include <stdio.h>
#include <omp.h>
#define NT 4
#define INIT 10
/*
The test emulates code generation needed for reduction with task modifier on
parallel construct.
Note: tasks could just use in_reduction clause, but compiler does not accept
this because of bug: it mistakenly requires reduction item to be shared, which
is only true for reduction on worksharing and wrong for task reductions.
*/
//------------------------------------------------
// 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_modifier_init(void *loc, int gtid, int is_ws,
int num, void *data);
extern void __kmpc_task_reduction_modifier_fini(void *loc, int gtid, int is_ws);
extern int __kmpc_global_thread_num(void *);
#ifdef __cplusplus
}
#endif
//------------------------------------------------
// Compiler-generated code
typedef struct red_input {
void *reduce_shar; /**< shared between tasks item to reduce into */
size_t reduce_size; /**< size of data item in bytes */
// three compiler-generated routines (init, fini are optional):
void *reduce_init; /**< data initialization routine (single paramemter) */
void *reduce_fini; /**< data finalization routine */
void *reduce_comb; /**< data combiner routine */
unsigned flags; /**< flags for additional info from compiler */
} red_input_t;
void i_comb(void *lhs, void *rhs) { *(int *)lhs += *(int *)rhs; }
int main() {
int var = INIT;
omp_set_dynamic(0);
omp_set_num_threads(NT);
// #pragma omp parallel reduction(task,+:var)
#pragma omp parallel reduction(+ : var)
{
int gtid = __kmpc_global_thread_num(NULL);
void *tg; // pointer to taskgroup (optional)
red_input_t r_var;
r_var.reduce_shar = &var;
r_var.reduce_size = sizeof(var);
r_var.reduce_init = NULL;
r_var.reduce_fini = NULL;
r_var.reduce_comb = (void *)&i_comb;
tg = __kmpc_task_reduction_modifier_init(
NULL, // ident_t loc;
gtid,
0, // 1 - worksharing construct, 0 - parallel
1, // number of reduction objects
&r_var // related data
);
var++;
#pragma omp task /*in_reduction(+:var)*/ shared(var)
{
int gtid = __kmpc_global_thread_num(NULL);
int *p_var = (int *)__kmpc_task_reduction_get_th_data(gtid, tg, &var);
*p_var += 1;
}
if (omp_get_thread_num() > 0) {
#pragma omp task /*in_reduction(+:var)*/ shared(var)
{
int gtid = __kmpc_global_thread_num(NULL);
int *p_var = (int *)__kmpc_task_reduction_get_th_data(gtid, tg, &var);
*p_var += 1;
}
}
__kmpc_task_reduction_modifier_fini(NULL, gtid, 0);
}
if (var == INIT + NT * 3 - 1) {
printf("passed\n");
return 0;
} else {
printf("failed: var = %d (!= %d)\n", var, INIT + NT * 3 - 1);
return 1;
}
}

openmp/trunk/runtime/test/tasking/kmp_task_modifier_simple_ws_new.cpp

// RUN: %libomp-cxx-compile-and-run
#include <stdio.h>
#include <omp.h>
#define NT 4
#define INIT 10
/*
The test emulates code generation needed for reduction with task modifier on
parallel construct.
Note: tasks could just use in_reduction clause, but compiler does not accept
this because of bug: it mistakenly requires reduction item to be shared, which
is only true for reduction on worksharing and wrong for task reductions.
*/
//------------------------------------------------
// 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_modifier_init(void *loc, int gtid, int
// flags, int num, void* data);
extern void *__kmpc_taskred_modifier_init(void *loc, int gtid, int is_ws,
int num, void *data);
extern void __kmpc_task_reduction_modifier_fini(void *loc, int gtid, int is_ws);
extern int __kmpc_global_thread_num(void *);
#ifdef __cplusplus
}
#endif
//------------------------------------------------
// Compiler-generated code
typedef struct red_input {
void *reduce_shar; /**< shared between tasks item to reduce into */
void *reduce_orig; /**< original reduction item used for initialization */
size_t reduce_size; /**< size of data item in bytes */
// three compiler-generated routines (init, fini are optional):
void *reduce_init; /**< data initialization routine (single paramemter) */
void *reduce_fini; /**< data finalization routine */
void *reduce_comb; /**< data combiner routine */
unsigned flags; /**< flags for additional info from compiler */
} red_input_t;
void i_comb(void *lhs, void *rhs) { *(int *)lhs += *(int *)rhs; }
int main() {
int var = INIT;
int *p_var_orig = &var;
int i;
omp_set_dynamic(0);
omp_set_num_threads(NT);
#pragma omp parallel private(i) shared(p_var_orig)
// #pragma omp for reduction(task,+:var)
#pragma omp for reduction(+ : var)
for (i = 0; i < NT; ++i) // single iteration per thread
{
// generated code, which actually should be placed before
// loop iterations distribution, but placed here just to show the idea,
// and to keep correctness the loop count is equal to number of threads
int gtid = __kmpc_global_thread_num(NULL);
void *tg; // pointer to taskgroup (optional)
red_input_t r_var;
r_var.reduce_shar = &var;
r_var.reduce_orig =
p_var_orig; // not used in this test but illustrates codegen
r_var.reduce_size = sizeof(var);
r_var.reduce_init = NULL;
r_var.reduce_fini = NULL;
r_var.reduce_comb = (void *)&i_comb;
tg = __kmpc_taskred_modifier_init(
NULL, // ident_t loc;
gtid,
1, // 1 - worksharing construct, 0 - parallel
1, // number of reduction objects
&r_var // related data
);
// end of generated code
var++;
#pragma omp task /*in_reduction(+:var)*/ shared(var)
{
// emulate task reduction here because of compiler bug:
// it mistakenly declines to accept in_reduction because var is private
// outside.
int gtid = __kmpc_global_thread_num(NULL);
int *p_var = (int *)__kmpc_task_reduction_get_th_data(gtid, tg, &var);
*p_var += 1;
}
if (omp_get_thread_num() > 0) {
#pragma omp task /*in_reduction(+:var)*/ shared(var)
{
int gtid = __kmpc_global_thread_num(NULL);
int *p_var = (int *)__kmpc_task_reduction_get_th_data(gtid, tg, &var);
*p_var += 1;
}
}
// generated code, which actually should be placed after loop completion
// but before barrier and before loop reduction. It placed here just to show
// the idea,
// and to keep correctness the loop count is equal to number of threads
__kmpc_task_reduction_modifier_fini(NULL, gtid, 1);
// end of generated code
}
if (var == INIT + NT * 3 - 1) {
printf("passed\n");
return 0;
} else {
printf("failed: var = %d (!= %d)\n", var, INIT + NT * 3 - 1);
return 1;
}
}

openmp/trunk/runtime/test/tasking/kmp_task_modifier_simple_ws_old.cpp

// RUN: %libomp-cxx-compile-and-run
#include <stdio.h>
#include <omp.h>
#define NT 4
#define INIT 10
/*
The test emulates code generation needed for reduction with task modifier on
parallel construct.
Note: tasks could just use in_reduction clause, but compiler does not accept
this because of bug: it mistakenly requires reduction item to be shared, which
is only true for reduction on worksharing and wrong for task reductions.
*/
//------------------------------------------------
// 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_modifier_init(void *loc, int gtid, int is_ws,
int num, void *data);
extern void __kmpc_task_reduction_modifier_fini(void *loc, int gtid, int is_ws);
extern int __kmpc_global_thread_num(void *);
#ifdef __cplusplus
}
#endif
//------------------------------------------------
// Compiler-generated code
typedef struct red_input {
void *reduce_shar; /**< shared between tasks item to reduce into */
size_t reduce_size; /**< size of data item in bytes */
// three compiler-generated routines (init, fini are optional):
void *reduce_init; /**< data initialization routine (single paramemter) */
void *reduce_fini; /**< data finalization routine */
void *reduce_comb; /**< data combiner routine */
unsigned flags; /**< flags for additional info from compiler */
} red_input_t;
void i_comb(void *lhs, void *rhs) { *(int *)lhs += *(int *)rhs; }
int main() {
int var = INIT;
int i;
omp_set_dynamic(0);
omp_set_num_threads(NT);
#pragma omp parallel private(i)
// #pragma omp for reduction(task,+:var)
#pragma omp for reduction(+ : var)
for (i = 0; i < NT; ++i) // single iteration per thread
{
// generated code, which actually should be placed before
// loop iterations distribution, but placed here just to show the idea,
// and to keep correctness the loop count is equal to number of threads
int gtid = __kmpc_global_thread_num(NULL);
void *tg; // pointer to taskgroup (optional)
red_input_t r_var;
r_var.reduce_shar = &var;
r_var.reduce_size = sizeof(var);
r_var.reduce_init = NULL;
r_var.reduce_fini = NULL;
r_var.reduce_comb = (void *)&i_comb;
tg = __kmpc_task_reduction_modifier_init(
NULL, // ident_t loc;
gtid,
1, // 1 - worksharing construct, 0 - parallel
1, // number of reduction objects
&r_var // related data
);
// end of generated code
var++;
#pragma omp task /*in_reduction(+:var)*/ shared(var)
{
// emulate task reduction here because of compiler bug:
// it mistakenly declines to accept in_reduction because var is private
// outside.
int gtid = __kmpc_global_thread_num(NULL);
int *p_var = (int *)__kmpc_task_reduction_get_th_data(gtid, tg, &var);
*p_var += 1;
}
if (omp_get_thread_num() > 0) {
#pragma omp task /*in_reduction(+:var)*/ shared(var)
{
int gtid = __kmpc_global_thread_num(NULL);
int *p_var = (int *)__kmpc_task_reduction_get_th_data(gtid, tg, &var);
*p_var += 1;
}
}
// generated code, which actually should be placed after loop completion
// but before barrier and before loop reduction. It placed here just to show
// the idea,
// and to keep correctness the loop count is equal to number of threads
__kmpc_task_reduction_modifier_fini(NULL, gtid, 1);
// end of generated code
}
if (var == INIT + NT * 3 - 1) {
printf("passed\n");
return 0;
} else {
printf("failed: var = %d (!= %d)\n", var, INIT + NT * 3 - 1);
return 1;
}
}