[OMPT] Update types according to TR7

[sconvent]

Summary

Some types and callback signatures have changed from TR6 to TR7.
Major changes (only adding signatures and stubs):
(-remove idle callback) done by D48362
-add reduction and dispatch callback
-add get_task_memory and finalize_tool runtime entry points
-ompt_invoker_t becomes ompt_parallel_flag_t
-more types of sync_regions

[sconvent]

The removal of the idle callback was done in D48362 and is removed from this Patch.

[hbae]

runtime/src/kmp_csupport.cpp

2571–2572

Invocation of the lock function should be outside of the OMPT code.

2764

Same here.

[protze.joachim]

runtime/src/kmp_csupport.cpp

2571–2572

hbae is right, the function call must be there, only the variable is ompt-specific.

What you actually might do is leaving the declaration and assignment in the ifdef, but move the function call out. This should avoid compiler warnings on unused variable acquire_status

2764

You could do the same here, which will result in two separate ifdef blocks.

[Hahnfeld]

runtime/src/kmp_csupport.cpp

2571–2572

Just comment, no suggestion for either solution: You can also do (void) acquire_status;. I think that's used a lot in Clang's source code and will also avoid the compiler warning.

[Hahnfeld]

runtime/src/kmp_csupport.cpp

2571–2572

Fixed in D51303.

[sconvent]

Moved lock calls out of OMPT code

[hbae]

LGTM.

[protze.joachim]

LGTM

runtime/src/include/50/ompt.h.var

macro (ompt_enumerate_mutex_impls)      \
                                             \
     macro (ompt_set_callback)               \
     macro (ompt_get_callback)               \
                                             \
     macro (ompt_get_state)                  \
                                             \
     macro (ompt_get_parallel_info)          \
     macro (ompt_get_task_info)              \
+    macro (ompt_get_task_memory)            \
     macro (ompt_get_thread_data)            \
     macro (ompt_get_unique_id)              \
+    macro (ompt_finalize_tool)              \
                                             \
     macro(ompt_get_num_procs)               \
     macro(ompt_get_num_places)              \
     macro(ompt_get_place_proc_ids)          \
     macro(ompt_get_place_num)               \
     macro(ompt_get_partition_place_nums)    \
     macro(ompt_get_proc_id)                 \
                                             \
#define FOREACH_OMPT_EVENT(macro)                                                                                        \
     macro (ompt_callback_mutex_acquire,     ompt_callback_mutex_acquire_t,     26) /* mutex acquire                   */ \
     macro (ompt_callback_mutex_acquired,    ompt_callback_mutex_t,             27) /* mutex acquired                  */ \
                                                                                                                          \
     macro (ompt_callback_nest_lock,         ompt_callback_nest_lock_t,         28) /* nest lock                       */ \
                                                                                                                          \
     macro (ompt_callback_flush,             ompt_callback_flush_t,             29) /* after executing flush           */ \
                                                                                                                          \
     macro (ompt_callback_cancel,            ompt_callback_cancel_t,            30) /* cancel innermost binding region */ \
-    macro (ompt_callback_idle,              ompt_callback_idle_t,              31) /* begin or end idle state         */
+                                                                                                                         \
+    macro (ompt_callback_reduction,         ompt_callback_sync_region_t,       31) /* reduction                       */ \
+                                                                                                                         \
+    macro (ompt_callback_dispatch,          ompt_callback_dispatch_t,          32) /* dispatch of work                */
 
 
 
 /*****************************************************************************
  * data types
  *****************************************************************************/
 
 /*---------------------
typedef struct omp_frame_t {
     void *enter_frame;   /* previous frame is user code */
 } omp_frame_t;
 
 
 /*---------------------
  * dependences types
  *---------------------*/
 
-typedef enum ompt_task_dependence_flag_t {
+typedef enum ompt_task_dependence_type_t {
     // a two bit field for the dependence type
-    ompt_task_dependence_type_out   = 1,
-    ompt_task_dependence_type_in    = 2,
-    ompt_task_dependence_type_inout = 3,
-} ompt_task_dependence_flag_t;
+    ompt_task_dependence_type_in            = 1,
+    ompt_task_dependence_type_out           = 2,
+    ompt_task_dependence_type_inout         = 3,
+    ompt_task_dependence_type_mutexinoutset = 4
+} ompt_task_dependence_type_t;
 
 typedef struct ompt_task_dependence_t {
     void *variable_addr;
-    unsigned int dependence_flags;
+    ompt_task_dependence_type_t dependence_type;
 } ompt_task_dependence_t;
 
 
 /*****************************************************************************
  * enumerations for thread states and runtime events
  *****************************************************************************/
 
 /*---------------------

 /* initialization */
 typedef void (*ompt_interface_fn_t)(void);
 
 typedef ompt_interface_fn_t (*ompt_function_lookup_t)(
     const char *                          /* entry point to look up              */
 );
 
 /* threads */
-typedef enum ompt_thread_type_t {
+typedef enum ompt_thread_t {
     ompt_thread_initial = 1, // start the enumeration at 1
     ompt_thread_worker  = 2,
     ompt_thread_other   = 3,
     ompt_thread_unknown = 4
-} ompt_thread_type_t;
+} ompt_thread_t;
 
-typedef enum ompt_invoker_t {
-    ompt_invoker_program = 1,             /* program invokes master task         */
-    ompt_invoker_runtime = 2              /* runtime invokes master task         */
-} ompt_invoker_t;
+typedef enum ompt_parallel_flag_t {
+    ompt_parallel_invoker_program = 0x00000001,   /* program invokes master task */
+    ompt_parallel_invoker_runtime = 0x00000002,   /* runtime invokes master task */
+    ompt_parallel_league = 0x40000000,
+    ompt_parallel_team = 0x80000000
+} ompt_parallel_flag_t;
 
 typedef void (*ompt_callback_thread_begin_t) (
-    ompt_thread_type_t thread_type,       /* type of thread                      */
+    ompt_thread_t thread_type,            /* type of thread                      */
     ompt_data_t *thread_data              /* data of thread                      */
 );
 
 typedef void (*ompt_callback_thread_end_t) (
     ompt_data_t *thread_data              /* data of thread                      */
 );
 
 typedef void (*ompt_wait_callback_t) (
     omp_wait_id_t wait_id                /* wait data                           */
 );
 
 /* parallel and workshares */
 typedef enum ompt_scope_endpoint_t {
     ompt_scope_begin = 1,
     ompt_scope_end   = 2
 } ompt_scope_endpoint_t;
 
 
 /* implicit task */
 typedef void (*ompt_callback_implicit_task_t) (
     ompt_scope_endpoint_t endpoint,       /* endpoint of implicit task           */
     ompt_data_t *parallel_data,           /* data of parallel region             */
     ompt_data_t *task_data,               /* data of implicit task               */
-    unsigned int team_size,               /* team size                           */
-    unsigned int thread_num               /* thread number of calling thread     */
+    unsigned int actual_parallelism,      /* team size                           */
+    unsigned int index                    /* thread number of calling thread     */
 );
 
 typedef void (*ompt_callback_parallel_begin_t) (
     ompt_data_t *encountering_task_data,         /* data of encountering task           */
     const omp_frame_t *encountering_task_frame,  /* frame data of encountering task     */
     ompt_data_t *parallel_data,                  /* data of parallel region             */
     unsigned int requested_team_size,            /* requested number of threads in team */
-    ompt_invoker_t invoker,                      /* invoker of master task              */
+    int flag,                                    /* flag for additional information     */
     const void *codeptr_ra                       /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_parallel_end_t) (
     ompt_data_t *parallel_data,           /* data of parallel region             */
     ompt_data_t *encountering_task_data,  /* data of encountering task           */
-    ompt_invoker_t invoker,               /* invoker of master task              */ 
+    int flag,                             /* flag for additional information     */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 /* tasks */
-typedef enum ompt_task_type_t {
+typedef enum ompt_task_flag_t {
     ompt_task_initial    = 0x1,
     ompt_task_implicit   = 0x2,
     ompt_task_explicit   = 0x4,
     ompt_task_target     = 0x8,
     ompt_task_undeferred = 0x8000000,
     ompt_task_untied     = 0x10000000,
     ompt_task_final      = 0x20000000,
     ompt_task_mergeable  = 0x40000000,
     ompt_task_merged     = 0x80000000
-} ompt_task_type_t;
+} ompt_task_flag_t;
 
 typedef enum ompt_task_status_t {
     ompt_task_complete = 1,
     ompt_task_yield    = 2,
     ompt_task_cancel   = 3,
-    ompt_task_others   = 4
+    ompt_task_switch   = 4
 } ompt_task_status_t;
 
 typedef void (*ompt_callback_task_schedule_t) (
     ompt_data_t *prior_task_data,         /* data of prior task                  */
     ompt_task_status_t prior_task_status, /* status of prior task                */
     ompt_data_t *next_task_data           /* data of next task                   */
 );
 
 typedef void (*ompt_callback_task_create_t) (
     ompt_data_t *encountering_task_data,         /* data of parent task                 */
     const omp_frame_t *encountering_task_frame,  /* frame data for parent task          */
     ompt_data_t *new_task_data,                  /* data of created task                */
-    int type,                                    /* type of created task                */
+    int flag,                                    /* type of created task                */
     int has_dependences,                         /* created task has dependences        */
     const void *codeptr_ra                       /* return address of runtime call      */
 );
 
 /* task dependences */
 typedef void (*ompt_callback_task_dependences_t) (
     ompt_data_t *task_data,               /* data of task                        */
     const ompt_task_dependence_t *deps,   /* dependences of task                 */
     int ndeps                             /* dependences count of task           */
 );
 
 typedef void (*ompt_callback_task_dependence_t) (
     ompt_data_t *src_task_data,           /* data of source task                 */
     ompt_data_t *sink_task_data           /* data of sink task                   */
 );
 
 /* target and device */
-typedef enum ompt_target_type_t {
+typedef enum ompt_target_t {
     ompt_target = 1,
     ompt_target_enter_data = 2,
     ompt_target_exit_data = 3,
     ompt_target_update = 4
-} ompt_target_type_t;
+} ompt_target_t;
 
 typedef void (*ompt_callback_target_t) (
-    ompt_target_type_t kind,
+    ompt_target_t kind,
     ompt_scope_endpoint_t endpoint,
     uint64_t device_num,
     ompt_data_t *task_data,
     ompt_id_t target_id,
     const void *codeptr_ra
 );
 
 typedef enum ompt_target_data_op_t {
     ompt_target_data_alloc = 1,
     ompt_target_data_transfer_to_dev = 2,
     ompt_target_data_transfer_from_dev = 3,
     ompt_target_data_delete = 4
 } ompt_target_data_op_t;
 
 typedef void (*ompt_callback_target_data_op_t) (
     ompt_id_t target_id,
     ompt_id_t host_op_id,
     ompt_target_data_op_t optype,
-    void *host_addr,
-    void *device_addr,
-    size_t bytes
+    void *src_addr,
+    int src_device_num,
+    void *dest_addr,
+    int dest_device_num,
+    size_t bytes,
+    const void *codeptr_ra
 );
 
 typedef void (*ompt_callback_target_submit_t) (
     ompt_id_t target_id,
-    ompt_id_t host_op_id
+    ompt_id_t host_op_id,
+    unsigned int requested_num_teams
 );
 
 typedef void (*ompt_callback_target_map_t) (
     ompt_id_t target_id,
     unsigned int nitems,
     void **host_addr,
     void **device_addr,
     size_t *bytes,
-    unsigned int *mapping_flags
+    unsigned int *mapping_flags,
+    const void *codeptr_ra
 );
 
 typedef void (*ompt_callback_device_initialize_t) (
     uint64_t device_num,
     const char *type,
     ompt_device_t *device,
     ompt_function_lookup_t lookup,
     const char *documentation

 /* control_tool */
 typedef int (*ompt_callback_control_tool_t) (
     uint64_t command,                     /* command of control call             */
     uint64_t modifier,                    /* modifier of control call            */
     void *arg,                            /* argument of control call            */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
-typedef enum ompt_mutex_kind_t {
-    ompt_mutex           = 0x10,
-    ompt_mutex_lock      = 0x11,
-    ompt_mutex_nest_lock = 0x12,
-    ompt_mutex_critical  = 0x13,
-    ompt_mutex_atomic    = 0x14,
-    ompt_mutex_ordered   = 0x20
-} ompt_mutex_kind_t;
+typedef enum ompt_mutex_t {
+    ompt_mutex_lock      = 1,
+    ompt_mutex_nest_lock = 2,
+    ompt_mutex_critical  = 3,
+    ompt_mutex_atomic    = 4,
+    ompt_mutex_ordered   = 5
+} ompt_mutex_t;
 
 typedef void (*ompt_callback_mutex_acquire_t) (
-    ompt_mutex_kind_t kind,               /* mutex kind                          */
+    ompt_mutex_t kind,                    /* mutex kind                          */
     unsigned int hint,                    /* mutex hint                          */
     unsigned int impl,                    /* mutex implementation                */
-    omp_wait_id_t wait_id,               /* id of object being awaited          */
+    omp_wait_id_t wait_id,                /* id of object being awaited          */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_mutex_t) (
-    ompt_mutex_kind_t kind,               /* mutex kind                          */
-    omp_wait_id_t wait_id,               /* id of object being awaited          */
+    ompt_mutex_t kind,                    /* mutex kind                          */
+    omp_wait_id_t wait_id,                /* id of object being awaited          */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_nest_lock_t) (
     ompt_scope_endpoint_t endpoint,       /* endpoint of nested lock             */
-    omp_wait_id_t wait_id,               /* id of object being awaited          */
+    omp_wait_id_t wait_id,                /* id of object being awaited          */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_master_t) (
     ompt_scope_endpoint_t endpoint,       /* endpoint of master region           */
     ompt_data_t *parallel_data,           /* data of parallel region             */
     ompt_data_t *task_data,               /* data of task                        */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_idle_t) (
     ompt_scope_endpoint_t endpoint        /* endpoint of idle time               */
 );
 
-typedef enum ompt_work_type_t {
+typedef enum ompt_work_t {
     ompt_work_loop            = 1,
     ompt_work_sections        = 2,
     ompt_work_single_executor = 3,
     ompt_work_single_other    = 4,
     ompt_work_workshare       = 5,
     ompt_work_distribute      = 6,
     ompt_work_taskloop        = 7
-} ompt_work_type_t;
+} ompt_work_t;
 
 typedef void (*ompt_callback_work_t) (
-    ompt_work_type_t wstype,              /* type of work region                 */
+    ompt_work_t wstype,              /* type of work region                 */
     ompt_scope_endpoint_t endpoint,       /* endpoint of work region             */
     ompt_data_t *parallel_data,           /* data of parallel region             */
     ompt_data_t *task_data,               /* data of task                        */
     uint64_t count,                       /* quantity of work                    */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
-typedef enum ompt_sync_region_kind_t {
-    ompt_sync_region_barrier   = 1,
-    ompt_sync_region_taskwait  = 2,
-    ompt_sync_region_taskgroup = 3
-} ompt_sync_region_kind_t;
+typedef enum ompt_sync_region_t {
+    ompt_sync_region_barrier                  = 1,
+    ompt_sync_region_barrier_implicit         = 2,
+    ompt_sync_region_barrier_explicit         = 3,
+    ompt_sync_region_barrier_implementation   = 4,
+    ompt_sync_region_taskwait                 = 5,
+    ompt_sync_region_taskgroup                = 6,
+    ompt_sync_region_reduction                = 7
+} ompt_sync_region_t;
 
 typedef void (*ompt_callback_sync_region_t) (
-    ompt_sync_region_kind_t kind,         /* kind of sync region                 */
+    ompt_sync_region_t kind,              /* kind of sync region                 */
     ompt_scope_endpoint_t endpoint,       /* endpoint of sync region             */
     ompt_data_t *parallel_data,           /* data of parallel region             */
     ompt_data_t *task_data,               /* data of task                        */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef enum ompt_cancel_flag_t {
-    ompt_cancel_parallel       = 0x1,
-    ompt_cancel_sections       = 0x2,
-    ompt_cancel_do             = 0x4,
-    ompt_cancel_taskgroup      = 0x8,
+    ompt_cancel_parallel       = 0x01,
+    ompt_cancel_sections       = 0x02,
+    ompt_cancel_loop           = 0x04,
+    ompt_cancel_taskgroup      = 0x08,
     ompt_cancel_activated      = 0x10,
     ompt_cancel_detected       = 0x20,
     ompt_cancel_discarded_task = 0x40
 } ompt_cancel_flag_t;
 
 typedef void (*ompt_callback_cancel_t) (
     ompt_data_t *task_data,               /* data of task                        */
     int flags,                            /* cancel flags                        */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_flush_t) (
     ompt_data_t *thread_data,             /* data of thread                      */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
+typedef enum ompt_dispatch_t {
+    ompt_dispatch_iteration = 1,
+    ompt_dispatch_section =   2
+} ompt_dispatch_t;
+
+typedef void (*ompt_callback_dispatch_t) (
+    ompt_data_t *parallel_data,
+    ompt_data_t *task_data,
+    ompt_dispatch_t kind,
+    ompt_data_t instance
+);
+
 /****************************************************************************
  * ompt API
  ***************************************************************************/
 
 #ifdef  __cplusplus
 extern "C" {
 #endif
 
OMPT_API_FUNCTION(int, ompt_get_task_info, (
     int ancestor_level,
     int *type,
     ompt_data_t **task_data,
     omp_frame_t **task_frame,
     ompt_data_t **parallel_data,
     int *thread_num
 ));
 
+OMPT_API_FUNCTION(int, ompt_get_task_memory, (
+    void **addr,
+    size_t *size,
+    int block
+));
+
 /* procs */
 OMPT_API_FUNCTION(int, ompt_get_num_procs, (void));
 
 /* places */
 OMPT_API_FUNCTION(int, ompt_get_num_places, (void));
 
 OMPT_API_FUNCTION(int, ompt_get_place_proc_ids, (
     int place_num,

 OMPT_API_FUNCTION(int, ompt_get_proc_id, (void));
 
 
 /****************************************************************************
  * INITIALIZATION FUNCTIONS
  ***************************************************************************/
 
 OMPT_API_FUNCTION(int, ompt_initialize, (
-    ompt_function_lookup_t ompt_fn_lookup,
+    ompt_function_lookup_t lookup,
     ompt_data_t *tool_data
 ));
 
 OMPT_API_FUNCTION(void, ompt_finalize, (
     ompt_data_t *tool_data
 ));
 
 typedef struct ompt_start_tool_result_t {
OMPT_API_FUNCTION(int, ompt_enumerate_mutex_impls, (
     int current_impl,
     int *next_impl,
     const char **next_impl_name
 ));
 
 /* get_unique_id */
 OMPT_API_FUNCTION(uint64_t, ompt_get_unique_id, (void));
 
+/* finalize tool */
+OMPT_API_FUNCTION(void, ompt_finalize_tool, (void)); 
+
 #ifdef  __cplusplus
 };
 #endif
 
 /****************************************************************************
  * TARGET
  ***************************************************************************/
 

runtime/src/kmp_barrier.cpp

int __kmp_barrier(enum barrier_type bt, int gtid, int is_split,
                   size_t reduce_size, void *reduce_data,
                   void (*reduce)(void *, void *)) {
   KMP_TIME_PARTITIONED_BLOCK(OMP_plain_barrier);
   KMP_SET_THREAD_STATE_BLOCK(PLAIN_BARRIER);
   int tid = __kmp_tid_from_gtid(gtid);
   kmp_info_t *this_thr = __kmp_threads[gtid];
   kmp_team_t *team = this_thr->th.th_team;
   int status = 0;
-#if OMPT_SUPPORT
+#if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_data_t *my_task_data;
   ompt_data_t *my_parallel_data;
   void *return_address;
 #endif
 
   KA_TRACE(15, ("__kmp_barrier: T#%d(%d:%d) has arrived\n", gtid,
                 __kmp_team_from_gtid(gtid)->t.t_id, __kmp_tid_from_gtid(gtid)));
 
#endif /* KMP_DEBUG */
   KMP_DEBUG_ASSERT(TCR_PTR(this_thr->th.th_team));
   KMP_DEBUG_ASSERT(TCR_PTR(this_thr->th.th_root));
   KMP_DEBUG_ASSERT(this_thr == team->t.t_threads[tid]);
   KA_TRACE(10, ("__kmp_join_barrier: T#%d(%d:%d) arrived at join barrier\n",
                 gtid, team_id, tid));
 
   ANNOTATE_BARRIER_BEGIN(&team->t.t_bar);
 #if OMPT_SUPPORT
-  ompt_data_t *my_task_data;
-  ompt_data_t *my_parallel_data;
   if (ompt_enabled.enabled) {
 #if OMPT_OPTIONAL
+    ompt_data_t *my_task_data;
+    ompt_data_t *my_parallel_data;
     void *codeptr = NULL;
     int ds_tid = this_thr->th.th_info.ds.ds_tid;
     if (KMP_MASTER_TID(ds_tid) &&
         (ompt_callbacks.ompt_callback(ompt_callback_sync_region_wait) ||
          ompt_callbacks.ompt_callback(ompt_callback_sync_region)))
       codeptr = team->t.ompt_team_info.master_return_address;
     my_task_data = OMPT_CUR_TASK_DATA(this_thr);
     my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);

runtime/src/kmp_cancel.cpp

#if OMPT_SUPPORT && OMPT_OPTIONAL
           if (ompt_enabled.ompt_callback_cancel) {
             ompt_data_t *task_data;
             __ompt_get_task_info_internal(0, NULL, &task_data, NULL, NULL,
                                           NULL);
             ompt_cancel_flag_t type = ompt_cancel_parallel;
             if (cncl_kind == cancel_parallel)
               type = ompt_cancel_parallel;
             else if (cncl_kind == cancel_loop)
-              type = ompt_cancel_do;
+              type = ompt_cancel_loop;
             else if (cncl_kind == cancel_sections)
               type = ompt_cancel_sections;
             ompt_callbacks.ompt_callback(ompt_callback_cancel)(
                 task_data, type | ompt_cancel_activated,
                 OMPT_GET_RETURN_ADDRESS(0));
           }
 #endif
           return 1 /* true */;
#if OMPT_SUPPORT && OMPT_OPTIONAL
             if (ompt_enabled.ompt_callback_cancel) {
               ompt_data_t *task_data;
               __ompt_get_task_info_internal(0, NULL, &task_data, NULL, NULL,
                                             NULL);
               ompt_cancel_flag_t type = ompt_cancel_parallel;
               if (cncl_kind == cancel_parallel)
                 type = ompt_cancel_parallel;
               else if (cncl_kind == cancel_loop)
-                type = ompt_cancel_do;
+                type = ompt_cancel_loop;
               else if (cncl_kind == cancel_sections)
                 type = ompt_cancel_sections;
               ompt_callbacks.ompt_callback(ompt_callback_cancel)(
                   task_data, type | ompt_cancel_detected,
                   OMPT_GET_RETURN_ADDRESS(0));
             }
 #endif
             return 1 /* true */;

runtime/src/kmp_csupport.cpp

if (ompt_enabled.enabled &&
 
     // reset clear the task id only after unlinking the task
     ompt_data_t *parent_task_data;
     __ompt_get_task_info_internal(1, NULL, &parent_task_data, NULL, NULL, NULL);
 
     if (ompt_enabled.ompt_callback_parallel_end) {
       ompt_callbacks.ompt_callback(ompt_callback_parallel_end)(
           &(serial_team->t.ompt_team_info.parallel_data), parent_task_data,
-          ompt_invoker_program, OMPT_LOAD_RETURN_ADDRESS(global_tid));
+          ompt_parallel_invoker_program, OMPT_LOAD_RETURN_ADDRESS(global_tid));
     }
     __ompt_lw_taskteam_unlink(this_thr);
     this_thr->th.ompt_thread_info.state = omp_state_overhead;
   }
 #endif
 
   /* If necessary, pop the internal control stack values and replace the team
    * values */

 Mark the end of a statically scheduled loop.
 */
 void __kmpc_for_static_fini(ident_t *loc, kmp_int32 global_tid) {
   KMP_POP_PARTITIONED_TIMER();
   KE_TRACE(10, ("__kmpc_for_static_fini called T#%d\n", global_tid));
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_work) {
-    ompt_work_type_t ompt_work_type = ompt_work_loop;
+    ompt_work_t ompt_work_type = ompt_work_loop;
     ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
     ompt_task_info_t *task_info = __ompt_get_task_info_object(0);
     // Determine workshare type
     if (loc != NULL) {
       if ((loc->flags & KMP_IDENT_WORK_LOOP) != 0) {
         ompt_work_type = ompt_work_loop;
       } else if ((loc->flags & KMP_IDENT_WORK_SECTIONS) != 0) {
         ompt_work_type = ompt_work_sections;
#if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     if (ompt_enabled.ompt_callback_mutex_acquire) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
           ompt_mutex_nest_lock, omp_lock_hint_none,
           __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
           codeptr);
     }
   }
-#endif
   int acquire_status =
       KMP_D_LOCK_FUNC(user_lock, set)((kmp_dyna_lock_t *)user_lock, gtid);
+#endif
 #if USE_ITT_BUILD
   __kmp_itt_lock_acquired((kmp_user_lock_p)user_lock);
 #endif
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     if (acquire_status == KMP_LOCK_ACQUIRED_FIRST) {
       if (ompt_enabled.ompt_callback_mutex_acquired) {

 
 /* release the lock */
 void __kmpc_unset_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) {
 #if KMP_USE_DYNAMIC_LOCK
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_releasing((kmp_user_lock_p)user_lock);
 #endif
-  int release_status =
-      KMP_D_LOCK_FUNC(user_lock, unset)((kmp_dyna_lock_t *)user_lock, gtid);
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
+  int release_status =
+      KMP_D_LOCK_FUNC(user_lock, unset)((kmp_dyna_lock_t *)user_lock, gtid);
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.enabled) {
     if (release_status == KMP_LOCK_RELEASED) {
       if (ompt_enabled.ompt_callback_mutex_released) {
         // release_lock_last

runtime/src/kmp_runtime.cpp

if (ompt_enabled.enabled &&
     parent_task_info = OMPT_CUR_TASK_INFO(this_thr);
 
     parent_task_info->frame.enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     if (ompt_enabled.ompt_callback_parallel_begin) {
       int team_size = 1;
 
       ompt_callbacks.ompt_callback(ompt_callback_parallel_begin)(
           &(parent_task_info->task_data), &(parent_task_info->frame),
-          &ompt_parallel_data, team_size, ompt_invoker_program, codeptr);
+          &ompt_parallel_data, team_size, ompt_parallel_invoker_program,
+          codeptr);
     }
   }
 #endif // OMPT_SUPPORT
 
   if (this_thr->th.th_team != serial_team) {
     // Nested level will be an index in the nested nthreads array
     int level = this_thr->th.th_team->t.t_level;
 
#endif
   }
 #endif /* KMP_AFFINITY_SUPPORTED */
 
   __kmp_root_counter++;
 
 #if OMPT_SUPPORT
   if (!initial_thread && ompt_enabled.enabled) {
 
-    ompt_thread_t *root_thread = ompt_get_thread();
+    kmp_info_t *root_thread = ompt_get_thread();
 
     ompt_set_thread_state(root_thread, omp_state_overhead);
 
     if (ompt_enabled.ompt_callback_thread_begin) {
       ompt_callbacks.ompt_callback(ompt_callback_thread_begin)(
           ompt_thread_initial, __ompt_get_thread_data_internal());
     }
     ompt_data_t *task_data;

runtime/src/kmp_sched.cpp

#endif
   kmp_uint32 nth;
   UT trip_count;
   kmp_team_t *team;
   kmp_info_t *th = __kmp_threads[gtid];
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_team_info_t *team_info = NULL;
   ompt_task_info_t *task_info = NULL;
-  ompt_work_type_t ompt_work_type = ompt_work_loop;
+  ompt_work_t ompt_work_type = ompt_work_loop;
 
   static kmp_int8 warn = 0;
 
   if (ompt_enabled.ompt_callback_work) {
     // Only fully initialize variables needed by OMPT if OMPT is enabled.
     team_info = __ompt_get_teaminfo(0, NULL);
     task_info = __ompt_get_task_info_object(0);
     // Determine workshare type

runtime/src/kmp_taskdeps.cpp

new_taskdata->ompt_task_info.deps =
             thread, (ndeps + ndeps_noalias) * sizeof(ompt_task_dependence_t));
 
     KMP_ASSERT(new_taskdata->ompt_task_info.deps != NULL);
 
     for (i = 0; i < ndeps; i++) {
       new_taskdata->ompt_task_info.deps[i].variable_addr =
           (void *)dep_list[i].base_addr;
       if (dep_list[i].flags.in && dep_list[i].flags.out)
-        new_taskdata->ompt_task_info.deps[i].dependence_flags =
+        new_taskdata->ompt_task_info.deps[i].dependence_type =
             ompt_task_dependence_type_inout;
       else if (dep_list[i].flags.out)
-        new_taskdata->ompt_task_info.deps[i].dependence_flags =
+        new_taskdata->ompt_task_info.deps[i].dependence_type =
             ompt_task_dependence_type_out;
       else if (dep_list[i].flags.in)
-        new_taskdata->ompt_task_info.deps[i].dependence_flags =
+        new_taskdata->ompt_task_info.deps[i].dependence_type =
             ompt_task_dependence_type_in;
     }
     for (i = 0; i < ndeps_noalias; i++) {
       new_taskdata->ompt_task_info.deps[ndeps + i].variable_addr =
           (void *)noalias_dep_list[i].base_addr;
       if (noalias_dep_list[i].flags.in && noalias_dep_list[i].flags.out)
-        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_flags =
+        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_type =
             ompt_task_dependence_type_inout;
       else if (noalias_dep_list[i].flags.out)
-        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_flags =
+        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_type =
             ompt_task_dependence_type_out;
       else if (noalias_dep_list[i].flags.in)
-        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_flags =
+        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_type =
             ompt_task_dependence_type_in;
     }
     ompt_callbacks.ompt_callback(ompt_callback_task_dependences)(
         &(new_taskdata->ompt_task_info.task_data),
         new_taskdata->ompt_task_info.deps, new_taskdata->ompt_task_info.ndeps);
     /* We can now free the allocated memory for the dependencies */
     /* For OMPD we might want to delay the free until task_end */
     KMP_OMPT_DEPS_FREE(thread, new_taskdata->ompt_task_info.deps);

runtime/src/kmp_tasking.cpp

 }
 
 // __ompt_task_start:
 //   Build and trigger task-begin event
 static inline void __ompt_task_start(kmp_task_t *task,
                                      kmp_taskdata_t *current_task,
                                      kmp_int32 gtid) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
-  ompt_task_status_t status = ompt_task_others;
+  ompt_task_status_t status = ompt_task_switch;
   if (__kmp_threads[gtid]->th.ompt_thread_info.ompt_task_yielded) {
     status = ompt_task_yield;
     __kmp_threads[gtid]->th.ompt_thread_info.ompt_task_yielded = 0;
   }
   /* let OMPT know that we're about to run this task */
   if (ompt_enabled.ompt_callback_task_schedule) {
     ompt_callbacks.ompt_callback(ompt_callback_task_schedule)(
         &(current_task->ompt_task_info.task_data), status,
if (!new_taskdata->td_flags.started) {
             ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 0,
             OMPT_LOAD_RETURN_ADDRESS(gtid));
       }
     } else {
       // We are scheduling the continuation of an UNTIED task.
       // Scheduling back to the parent task.
       __ompt_task_finish(new_task,
                          new_taskdata->ompt_task_info.scheduling_parent,
-                         ompt_task_others);
+                         ompt_task_switch);
       new_taskdata->ompt_task_info.frame.exit_frame = NULL;
     }
   }
 #endif
 
   res = __kmp_omp_task(gtid, new_task, true);
 
   KA_TRACE(10, ("__kmpc_omp_task(exit): T#%d returning "
#endif // OMPT_SUPPORT && OMPT_OPTIONAL
 
   KA_TRACE(10, ("__kmpc_omp_taskwait(exit): T#%d task %p finished waiting, "
                 "returning TASK_CURRENT_NOT_QUEUED\n",
                 gtid, taskdata));
 
   return TASK_CURRENT_NOT_QUEUED;
 }
 
-#if OMPT_SUPPORT
+#if OMPT_SUPPORT && OMPT_OPTIONAL
 OMPT_NOINLINE
 static kmp_int32 __kmpc_omp_taskwait_ompt(ident_t *loc_ref, kmp_int32 gtid,
                                           void *frame_address,
                                           void *return_address) {
   return __kmpc_omp_taskwait_template<true>(loc_ref, gtid, frame_address,
                                             return_address);
 }
-#endif // OMPT_SUPPORT
+#endif // OMPT_SUPPORT && OMPT_OPTIONAL
 
 // __kmpc_omp_taskwait: Wait until all tasks generated by the current task are
 // complete
 kmp_int32 __kmpc_omp_taskwait(ident_t *loc_ref, kmp_int32 gtid) {
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (UNLIKELY(ompt_enabled.enabled)) {
     OMPT_STORE_RETURN_ADDRESS(gtid);
     return __kmpc_omp_taskwait_ompt(loc_ref, gtid, OMPT_GET_FRAME_ADDRESS(1),

runtime/src/kmp_wait_release.h

if (ompt_enabled.ompt_callback_sync_region) {
           ompt_sync_region_barrier, ompt_scope_end, NULL, tId, codeptr);
     }
 #endif
     if (!KMP_MASTER_TID(ds_tid)) {
       if (ompt_enabled.ompt_callback_implicit_task) {
         ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
             ompt_scope_end, NULL, tId, 0, ds_tid);
       }
-#if OMPT_OPTIONAL
-      if (ompt_enabled.ompt_callback_idle) {
-        ompt_callbacks.ompt_callback(ompt_callback_idle)(ompt_scope_begin);
-      }
-#endif
       // return to idle state
       this_thr->th.ompt_thread_info.state = omp_state_idle;
     } else {
       this_thr->th.ompt_thread_info.state = omp_state_overhead;
     }
   }
 }
 #endif
if (!final_spin || ompt_entry_state != omp_state_wait_barrier_implicit ||
       } else {
         pId = OMPT_CUR_TEAM_DATA(this_thr);
         tId = OMPT_CUR_TASK_DATA(this_thr);
       }
     } else {
       pId = NULL;
       tId = &(this_thr->th.ompt_thread_info.task_data);
     }
-#if OMPT_OPTIONAL
-    if (ompt_entry_state == omp_state_idle) {
-      if (ompt_enabled.ompt_callback_idle) {
-        ompt_callbacks.ompt_callback(ompt_callback_idle)(ompt_scope_begin);
-      }
-    } else
-#endif
         if (final_spin && (__kmp_tasking_mode == tskm_immediate_exec ||
                            this_thr->th.th_task_team == NULL)) {
       // implicit task is done. Either no taskqueue, or task-team finished
       __ompt_implicit_task_end(this_thr, ompt_entry_state, tId, pId);
     }
   }
 #endif
 
#if OMPT_SUPPORT
   if (ompt_enabled.enabled && ompt_exit_state != omp_state_undefined) {
 #if OMPT_OPTIONAL
     if (final_spin) {
       __ompt_implicit_task_end(this_thr, ompt_exit_state, tId, pId);
       ompt_exit_state = this_thr->th.ompt_thread_info.state;
     }
 #endif
     if (ompt_exit_state == omp_state_idle) {
-#if OMPT_OPTIONAL
-      if (ompt_enabled.ompt_callback_idle) {
-        ompt_callbacks.ompt_callback(ompt_callback_idle)(ompt_scope_end);
-      }
-#endif
       this_thr->th.ompt_thread_info.state = omp_state_overhead;
     }
   }
 #endif
 #if KMP_STATS_ENABLED
   // If we were put into idle state, pop that off the state stack
   if (KMP_GET_THREAD_STATE() == IDLE) {
     KMP_POP_PARTITIONED_TIMER();

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_idle_implemented ompt_event_MAY_ALWAYS_OPTIONAL
+#define ompt_callback_reduction_implemented ompt_event_UNIMPLEMENTED
+
+#define ompt_callback_dispatch_implemented ompt_event_UNIMPLEMENTED
 
 #endif

runtime/src/ompt-general.cpp

ompt_enabled.enabled = !!ompt_start_tool_result->initialize(
         ompt_fn_lookup, &(ompt_start_tool_result->tool_data));
 
     if (!ompt_enabled.enabled) {
       // tool not enabled, zero out the bitmap, and done
       memset(&ompt_enabled, 0, sizeof(ompt_enabled));
       return;
     }
 
-    ompt_thread_t *root_thread = ompt_get_thread();
+    kmp_info_t *root_thread = ompt_get_thread();
 
     ompt_set_thread_state(root_thread, omp_state_overhead);
 
     if (ompt_enabled.ompt_callback_thread_begin) {
       ompt_callbacks.ompt_callback(ompt_callback_thread_begin)(
           ompt_thread_initial, __ompt_get_thread_data_internal());
     }
     ompt_data_t *task_data;
OMPT_API_ROUTINE int ompt_get_task_info(int ancestor_level, int *type,
                                         ompt_data_t **task_data,
                                         omp_frame_t **task_frame,
                                         ompt_data_t **parallel_data,
                                         int *thread_num) {
   return __ompt_get_task_info_internal(ancestor_level, type, task_data,
                                        task_frame, parallel_data, thread_num);
 }
 
+OMPT_API_ROUTINE int ompt_get_task_memory(void **addr, size_t *size,
+                                          int block) {
+  // stub
+  return 0;
+}
+
 /*****************************************************************************
  * num_procs
  ****************************************************************************/
 
 OMPT_API_ROUTINE int ompt_get_num_procs(void) {
   // copied from kmp_ftn_entry.h (but modified: OMPT can only be called when
   // runtime is initialized)
   return __kmp_avail_proc;

 /*****************************************************************************
  * misc
  ****************************************************************************/
 
 OMPT_API_ROUTINE uint64_t ompt_get_unique_id(void) {
   return __ompt_get_unique_id_internal();
 }
 
+OMPT_API_ROUTINE void ompt_finalize_tool(void) {
+  // stub
+}
+
 /*****************************************************************************
  * Target
  ****************************************************************************/
 
 OMPT_API_ROUTINE int ompt_get_target_info(uint64_t *device_num,
                                           ompt_id_t *target_id,
                                           ompt_id_t *host_op_id) {
   return 0; // thread is not in a target region

runtime/src/ompt-internal.h

 #include "ompt-event-specific.h"
 #include "ompt.h"
 
 #define OMPT_VERSION 1
 
 #define _OMP_EXTERN extern "C"
 
 #define OMPT_INVOKER(x)                                                        \
-  ((x == fork_context_gnu) ? ompt_invoker_program : ompt_invoker_runtime)
+  ((x == fork_context_gnu) ? ompt_parallel_invoker_program                     \
+                           : ompt_parallel_invoker_runtime)
 
 #define ompt_callback(e) e##_callback
 
 typedef struct ompt_callbacks_internal_s {
 #define ompt_event_macro(event, callback, eventid)                             \
   callback ompt_callback(event);
 
   FOREACH_OMPT_EVENT(ompt_event_macro)

runtime/src/ompt-specific.h

 //===----------------------------------------------------------------------===//
 
 #ifndef OMPT_SPECIFIC_H
 #define OMPT_SPECIFIC_H
 
 #include "kmp.h"
 
 /*****************************************************************************
- * types
- ****************************************************************************/
-
-typedef kmp_info_t ompt_thread_t;
-
-/*****************************************************************************
  * forward declarations
  ****************************************************************************/
 
 void __ompt_team_assign_id(kmp_team_t *team, ompt_data_t ompt_pid);
 void __ompt_thread_assign_wait_id(void *variable);
 
-void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, ompt_thread_t *thr,
+void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr,
                              int gtid, ompt_data_t *ompt_pid, void *codeptr);
 
-void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt, ompt_thread_t *thr,
+void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt, kmp_info_t *thr,
                              int on_heap);
 
-void __ompt_lw_taskteam_unlink(ompt_thread_t *thr);
+void __ompt_lw_taskteam_unlink(kmp_info_t *thr);
 
 ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size);
 
 ompt_task_info_t *__ompt_get_task_info_object(int depth);
 
 int __ompt_get_parallel_info_internal(int ancestor_level,
                                       ompt_data_t **parallel_data,
                                       int *team_size);
#define OMPT_STORE_RETURN_ADDRESS(gtid)                                        \
   __kmp_threads[gtid]->th.ompt_thread_info.return_address =                    \
       __builtin_return_address(0)
 #define OMPT_LOAD_RETURN_ADDRESS(gtid) __ompt_load_return_address(gtid)
 
 //******************************************************************************
 // inline functions
 //******************************************************************************
 
-inline ompt_thread_t *ompt_get_thread_gtid(int gtid) {
+inline kmp_info_t *ompt_get_thread_gtid(int gtid) {
   return (gtid >= 0) ? __kmp_thread_from_gtid(gtid) : NULL;
 }
 
-inline ompt_thread_t *ompt_get_thread() {
+inline kmp_info_t *ompt_get_thread() {
   int gtid = __kmp_get_gtid();
   return ompt_get_thread_gtid(gtid);
 }
 
-inline void ompt_set_thread_state(ompt_thread_t *thread, omp_state_t state) {
+inline void ompt_set_thread_state(kmp_info_t *thread, omp_state_t state) {
   thread->th.ompt_thread_info.state = state;
 }
 
 inline const char *ompt_get_runtime_version() {
   return &__kmp_version_lib_ver[KMP_VERSION_MAGIC_LEN];
 }
 
 #endif

runtime/test/ompt/callback.h

 #ifndef _BSD_SOURCE
 #define _BSD_SOURCE
 #endif
 #define _DEFAULT_SOURCE
 #include <stdio.h>
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
 #endif
 #include <inttypes.h>
 #include <omp.h>
 #include <ompt.h>
 #include "ompt-signal.h"
 
 // Used to detect architecture
 #include "../../src/kmp_platform.h"
 
-static const char* ompt_thread_type_t_values[] = {
+static const char* ompt_thread_t_values[] = {
   NULL,
   "ompt_thread_initial",
   "ompt_thread_worker",
   "ompt_thread_other"
 };
 
 static const char* ompt_task_status_t_values[] = {
   NULL,
   "ompt_task_complete",
   "ompt_task_yield",
   "ompt_task_cancel",
   "ompt_task_others"
 };
 static const char* ompt_cancel_flag_t_values[] = {
   "ompt_cancel_parallel",
   "ompt_cancel_sections",
-  "ompt_cancel_do",
+  "ompt_cancel_loop",
   "ompt_cancel_taskgroup",
   "ompt_cancel_activated",
   "ompt_cancel_detected",
   "ompt_cancel_discarded_task"
 };
 
 static void format_task_type(int type, char *buffer) {
   char *progress = buffer;
printf("%" PRIu64 ": fuzzy_address=0x%" PRIx64 " or 0x%" PRIx64              \
          ompt_get_thread_data()->value,                                        \
          ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES - 1,                   \
          ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES,                       \
          ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES + 1,                   \
          ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES + 2, addr)
 
 static void
 on_ompt_callback_mutex_acquire(
-  ompt_mutex_kind_t kind,
+  ompt_mutex_t kind,
   unsigned int hint,
   unsigned int impl,
   omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
case ompt_mutex_ordered:
       break;
     default:
       break;
   }
 }
 
 static void
 on_ompt_callback_mutex_acquired(
-  ompt_mutex_kind_t kind,
+  ompt_mutex_t kind,
   omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_acquired_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
case ompt_mutex_ordered:
       break;
     default:
       break;
   }
 }
 
 static void
 on_ompt_callback_mutex_released(
-  ompt_mutex_kind_t kind,
+  ompt_mutex_t kind,
   omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_release_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
switch(endpoint)
     case ompt_scope_end:
       printf("%" PRIu64 ": ompt_event_release_nest_lock_prev: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
   }
 }
 
 static void
 on_ompt_callback_sync_region(
-  ompt_sync_region_kind_t kind,
+  ompt_sync_region_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:
       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_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);
           print_ids(0);
           break;
         case ompt_sync_region_taskwait:
           printf("%" PRIu64 ": ompt_event_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_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:
+          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_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_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_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;
       }
       break;
   }
 }
 
 static void
 on_ompt_callback_sync_region_wait(
-  ompt_sync_region_kind_t kind,
+  ompt_sync_region_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:
       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_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:
+          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;
       }
       break;
   }
 }
 
 static void
 on_ompt_callback_flush(
     ompt_data_t *thread_data,
on_ompt_callback_cancel(
     const void *codeptr_ra)
 {
   const char* first_flag_value;
   const char* second_flag_value;
   if(flags & ompt_cancel_parallel)
     first_flag_value = ompt_cancel_flag_t_values[0];
   else if(flags & ompt_cancel_sections)
     first_flag_value = ompt_cancel_flag_t_values[1];
-  else if(flags & ompt_cancel_do)
+  else if(flags & ompt_cancel_loop)
     first_flag_value = ompt_cancel_flag_t_values[2];
   else if(flags & ompt_cancel_taskgroup)
     first_flag_value = ompt_cancel_flag_t_values[3];
 
   if(flags & ompt_cancel_activated)
     second_flag_value = ompt_cancel_flag_t_values[4];
   else if(flags & ompt_cancel_detected)
     second_flag_value = ompt_cancel_flag_t_values[5];
   else if(flags & ompt_cancel_discarded_task)
     second_flag_value = ompt_cancel_flag_t_values[6];
 
   printf("%" PRIu64 ": ompt_event_cancel: task_data=%" PRIu64 ", flags=%s|%s=%" PRIu32 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, task_data->value, first_flag_value, second_flag_value, flags,  codeptr_ra);
 }
 
 static void
-on_ompt_callback_idle(
-  ompt_scope_endpoint_t endpoint)
-{
-  switch(endpoint)
-  {
-    case ompt_scope_begin:
-      printf("%" PRIu64 ": ompt_event_idle_begin:\n", ompt_get_thread_data()->value);
-      break;
-    case ompt_scope_end:
-      printf("%" PRIu64 ": ompt_event_idle_end:\n", ompt_get_thread_data()->value);
-      break;
-  }
-}
-
-static void
 on_ompt_callback_implicit_task(
     ompt_scope_endpoint_t endpoint,
     ompt_data_t *parallel_data,
     ompt_data_t *task_data,
     unsigned int team_size,
     unsigned int thread_num)
 {
   switch(endpoint)
   {
     case ompt_scope_begin:
       if(task_data->ptr)
         printf("%s\n", "0: task_data initially not null");
       task_data->value = ompt_get_unique_id();
       printf("%" PRIu64 ": ompt_event_implicit_task_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", team_size=%" PRIu32 ", thread_num=%" PRIu32 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, team_size, thread_num);
       break;
     case ompt_scope_end:
       printf("%" PRIu64 ": ompt_event_implicit_task_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", team_size=%" PRIu32 ", thread_num=%" PRIu32 "\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, team_size, thread_num);
       break;
   }
 }
 
 static void
 on_ompt_callback_lock_init(
-  ompt_mutex_kind_t kind,
+  ompt_mutex_t kind,
   unsigned int hint,
   unsigned int impl,
   omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_init_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
       break;
     case ompt_mutex_nest_lock:
       printf("%" PRIu64 ": ompt_event_init_nest_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
       break;
     default:
       break;
   }
 }
 
 static void
 on_ompt_callback_lock_destroy(
-  ompt_mutex_kind_t kind,
+  ompt_mutex_t kind,
   omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_destroy_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
     case ompt_mutex_nest_lock:
       printf("%" PRIu64 ": ompt_event_destroy_nest_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
     default:
       break;
   }
 }
 
 static void
 on_ompt_callback_work(
-  ompt_work_type_t wstype,
+  ompt_work_t wstype,
   ompt_scope_endpoint_t endpoint,
   ompt_data_t *parallel_data,
   ompt_data_t *task_data,
   uint64_t count,
   const void *codeptr_ra)
 {
   switch(endpoint)
   {
case ompt_scope_begin:
       printf("%" PRIu64 ": ompt_event_master_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_scope_end:
       printf("%" PRIu64 ": ompt_event_master_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra);
       break;
   }
 }
 
-static void
-on_ompt_callback_parallel_begin(
+static void on_ompt_callback_parallel_begin(
     ompt_data_t *encountering_task_data,
-  const omp_frame_t *encountering_task_frame,
-  ompt_data_t* parallel_data,
-  uint32_t requested_team_size,
-  ompt_invoker_t invoker,
-  const void *codeptr_ra)
-{
+    const omp_frame_t *encountering_task_frame, ompt_data_t *parallel_data,
+    uint32_t requested_team_size, int flag, const void *codeptr_ra) {
   if(parallel_data->ptr)
     printf("0: parallel_data initially not null\n");
   parallel_data->value = ompt_get_unique_id();
-  printf("%" PRIu64 ": ompt_event_parallel_begin: parent_task_id=%" PRIu64 ", parent_task_frame.exit=%p, parent_task_frame.reenter=%p, parallel_id=%" PRIu64 ", requested_team_size=%" PRIu32 ", codeptr_ra=%p, invoker=%d\n", ompt_get_thread_data()->value, encountering_task_data->value, encountering_task_frame->exit_frame, encountering_task_frame->enter_frame, parallel_data->value, requested_team_size, codeptr_ra, invoker);
+  printf("%" PRIu64 ": ompt_event_parallel_begin: parent_task_id=%" PRIu64
+         ", parent_task_frame.exit=%p, parent_task_frame.reenter=%p, "
+         "parallel_id=%" PRIu64 ", requested_team_size=%" PRIu32
+         ", codeptr_ra=%p, invoker=%d\n",
+         ompt_get_thread_data()->value, encountering_task_data->value,
+         encountering_task_frame->exit_frame,
+         encountering_task_frame->enter_frame, parallel_data->value,
+         requested_team_size, codeptr_ra, flag);
 }
 
-static void
-on_ompt_callback_parallel_end(
-  ompt_data_t *parallel_data,
+static void on_ompt_callback_parallel_end(ompt_data_t *parallel_data,
                                           ompt_data_t *encountering_task_data,
-  ompt_invoker_t invoker,
-  const void *codeptr_ra)
-{
-  printf("%" PRIu64 ": ompt_event_parallel_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", invoker=%d, codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, encountering_task_data->value, invoker, codeptr_ra);
+                                          int flag, const void *codeptr_ra) {
+  printf("%" PRIu64 ": ompt_event_parallel_end: parallel_id=%" PRIu64
+         ", task_id=%" PRIu64 ", invoker=%d, codeptr_ra=%p\n",
+         ompt_get_thread_data()->value, parallel_data->value,
+         encountering_task_data->value, flag, codeptr_ra);
 }
 
 static void
 on_ompt_callback_task_create(
     ompt_data_t *encountering_task_data,
     const omp_frame_t *encountering_task_frame,
     ompt_data_t* new_task_data,
     int type,
on_ompt_callback_task_dependence(
   ompt_data_t *first_task_data,
   ompt_data_t *second_task_data)
 {
   printf("%" PRIu64 ": ompt_event_task_dependence_pair: first_task_id=%" PRIu64 ", second_task_id=%" PRIu64 "\n", ompt_get_thread_data()->value, first_task_data->value, second_task_data->value);
 }
 
 static void
 on_ompt_callback_thread_begin(
-  ompt_thread_type_t thread_type,
+  ompt_thread_t thread_type,
   ompt_data_t *thread_data)
 {
   if(thread_data->ptr)
     printf("%s\n", "0: thread_data initially not null");
   thread_data->value = ompt_get_unique_id();
-  printf("%" PRIu64 ": ompt_event_thread_begin: thread_type=%s=%d, thread_id=%" PRIu64 "\n", ompt_get_thread_data()->value, ompt_thread_type_t_values[thread_type], thread_type, thread_data->value);
+  printf("%" PRIu64 ": ompt_event_thread_begin: thread_type=%s=%d, thread_id=%" PRIu64 "\n", ompt_get_thread_data()->value, ompt_thread_t_values[thread_type], thread_type, thread_data->value);
 }
 
 static void
 on_ompt_callback_thread_end(
   ompt_data_t *thread_data)
 {
   printf("%" PRIu64 ": ompt_event_thread_end: thread_id=%" PRIu64 "\n", ompt_get_thread_data()->value, thread_data->value);
 }
int ompt_initialize(
   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(ompt_callback_control_tool);
   register_callback(ompt_callback_flush);
   register_callback(ompt_callback_cancel);
-  register_callback(ompt_callback_idle);
   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);
   register_callback(ompt_callback_parallel_begin);
   register_callback(ompt_callback_parallel_end);
   register_callback(ompt_callback_task_create);

runtime/test/ompt/cancel/cancel_worksharing.c

int main()
   // Check if libomp supports the callbacks for this test.
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create'
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_cancel'
 
   // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]]
   // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=[[NULL]], new_task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[NULL]], task_type=ompt_task_initial=1, has_dependences=no
   
   // cancel for and sections
-  // CHECK: {{^}}[[MASTER_ID]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_do|ompt_cancel_activated=20, codeptr_ra={{0x[0-f]*}}
+  // CHECK: {{^}}[[MASTER_ID]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_loop|ompt_cancel_activated=20, codeptr_ra={{0x[0-f]*}}
   // CHECK: {{^}}[[MASTER_ID]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_sections|ompt_cancel_activated=18, codeptr_ra={{0x[0-f]*}}
-  // CHECK: {{^}}[[OTHER_THREAD_ID:[0-9]+]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_do|ompt_cancel_detected=36, codeptr_ra={{0x[0-f]*}}
+  // CHECK: {{^}}[[OTHER_THREAD_ID:[0-9]+]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_loop|ompt_cancel_detected=36, codeptr_ra={{0x[0-f]*}}
   // CHECK: {{^}}[[OTHER_THREAD_ID:[0-9]+]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_sections|ompt_cancel_detected=34, codeptr_ra={{0x[0-f]*}}
 
   return 0;
 }

runtime/test/ompt/loadtool/tool_available_search/tool_available_search.c

ompt_start_tool_result_t* ompt_start_tool(
   return NULL;
 }
 #elif defined(THIRD_TOOL)
 // The third tool has an implementation of ompt_start_tool that returns a 
 // pointer to a valid instance of ompt_start_tool_result_t
 
 static void
 on_ompt_callback_thread_begin(
-  ompt_thread_type_t thread_type,
+  ompt_thread_t thread_type,
   ompt_data_t *thread_data)
 {
   printf("0: ompt_event_thread_begin\n");
 }
 
 int ompt_initialize(
   ompt_function_lookup_t lookup,
   ompt_data_t *tool_data)

runtime/test/ompt/misc/idle.c

-// RUN: %libomp-compile-and-run | FileCheck %s
-// REQUIRES: ompt
-#include "callback.h"
-#include <omp.h>
-
-int main()
-{
-  int x = 0;
-  #pragma omp parallel num_threads(3)
-  {
-    #pragma omp atomic
-    x++;
-  }
-  #pragma omp parallel num_threads(2)
-  {
-    #pragma omp atomic
-    x++;
-  }
-
-
-  printf("x=%d\n", x);
-
-  // Check if libomp supports the callbacks for this test.
-  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_idle'
-
-  // CHECK: 0: NULL_POINTER=[[NULL:.*$]]
-
-  // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_idle_begin:
-  // CHECK: {{^}}[[THREAD_ID]]: ompt_event_idle_end:
-
-  return 0;
-}

runtime/test/ompt/synchronization/barrier/implicit_task_data.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 
 // This test checks that values stored in task_data in a barrier_begin event
 // are still present in the corresponding barrier_end event.
 // Therefore, callback implementations different from the ones in callback.h are neccessary.
 // This is a test for an issue reported in 
 // https://github.com/OpenMPToolsInterface/LLVM-openmp/issues/39
 
 #define _BSD_SOURCE
 #include <stdio.h>
 #include <unistd.h>
 #include <inttypes.h>
 #include <omp.h>
 #include <ompt.h>
 
-static const char* ompt_thread_type_t_values[] = {
+static const char* ompt_thread_t_values[] = {
   NULL,
   "ompt_thread_initial",
   "ompt_thread_worker",
   "ompt_thread_other"
 };
 
 static ompt_get_unique_id_t ompt_get_unique_id;
 static ompt_get_thread_data_t ompt_get_thread_data;
int main()
   // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id=0, task_id=[[TASK_ID]], codeptr_ra=[[NULL]]
   // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id=0, task_id=[[TASK_ID]], codeptr_ra=[[NULL]]
 
   return 0;
 }
 
 static void
 on_ompt_callback_thread_begin(
-  ompt_thread_type_t thread_type,
+  ompt_thread_t thread_type,
   ompt_data_t *thread_data)
 {
   if(thread_data->ptr)
     printf("%s\n", "0: thread_data initially not null");
   thread_data->value = ompt_get_unique_id();
-  printf("%" PRIu64 ": ompt_event_thread_begin: thread_type=%s=%d, thread_id=%" PRIu64 "\n", ompt_get_thread_data()->value, ompt_thread_type_t_values[thread_type], thread_type, thread_data->value);
+  printf("%" PRIu64 ": ompt_event_thread_begin: thread_type=%s=%d, thread_id=%" PRIu64 "\n", ompt_get_thread_data()->value, ompt_thread_t_values[thread_type], thread_type, thread_data->value);
 }
 
 static void
 on_ompt_callback_sync_region(
-  ompt_sync_region_kind_t kind,
+  ompt_sync_region_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:
       task_data->value = ompt_get_unique_id();
       if(kind == ompt_sync_region_barrier)
         printf("%" PRIu64 ": ompt_event_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_scope_end:
       if(kind == ompt_sync_region_barrier)
         printf("%" PRIu64 ": ompt_event_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;
   }
 }
 
 static void
 on_ompt_callback_sync_region_wait(
-  ompt_sync_region_kind_t kind,
+  ompt_sync_region_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: