[OpenMP] Implementation of OMPT reduction callbacks

[protze.joachim]

Summary

Including two tests

These callbacks were added late to the 5.0 specification, an implementation is missing.

[protze.joachim]

Apply clang-format

[jdoerfert]

openmp/runtime/src/kmp_barrier.cpp

140

These seem to be basically the same block(s) of code multiple times. Can we outline them into a helper (including the guards)?

openmp/runtime/test/ompt/callback.h

430

Can we not have default clauses so we get appropriate warnings?

[protze.joachim]

Implement requested changes.

@jdoerfert is this as you intended the change?

[jdoerfert]

In D70395#1764045, @protze.joachim wrote:

Implement requested changes.

@jdoerfert is this as you intended the change?

Yes. I was expecting functions but macros seems to be the solution used in this code so far.
Do you think it is worth it to do it for openmp/runtime/src/kmp_csupport.cpp as well?

openmp/runtime/test/ompt/callback.h

411

default again.

[protze.joachim]

Macro outsourced to ompt_specific, which is included by both kmp source files.
Tested for LIBOMP_OMPT_SUPPORT on/off builds.

[protze.joachim]

In D70395#1764086, @jdoerfert wrote:

Yes. I was expecting functions but macros seems to be the solution used in this code so far.

Macros are used, because variables are in the callers scope and re-used by the end macro.

Probably a question of style: should there be a do{}while(0) to catch the ;?
We need the ; after the macro invocation to please clang-format

[jdoerfert]

Thx, looks much cleaner (IMHO) and good to me now.

In D70395#1776898, @protze.joachim wrote:

In D70395#1764086, @jdoerfert wrote:

Yes. I was expecting functions but macros seems to be the solution used in this code so far.

Macros are used, because variables are in the callers scope and re-used by the end macro.

I would have tried references/pointers but I guess macros are the state-of-the-art solution here.

Probably a question of style: should there be a do{}while(0) to catch the ;?
We need the ; after the macro invocation to please clang-format

Sure.

[protze.joachim]

Pushed as 3356e268.

Not sure why this DR was not closed.

openmp/runtime/src/kmp_barrier.cpp

#if USE_ITT_BUILD && USE_ITT_NOTIFY
       }
 #endif
       if (reduce) {
         KA_TRACE(100,
                  ("__kmp_linear_barrier_gather: T#%d(%d:%d) += T#%d(%d:%d)\n",
                   gtid, team->t.t_id, tid, __kmp_gtid_from_tid(i, team),
                   team->t.t_id, i));
         ANNOTATE_REDUCE_AFTER(reduce);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);
+  ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);
+  void *return_address = OMPT_LOAD_RETURN_ADDRESS(gtid);
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_begin, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
         (*reduce)(this_thr->th.th_local.reduce_data,
                   other_threads[i]->th.th_local.reduce_data);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_end, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
         ANNOTATE_REDUCE_BEFORE(reduce);
         ANNOTATE_REDUCE_BEFORE(&team->t.t_bar);
       }
     }
     // Don't have to worry about sleep bit here or atomic since team setting
     team_bar->b_arrived = new_state;
     KA_TRACE(20, ("__kmp_linear_barrier_gather: T#%d(%d:%d) set team %d "
                   "arrived(%p) = %llu\n",
#if USE_ITT_BUILD && USE_ITT_NOTIFY
       }
 #endif
       if (reduce) {
         KA_TRACE(100,
                  ("__kmp_tree_barrier_gather: T#%d(%d:%d) += T#%d(%d:%u)\n",
                   gtid, team->t.t_id, tid, __kmp_gtid_from_tid(child_tid, team),
                   team->t.t_id, child_tid));
         ANNOTATE_REDUCE_AFTER(reduce);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);
+  ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);
+  void *return_address = OMPT_LOAD_RETURN_ADDRESS(gtid);
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_begin, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
         (*reduce)(this_thr->th.th_local.reduce_data,
                   child_thr->th.th_local.reduce_data);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_end, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
         ANNOTATE_REDUCE_BEFORE(reduce);
         ANNOTATE_REDUCE_BEFORE(&team->t.t_bar);
       }
       child++;
       child_tid++;
     } while (child <= branch_factor && child_tid < nproc);
   }
 
#if USE_ITT_BUILD && USE_ITT_NOTIFY
       }
 #endif
       if (reduce) {
         KA_TRACE(100,
                  ("__kmp_hyper_barrier_gather: T#%d(%d:%d) += T#%d(%d:%u)\n",
                   gtid, team->t.t_id, tid, __kmp_gtid_from_tid(child_tid, team),
                   team->t.t_id, child_tid));
         ANNOTATE_REDUCE_AFTER(reduce);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);
+  ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);
+  void *return_address = OMPT_LOAD_RETURN_ADDRESS(gtid);
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_begin, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
         (*reduce)(this_thr->th.th_local.reduce_data,
                   child_thr->th.th_local.reduce_data);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_end, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
         ANNOTATE_REDUCE_BEFORE(reduce);
         ANNOTATE_REDUCE_BEFORE(&team->t.t_bar);
       }
     }
   }
 
   if (KMP_MASTER_TID(tid)) {
     // Need to update the team arrived pointer if we are the master thread
if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
                 : team->t.t_bar[bt].b_arrived | thr_bar->leaf_state;
         KA_TRACE(20, ("__kmp_hierarchical_barrier_gather: T#%d(%d:%d) waiting "
                       "for leaf kids\n",
                       gtid, team->t.t_id, tid));
         kmp_flag_64 flag(&thr_bar->b_arrived, leaf_state);
         flag.wait(this_thr, FALSE USE_ITT_BUILD_ARG(itt_sync_obj));
         if (reduce) {
           ANNOTATE_REDUCE_AFTER(reduce);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);
+  ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);
+  void *return_address = OMPT_LOAD_RETURN_ADDRESS(gtid);
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_begin, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
           for (child_tid = tid + 1; child_tid <= tid + thr_bar->leaf_kids;
                ++child_tid) {
             KA_TRACE(100, ("__kmp_hierarchical_barrier_gather: T#%d(%d:%d) += "
                            "T#%d(%d:%d)\n",
                            gtid, team->t.t_id, tid,
                            __kmp_gtid_from_tid(child_tid, team), team->t.t_id,
                            child_tid));
             ANNOTATE_BARRIER_END(other_threads[child_tid]);
             (*reduce)(this_thr->th.th_local.reduce_data,
                       other_threads[child_tid]->th.th_local.reduce_data);
           }
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_end, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
           ANNOTATE_REDUCE_BEFORE(reduce);
           ANNOTATE_REDUCE_BEFORE(&team->t.t_bar);
         }
         // clear leaf_state bits
         KMP_TEST_THEN_AND64(&thr_bar->b_arrived, ~(thr_bar->leaf_state));
       }
       // Next, wait for higher level children on each child's b_arrived flag
       for (kmp_uint32 d = 1; d < thr_bar->my_level;

openmp/runtime/src/kmp_csupport.cpp

#endif
   // a thread-specific "th_local.reduction_method" variable is used currently
   // each thread executes 'determine' and 'set' lines (no need to execute by one
   // thread, to avoid unness extra syncs)
 
   packed_reduction_method = __kmp_determine_reduction_method(
       loc, global_tid, num_vars, reduce_size, reduce_data, reduce_func, lck);
   __KMP_SET_REDUCTION_METHOD(global_tid, packed_reduction_method);
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  kmp_info_t *this_thr = __kmp_threads[global_tid];
+  ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);
+  ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);
+  void *return_address = OMPT_LOAD_RETURN_ADDRESS(global_tid);
+#endif
   if (packed_reduction_method == critical_reduce_block) {
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_begin, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
+
     __kmp_enter_critical_section_reduce_block(loc, global_tid, lck);
     retval = 1;
 
   } else if (packed_reduction_method == empty_reduce_block) {
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_begin, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
+
     // usage: if team size == 1, no synchronization is required ( Intel
     // platforms only )
     retval = 1;
 
   } else if (packed_reduction_method == atomic_reduce_block) {
 
     retval = 2;
 
void __kmpc_end_reduce_nowait(ident_t *loc, kmp_int32 global_tid,
                               kmp_critical_name *lck) {
 
   PACKED_REDUCTION_METHOD_T packed_reduction_method;
 
   KA_TRACE(10, ("__kmpc_end_reduce_nowait() enter: called T#%d\n", global_tid));
 
   packed_reduction_method = __KMP_GET_REDUCTION_METHOD(global_tid);
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  kmp_info_t *this_thr = __kmp_threads[global_tid];
+  ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);
+  ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);
+  void *return_address = OMPT_LOAD_RETURN_ADDRESS(global_tid);
+#endif
+
   if (packed_reduction_method == critical_reduce_block) {
 
     __kmp_end_critical_section_reduce_block(loc, global_tid, lck);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_end, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
 
   } else if (packed_reduction_method == empty_reduce_block) {
 
     // usage: if team size == 1, no synchronization is required ( on Intel
     // platforms only )
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+
+    if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_end, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
+
   } else if (packed_reduction_method == atomic_reduce_block) {
 
     // neither master nor other workers should get here
     //     (code gen does not generate this call in case 2: atomic reduce block)
     // actually it's better to remove this elseif at all;
     // after removal this value will checked by the 'else' and will assert
 
   } else if (TEST_REDUCTION_METHOD(packed_reduction_method,
                                    tree_reduce_block)) {
 
     // only master gets here
+    // OMPT: tree reduction is annotated in the barrier code
 
   } else {
 
     // should never reach this block
     KMP_ASSERT(0); // "unexpected method"
   }
 
   if (__kmp_env_consistency_check)
#endif
 
   th = __kmp_thread_from_gtid(global_tid);
   teams_swapped = __kmp_swap_teams_for_teams_reduction(th, &team, &task_state);
 
   packed_reduction_method = __kmp_determine_reduction_method(
       loc, global_tid, num_vars, reduce_size, reduce_data, reduce_func, lck);
   __KMP_SET_REDUCTION_METHOD(global_tid, packed_reduction_method);
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  kmp_info_t *this_thr = __kmp_threads[global_tid];
+  ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);
+  ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);
+  void *return_address = OMPT_LOAD_RETURN_ADDRESS(global_tid);
+#endif
+
   if (packed_reduction_method == critical_reduce_block) {
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_begin, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
     __kmp_enter_critical_section_reduce_block(loc, global_tid, lck);
     retval = 1;
 
   } else if (packed_reduction_method == empty_reduce_block) {
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_begin, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
     // usage: if team size == 1, no synchronization is required ( Intel
     // platforms only )
     retval = 1;
 
   } else if (packed_reduction_method == atomic_reduce_block) {
 
     retval = 2;
 
void __kmpc_end_reduce(ident_t *loc, kmp_int32 global_tid,
 
   th = __kmp_thread_from_gtid(global_tid);
   teams_swapped = __kmp_swap_teams_for_teams_reduction(th, &team, &task_state);
 
   packed_reduction_method = __KMP_GET_REDUCTION_METHOD(global_tid);
 
   // this barrier should be visible to a customer and to the threading profile
   // tool (it's a terminating barrier on constructs if NOWAIT not specified)
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  kmp_info_t *this_thr = __kmp_threads[global_tid];
+  ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);
+  ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);
+  void *return_address = OMPT_LOAD_RETURN_ADDRESS(global_tid);
+#endif
 
   if (packed_reduction_method == critical_reduce_block) {
     __kmp_end_critical_section_reduce_block(loc, global_tid, lck);
  
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_end, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
+
 // TODO: implicit barrier: should be exposed
 #if OMPT_SUPPORT
     ompt_frame_t *ompt_frame;
     if (ompt_enabled.enabled) {
       __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
       if (ompt_frame->enter_frame.ptr == NULL)
         ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
       OMPT_STORE_RETURN_ADDRESS(global_tid);
     }
 #endif
 #if USE_ITT_NOTIFY
     __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
     __kmp_barrier(bs_plain_barrier, global_tid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     if (ompt_enabled.enabled) {
       ompt_frame->enter_frame = ompt_data_none;
     }
 #endif
 
   } else if (packed_reduction_method == empty_reduce_block) {
 
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (ompt_enabled.enabled && ompt_enabled.ompt_callback_reduction) {
+      ompt_callbacks.ompt_callback(ompt_callback_reduction)(
+          ompt_sync_region_reduction, ompt_scope_end, my_parallel_data,
+          my_task_data, return_address);
+    }
+#endif
+
 // usage: if team size==1, no synchronization is required (Intel platforms only)
 
 // TODO: implicit barrier: should be exposed
 #if OMPT_SUPPORT
     ompt_frame_t *ompt_frame;
     if (ompt_enabled.enabled) {
       __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
       if (ompt_frame->enter_frame.ptr == NULL)

openmp/runtime/src/ompt-event-specific.h

 #define ompt_callback_mutex_acquire_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 #define ompt_callback_mutex_acquired_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 #define ompt_callback_nest_lock_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_flush_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_cancel_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
-#define ompt_callback_reduction_implemented ompt_event_UNIMPLEMENTED
+#define ompt_callback_reduction_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_dispatch_implemented ompt_event_UNIMPLEMENTED
 
 #endif

openmp/runtime/test/ompt/callback.h

case ompt_scope_begin:
           printf("%" PRIu64 ": ompt_event_wait_barrier_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra);
           break;
         case ompt_sync_region_taskwait:
           printf("%" PRIu64 ": ompt_event_wait_taskwait_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra);
           break;
         case ompt_sync_region_taskgroup:
           printf("%" PRIu64 ": ompt_event_wait_taskgroup_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra);
           break;
-        case ompt_sync_region_reduction:
+        default:
           break;
       }
       break;
     case ompt_scope_end:
       switch(kind)
       {
         case ompt_sync_region_barrier:
         case ompt_sync_region_barrier_implicit:
         case ompt_sync_region_barrier_explicit:
         case ompt_sync_region_barrier_implementation:
           printf("%" PRIu64 ": ompt_event_wait_barrier_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra);
           break;
         case ompt_sync_region_taskwait:
           printf("%" PRIu64 ": ompt_event_wait_taskwait_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra);
           break;
         case ompt_sync_region_taskgroup:
           printf("%" PRIu64 ": ompt_event_wait_taskgroup_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra);
           break;
-        case ompt_sync_region_reduction:
-          break;
-      }
+        default:
+          break;
+      }
+}
+
+static void
+on_ompt_callback_reduction(
+  ompt_sync_region_kind_t kind,
+  ompt_scope_endpoint_t endpoint,
+  ompt_data_t *parallel_data,
+  ompt_data_t *task_data,
+  const void *codeptr_ra)
+{
+  switch(endpoint)
+  {
+    case ompt_scope_begin:
+        printf("%" PRIu64 ": ompt_event_reduction_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra);
+      break;
+    case ompt_scope_end:
+        printf("%" PRIu64 ": ompt_event_reduction_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra);
       break;
   }
 }
 
 static void
 on_ompt_callback_flush(
     ompt_data_t *thread_data,
     const void *codeptr_ra)
int ompt_initialize(
   ompt_enumerate_mutex_impls = (ompt_enumerate_mutex_impls_t) lookup("ompt_enumerate_mutex_impls");
 
   register_callback(ompt_callback_mutex_acquire);
   register_callback_t(ompt_callback_mutex_acquired, ompt_callback_mutex_t);
   register_callback_t(ompt_callback_mutex_released, ompt_callback_mutex_t);
   register_callback(ompt_callback_nest_lock);
   register_callback(ompt_callback_sync_region);
   register_callback_t(ompt_callback_sync_region_wait, ompt_callback_sync_region_t);
+  register_callback_t(ompt_callback_reduction, ompt_callback_sync_region_t);
   register_callback(ompt_callback_control_tool);
   register_callback(ompt_callback_flush);
   register_callback(ompt_callback_cancel);
   register_callback(ompt_callback_implicit_task);
   register_callback_t(ompt_callback_lock_init, ompt_callback_mutex_acquire_t);
   register_callback_t(ompt_callback_lock_destroy, ompt_callback_mutex_t);
   register_callback(ompt_callback_work);
   register_callback(ompt_callback_master);

openmp/runtime/test/ompt/synchronization/reduction/empty_reduce.c

+// RUN: %libomp-compile-and-run | FileCheck %s
+// RUN: %libomp-compile -DNOWAIT && %libomp-run | FileCheck %s
+// REQUIRES: ompt
+#include "callback.h"
+#include <omp.h>
+
+#ifdef NOWAIT
+  #define FOR_CLAUSE nowait
+#else
+  #define FOR_CLAUSE
+#endif
+
+int main()
+{
+  int sum = 0;
+  int i;
+  #pragma omp parallel num_threads(1)
+  #pragma omp for reduction(+:sum) FOR_CLAUSE
+  for(i = 0; i < 10000; i++)
+  {
+    sum += i;
+  }
+
+  // CHECK: 0: NULL_POINTER=[[NULL:.*$]]
+
+  // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin:
+  // CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]]
+  // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID:[0-9]+]]
+
+  // CHECK: {{^}}[[MASTER_ID]]: ompt_event_reduction_begin: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+  // CHECK: {{^}}[[MASTER_ID]]: ompt_event_reduction_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+
+  return 0;
+}

openmp/runtime/test/ompt/synchronization/reduction/tree_reduce.c

+// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
+// REQUIRES: ompt
+#include "callback.h"
+#include <omp.h>
+
+#ifdef NOWAIT
+  #define FOR_CLAUSE nowait
+#else
+  #define FOR_CLAUSE
+#endif
+
+int main()
+{
+  int sum = 0;
+  int i;
+  #pragma omp parallel num_threads(5)
+  #pragma omp for reduction(+:sum) FOR_CLAUSE
+  for(i = 0; i < 10000; i++)
+  {
+    sum += i;
+  }
+
+  // CHECK: 0: NULL_POINTER=[[NULL:.*$]]
+
+  // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin:
+  // CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]]
+  // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID:[0-9]+]]
+
+  // order and distribution to threads not determined
+  // CHECK-DAG: {{^}}{{[0-f]+}}: ompt_event_reduction_begin: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+  // CHECK-DAG: {{^}}{{[0-f]+}}: ompt_event_reduction_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+  // CHECK-DAG: {{^}}{{[0-f]+}}: ompt_event_reduction_begin: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+  // CHECK-DAG: {{^}}{{[0-f]+}}: ompt_event_reduction_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+  // CHECK-DAG: {{^}}{{[0-f]+}}: ompt_event_reduction_begin: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+  // CHECK-DAG: {{^}}{{[0-f]+}}: ompt_event_reduction_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+  // CHECK-DAG: {{^}}{{[0-f]+}}: ompt_event_reduction_begin: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+  // CHECK-DAG: {{^}}{{[0-f]+}}: ompt_event_reduction_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=
+
+  return 0;
+}