[OpenMP][OMPT] Update the omp-tools header file to reflect 5.1 changes

[protze.joachim]

Summary

This doesn't add functionality, but just adds the new types and renames the master callback to masked callback.

[protze.joachim]

This implies also some changes to the OMPT tests

[jdoerfert]

LGTM, one nit below.

openmp/runtime/test/ompt/synchronization/taskgroup.c

32

No replacement?

[protze.joachim]

openmp/runtime/test/ompt/synchronization/taskgroup.c

32

The test does not use the callback, so I removed the check rather than replacing it.

[protze.joachim]

The ompt_callback_master_t type is deprecated, but not removed. So, omp-tools.h still needs to define the type.
I moved the existing master.c test to masked.c and added a new master.c test, which just tries to register the deprecated callback.

I also ran all tests with cmake -DOPENMP_TEST_FLAGS:STRING="-Werror -Wno-#warnings" and fixed all warnings for the ompt test cases (mainly about missing cases in switch statements).

[lxfind]

Are all uses of on_ompt_callback_master expected to be replaced?
I see this is still using it:
https://github.com/llvm/llvm-project/blob/master/openmp/tools/multiplex/tests/custom_data_storage/first-tool.h#L126

[protze.joachim]

In D90752#2390115, @lxfind wrote:

Are all uses of on_ompt_callback_master expected to be replaced?
I see this is still using it:
https://github.com/llvm/llvm-project/blob/master/openmp/tools/multiplex/tests/custom_data_storage/first-tool.h#L126

multiplex tests are fixed in 25b3164bfbe6dc

openmp/runtime/src/include/omp-tools.h.var

 
 /*****************************************************************************
  * system include files
  *****************************************************************************/
 
 #include <stdint.h>
 #include <stddef.h>
 
+#ifdef DEPRECATION_WARNINGS 
+# ifdef __cplusplus
+# define DEPRECATED_51 [[deprecated("as of 5.1")]]
+# else
+# define DEPRECATED_51 __attribute__((deprecated("as of 5.1")))
+#endif
+#else
+#define DEPRECATED_51
+#endif
+
 /*****************************************************************************
  * iteration macros
  *****************************************************************************/
 
 #define FOREACH_OMPT_INQUIRY_FN(macro)      \
     macro (ompt_enumerate_states)           \
     macro (ompt_enumerate_mutex_impls)      \
                                             \
macro (ompt_callback_sync_region_wait,  ompt_callback_sync_region_t,       16) /* sync region wait begin or end   */ \
                                                                                                                          \
     macro (ompt_callback_mutex_released,    ompt_callback_mutex_t,             17) /* mutex released                  */ \
                                                                                                                          \
     macro (ompt_callback_dependences,       ompt_callback_dependences_t,       18) /* report task dependences         */ \
     macro (ompt_callback_task_dependence,   ompt_callback_task_dependence_t,   19) /* report task dependence          */ \
                                                                                                                          \
     macro (ompt_callback_work,              ompt_callback_work_t,              20) /* task at work begin or end       */ \
                                                                                                                          \
-    macro (ompt_callback_master,            ompt_callback_master_t,            21) /* task at master begin or end     */ \
+    macro (ompt_callback_masked,            ompt_callback_masked_t,            21) /* task at masked begin or end     */ \
                                                                                                                          \
     macro (ompt_callback_target_map,        ompt_callback_target_map_t,        22) /* target map                      */ \
                                                                                                                          \
     macro (ompt_callback_sync_region,       ompt_callback_sync_region_t,       23) /* sync region begin or end        */ \
                                                                                                                          \
     macro (ompt_callback_lock_init,         ompt_callback_mutex_acquire_t,     24) /* lock init                       */ \
     macro (ompt_callback_lock_destroy,      ompt_callback_mutex_t,             25) /* lock destroy                    */ \
                                                                                                                          \
     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_reduction,         ompt_callback_sync_region_t,       31) /* reduction                       */ \
                                                                                                                          \
-    macro (ompt_callback_dispatch,          ompt_callback_dispatch_t,          32) /* dispatch of work                */
+    macro (ompt_callback_dispatch,          ompt_callback_dispatch_t,          32) /* dispatch of work                */ \
+    macro (ompt_callback_target_emi,        ompt_callback_target_emi_t,        33) /* target                          */ \
+    macro (ompt_callback_target_data_op_emi,ompt_callback_target_data_op_emi_t,34) /* target data op                  */ \
+    macro (ompt_callback_target_submit_emi, ompt_callback_target_submit_emi_t, 35) /* target submit                   */ \
+    macro (ompt_callback_target_map_emi,    ompt_callback_target_map_emi_t,    36) /* target map                      */ \
+    macro (ompt_callback_error,             ompt_callback_error_t,             37) /* error                           */
 
 /*****************************************************************************
  * implementation specific types
  *****************************************************************************/
 
 typedef enum kmp_mutex_impl_t {
 #define kmp_mutex_impl_macro(impl, code) impl = code,
     FOREACH_KMP_MUTEX_IMPL(kmp_mutex_impl_macro)
typedef enum ompt_callbacks_t {
   ompt_callback_device_finalize          = 13,
   ompt_callback_device_load              = 14,
   ompt_callback_device_unload            = 15,
   ompt_callback_sync_region_wait         = 16,
   ompt_callback_mutex_released           = 17,
   ompt_callback_dependences              = 18,
   ompt_callback_task_dependence          = 19,
   ompt_callback_work                     = 20,
-  ompt_callback_master                   = 21,
+  ompt_callback_master     DEPRECATED_51 = 21,
+  ompt_callback_masked                   = 21,
   ompt_callback_target_map               = 22,
   ompt_callback_sync_region              = 23,
   ompt_callback_lock_init                = 24,
   ompt_callback_lock_destroy             = 25,
   ompt_callback_mutex_acquire            = 26,
   ompt_callback_mutex_acquired           = 27,
   ompt_callback_nest_lock                = 28,
   ompt_callback_flush                    = 29,
   ompt_callback_cancel                   = 30,
   ompt_callback_reduction                = 31,
-  ompt_callback_dispatch                 = 32
+  ompt_callback_dispatch                 = 32,
+  ompt_callback_target_emi               = 33,
+  ompt_callback_target_data_op_emi       = 34,
+  ompt_callback_target_submit_emi        = 35,
+  ompt_callback_target_map_emi           = 36,
+  ompt_callback_error                    = 37
 } ompt_callbacks_t;
 
 typedef enum ompt_record_t {
   ompt_record_ompt               = 1,
   ompt_record_native             = 2,
   ompt_record_invalid            = 3
 } ompt_record_t;
 
typedef enum ompt_thread_t {
   ompt_thread_initial                 = 1,
   ompt_thread_worker                  = 2,
   ompt_thread_other                   = 3,
   ompt_thread_unknown                 = 4
 } ompt_thread_t;
 
 typedef enum ompt_scope_endpoint_t {
   ompt_scope_begin                    = 1,
-  ompt_scope_end                      = 2
+  ompt_scope_end                      = 2,
+  ompt_scope_beginend                 = 3
 } ompt_scope_endpoint_t;
 
 typedef enum ompt_dispatch_t {
   ompt_dispatch_iteration             = 1,
   ompt_dispatch_section               = 2
 } ompt_dispatch_t;
 
 typedef enum ompt_sync_region_t {
-  ompt_sync_region_barrier                = 1,
-  ompt_sync_region_barrier_implicit       = 2,
+  ompt_sync_region_barrier                DEPRECATED_51 = 1,
+  ompt_sync_region_barrier_implicit       DEPRECATED_51 = 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_reduction              = 7,
+  ompt_sync_region_barrier_implicit_workshare = 8,
+  ompt_sync_region_barrier_implicit_parallel = 9,
+  ompt_sync_region_barrier_teams = 10
 } ompt_sync_region_t;
 
 typedef enum ompt_target_data_op_t {
-  ompt_target_data_alloc                = 1,
-  ompt_target_data_transfer_to_device   = 2,
-  ompt_target_data_transfer_from_device = 3,
-  ompt_target_data_delete               = 4,
-  ompt_target_data_associate            = 5,
-  ompt_target_data_disassociate         = 6
+  ompt_target_data_alloc                      = 1,
+  ompt_target_data_transfer_to_device         = 2,
+  ompt_target_data_transfer_from_device       = 3,
+  ompt_target_data_delete                     = 4,
+  ompt_target_data_associate                  = 5,
+  ompt_target_data_disassociate               = 6,
+  ompt_target_data_alloc_async                = 17,
+  ompt_target_data_transfer_to_device_async   = 18,
+  ompt_target_data_transfer_from_device_async = 19,
+  ompt_target_data_delete_async               = 20
 } ompt_target_data_op_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_taskloop           = 7,
+  ompt_work_scope              = 8
 } ompt_work_t;
 
 typedef enum ompt_mutex_t {
   ompt_mutex_lock                     = 1,
   ompt_mutex_test_lock                = 2,
   ompt_mutex_nest_lock                = 3,
   ompt_mutex_test_nest_lock           = 4,
   ompt_mutex_critical                 = 5,
typedef enum ompt_native_mon_flag_t {
   ompt_native_idleness                = 0x80
 } ompt_native_mon_flag_t;
 
 typedef enum ompt_task_flag_t {
   ompt_task_initial                   = 0x00000001,
   ompt_task_implicit                  = 0x00000002,
   ompt_task_explicit                  = 0x00000004,
   ompt_task_target                    = 0x00000008,
+  ompt_task_taskwait                  = 0x00000010,
   ompt_task_undeferred                = 0x08000000,
   ompt_task_untied                    = 0x10000000,
   ompt_task_final                     = 0x20000000,
   ompt_task_mergeable                 = 0x40000000,
   ompt_task_merged                    = 0x80000000
 } ompt_task_flag_t;
 
 typedef enum ompt_task_status_t {
   ompt_task_complete      = 1,
   ompt_task_yield         = 2,
   ompt_task_cancel        = 3,
   ompt_task_detach        = 4,
   ompt_task_early_fulfill = 5,
   ompt_task_late_fulfill  = 6,
-  ompt_task_switch        = 7
+  ompt_task_switch        = 7,
+  ompt_taskwait_complete  = 8
 } ompt_task_status_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_update                  = 4,
+  ompt_target_nowait                  = 9,
+  ompt_target_enter_data_nowait       = 10,
+  ompt_target_exit_data_nowait        = 11,
+  ompt_target_update_nowait           = 12
 } ompt_target_t;
 
 typedef enum ompt_parallel_flag_t {
   ompt_parallel_invoker_program = 0x00000001,
   ompt_parallel_invoker_runtime = 0x00000002,
   ompt_parallel_league          = 0x40000000,
   ompt_parallel_team            = 0x80000000
 } ompt_parallel_flag_t;
 
 typedef enum ompt_target_map_flag_t {
   ompt_target_map_flag_to             = 0x01,
   ompt_target_map_flag_from           = 0x02,
   ompt_target_map_flag_alloc          = 0x04,
   ompt_target_map_flag_release        = 0x08,
   ompt_target_map_flag_delete         = 0x10,
   ompt_target_map_flag_implicit       = 0x20
 } ompt_target_map_flag_t;
 
 typedef enum ompt_dependence_type_t {
   ompt_dependence_type_in              = 1,
   ompt_dependence_type_out             = 2,
   ompt_dependence_type_inout           = 3,
   ompt_dependence_type_mutexinoutset   = 4,
   ompt_dependence_type_source          = 5,
-  ompt_dependence_type_sink            = 6
+  ompt_dependence_type_sink            = 6,
+  ompt_dependence_type_inoutset        = 7
 } ompt_dependence_type_t;
 
+typedef enum ompt_severity_t {
+  ompt_warning                         = 1,
+  ompt_fatal                           = 2
+} ompt_severity_t;
+
 typedef enum ompt_cancel_flag_t {
   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
typedef enum ompt_frame_flag_t {
   ompt_frame_stackaddress   = 0x30
 } ompt_frame_flag_t;
 
 typedef enum ompt_state_t {
   ompt_state_work_serial                      = 0x000,
   ompt_state_work_parallel                    = 0x001,
   ompt_state_work_reduction                   = 0x002,
 
-  ompt_state_wait_barrier                     = 0x010,
+  ompt_state_wait_barrier                     DEPRECATED_51 = 0x010,
   ompt_state_wait_barrier_implicit_parallel   = 0x011,
   ompt_state_wait_barrier_implicit_workshare  = 0x012,
-  ompt_state_wait_barrier_implicit            = 0x013,
+  ompt_state_wait_barrier_implicit            DEPRECATED_51 = 0x013,
   ompt_state_wait_barrier_explicit            = 0x014,
+  ompt_state_wait_barrier_implementation      = 0x015,
+  ompt_state_wait_barrier_teams               = 0x016,
 
   ompt_state_wait_taskwait                    = 0x020,
   ompt_state_wait_taskgroup                   = 0x021,
 
   ompt_state_wait_mutex                       = 0x040,
   ompt_state_wait_lock                        = 0x041,
   ompt_state_wait_critical                    = 0x042,
   ompt_state_wait_atomic                      = 0x043,
typedef struct ompt_record_implicit_task_t {
   ompt_scope_endpoint_t endpoint;
   ompt_id_t parallel_id;
   ompt_id_t task_id;
   unsigned int actual_parallelism;
   unsigned int index;
   int flags;
 } ompt_record_implicit_task_t;
 
-typedef void (*ompt_callback_master_t) (
+typedef void (*ompt_callback_masked_t) (
   ompt_scope_endpoint_t endpoint,
   ompt_data_t *parallel_data,
   ompt_data_t *task_data,
   const void *codeptr_ra
 );
 
-typedef struct ompt_record_master_t {
+typedef ompt_callback_masked_t ompt_callback_master_t DEPRECATED_51;
+
+typedef struct ompt_record_masked_t {
   ompt_scope_endpoint_t endpoint;
   ompt_id_t parallel_id;
   ompt_id_t task_id;
   const void *codeptr_ra;
-} ompt_record_master_t;
+} ompt_record_masked_t;
 
 typedef void (*ompt_callback_sync_region_t) (
   ompt_sync_region_t kind,
   ompt_scope_endpoint_t endpoint,
   ompt_data_t *parallel_data,
   ompt_data_t *task_data,
   const void *codeptr_ra
 );
typedef void (*ompt_callback_device_load_t) (
   uint64_t module_id
 );
 
 typedef void (*ompt_callback_device_unload_t) (
   int device_num,
   uint64_t module_id
 );
 
+typedef void (*ompt_callback_target_data_op_emi_t) (
+  ompt_scope_endpoint_t endpoint,
+  ompt_data_t *target_task_data,
+  ompt_data_t *target_data,
+  ompt_id_t *host_op_id,
+  ompt_target_data_op_t optype,
+  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_data_op_t) (
   ompt_id_t target_id,
   ompt_id_t host_op_id,
   ompt_target_data_op_t optype,
   void *src_addr,
   int src_device_num,
   void *dest_addr,
   int dest_device_num,
   size_t bytes,
   const void *codeptr_ra
 );
 
 typedef struct ompt_record_target_data_op_t {
   ompt_id_t host_op_id;
   ompt_target_data_op_t optype;
   void *src_addr;
   int src_device_num;
   void *dest_addr;
   int dest_device_num;
   size_t bytes;
   ompt_device_time_t end_time;
   const void *codeptr_ra;
 } ompt_record_target_data_op_t;
 
+typedef void (*ompt_callback_target_emi_t) (
+  ompt_target_t kind,
+  ompt_scope_endpoint_t endpoint,
+  int device_num,
+  ompt_data_t *task_data,
+  ompt_data_t *target_task_data,
+  ompt_data_t *target_data,
+  const void *codeptr_ra
+);
+
 typedef void (*ompt_callback_target_t) (
   ompt_target_t kind,
   ompt_scope_endpoint_t endpoint,
   int device_num,
   ompt_data_t *task_data,
   ompt_id_t target_id,
   const void *codeptr_ra
 );
 
 typedef struct ompt_record_target_t {
   ompt_target_t kind;
   ompt_scope_endpoint_t endpoint;
   int device_num;
   ompt_id_t task_id;
   ompt_id_t target_id;
   const void *codeptr_ra;
 } ompt_record_target_t;
 
+typedef void (*ompt_callback_target_map_emi_t) (
+  ompt_data_t *target_data,
+  unsigned int nitems,
+  void **host_addr,
+  void **device_addr,
+  size_t *bytes,
+  unsigned int *mapping_flags,
+  const void *codeptr_ra
+);
+
 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,
   const void *codeptr_ra
 );
 
 typedef struct ompt_record_target_map_t {
   ompt_id_t target_id;
   unsigned int nitems;
   void **host_addr;
   void **device_addr;
   size_t *bytes;
   unsigned int *mapping_flags;
   const void *codeptr_ra;
 } ompt_record_target_map_t;
 
+typedef void (*ompt_callback_target_submit_emi_t) (
+  ompt_scope_endpoint_t endpoint,
+  ompt_data_t *target_data,
+  ompt_id_t *host_op_id,
+  unsigned int requested_num_teams
+);
+
 typedef void (*ompt_callback_target_submit_t) (
   ompt_id_t target_id,
   ompt_id_t host_op_id,
   unsigned int requested_num_teams
 );
 
 typedef struct ompt_record_target_kernel_t {
   ompt_id_t host_op_id;

 );
 
 typedef struct ompt_record_control_tool_t {
   uint64_t command;
   uint64_t modifier;
   const void *codeptr_ra;
 } ompt_record_control_tool_t;
 
+typedef void (*ompt_callback_error_t) (
+  ompt_severity_t severity,
+  const char *message, size_t length,
+  const void *codeptr_ra
+);
+
 typedef struct ompd_address_t {
   ompd_seg_t segment;
   ompd_addr_t address;
 } ompd_address_t;
 
 typedef struct ompd_frame_info_t {
   ompd_address_t frame_address;
   ompd_word_t frame_flag;
union {
     ompt_record_parallel_end_t parallel_end;
     ompt_record_work_t work;
     ompt_record_dispatch_t dispatch;
     ompt_record_task_create_t task_create;
     ompt_record_dependences_t dependences;
     ompt_record_task_dependence_t task_dependence;
     ompt_record_task_schedule_t task_schedule;
     ompt_record_implicit_task_t implicit_task;
-    ompt_record_master_t master;
+    ompt_record_masked_t masked;
     ompt_record_sync_region_t sync_region;
     ompt_record_mutex_acquire_t mutex_acquire;
     ompt_record_mutex_t mutex;
     ompt_record_nest_lock_t nest_lock;
     ompt_record_flush_t flush;
     ompt_record_cancel_t cancel;
     ompt_record_target_t target;
     ompt_record_target_data_op_t target_data_op;

openmp/runtime/src/kmp_csupport.cpp

kmp_int32 __kmpc_master(ident_t *loc, kmp_int32 global_tid) {
   if (KMP_MASTER_GTID(global_tid)) {
     KMP_COUNT_BLOCK(OMP_MASTER);
     KMP_PUSH_PARTITIONED_TIMER(OMP_master);
     status = 1;
   }
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (status) {
-    if (ompt_enabled.ompt_callback_master) {
+    if (ompt_enabled.ompt_callback_masked) {
       kmp_info_t *this_thr = __kmp_threads[global_tid];
       kmp_team_t *team = this_thr->th.th_team;
 
       int tid = __kmp_tid_from_gtid(global_tid);
-      ompt_callbacks.ompt_callback(ompt_callback_master)(
+      ompt_callbacks.ompt_callback(ompt_callback_masked)(
           ompt_scope_begin, &(team->t.ompt_team_info.parallel_data),
           &(team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_data),
           OMPT_GET_RETURN_ADDRESS(0));
     }
   }
 #endif
 
   if (__kmp_env_consistency_check) {
void __kmpc_end_master(ident_t *loc, kmp_int32 global_tid) {
   KC_TRACE(10, ("__kmpc_end_master: called T#%d\n", global_tid));
   __kmp_assert_valid_gtid(global_tid);
   KMP_DEBUG_ASSERT(KMP_MASTER_GTID(global_tid));
   KMP_POP_PARTITIONED_TIMER();
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   kmp_info_t *this_thr = __kmp_threads[global_tid];
   kmp_team_t *team = this_thr->th.th_team;
-  if (ompt_enabled.ompt_callback_master) {
+  if (ompt_enabled.ompt_callback_masked) {
     int tid = __kmp_tid_from_gtid(global_tid);
-    ompt_callbacks.ompt_callback(ompt_callback_master)(
+    ompt_callbacks.ompt_callback(ompt_callback_masked)(
         ompt_scope_end, &(team->t.ompt_team_info.parallel_data),
         &(team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_data),
         OMPT_GET_RETURN_ADDRESS(0));
   }
 #endif
 
   if (__kmp_env_consistency_check) {
     if (KMP_MASTER_GTID(global_tid))

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

 #define ompt_callback_parallel_end_implemented ompt_event_MAY_ALWAYS
 
 #define ompt_callback_task_create_implemented ompt_event_MAY_ALWAYS
 #define ompt_callback_task_schedule_implemented ompt_event_MAY_ALWAYS
 
 #define ompt_callback_implicit_task_implemented ompt_event_MAY_ALWAYS
 
 #define ompt_callback_target_implemented ompt_event_UNIMPLEMENTED
+#define ompt_callback_target_emi_implemented ompt_event_UNIMPLEMENTED
 #define ompt_callback_target_data_op_implemented ompt_event_UNIMPLEMENTED
+#define ompt_callback_target_data_op_emi_implemented ompt_event_UNIMPLEMENTED
 #define ompt_callback_target_submit_implemented ompt_event_UNIMPLEMENTED
+#define ompt_callback_target_submit_emi_implemented ompt_event_UNIMPLEMENTED
 
 #define ompt_callback_control_tool_implemented ompt_event_MAY_ALWAYS
 
 #define ompt_callback_device_initialize_implemented ompt_event_UNIMPLEMENTED
 #define ompt_callback_device_finalize_implemented ompt_event_UNIMPLEMENTED
 
 #define ompt_callback_device_load_implemented ompt_event_UNIMPLEMENTED
 #define ompt_callback_device_unload_implemented ompt_event_UNIMPLEMENTED
 
 /*----------------------------------------------------------------------------
  | Optional Events
  +--------------------------------------------------------------------------*/
 
 #define ompt_callback_sync_region_wait_implemented                             \
   ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_mutex_released_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_dependences_implemented                             \
   ompt_event_MAY_ALWAYS_OPTIONAL
 #define ompt_callback_task_dependence_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_work_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
-#define ompt_callback_master_implemented ompt_event_MAY_ALWAYS_OPTIONAL
+#define ompt_callback_masked_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_target_map_implemented ompt_event_UNIMPLEMENTED
+#define ompt_callback_target_map_emi_implemented ompt_event_UNIMPLEMENTED
 
 #define ompt_callback_sync_region_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_lock_init_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 #define ompt_callback_lock_destroy_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #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_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_dispatch_implemented ompt_event_UNIMPLEMENTED
 
+#define ompt_callback_error_implemented ompt_event_UNIMPLEMENTED
+
 #endif

openmp/runtime/test/ompt/callback.h

case ompt_scope_begin:
              ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
     case ompt_scope_end:
       printf("%" PRIu64 ":" _TOOL_PREFIX
              " ompt_event_release_nest_lock_prev: wait_id=%" PRIu64
              ", codeptr_ra=%p \n",
              ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
+    case ompt_scope_beginend:
+      printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+      exit(-1);
   }
 }
 
 static void
 on_ompt_callback_sync_region(
   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_implicit_workshare:
+        case ompt_sync_region_barrier_implicit_parallel:
+        case ompt_sync_region_barrier_teams:
         case ompt_sync_region_barrier_explicit:
         case ompt_sync_region_barrier_implementation:
           printf("%" PRIu64 ":" _TOOL_PREFIX
                  " 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);
case ompt_scope_begin:
       }
       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_implicit_workshare:
+        case ompt_sync_region_barrier_implicit_parallel:
+        case ompt_sync_region_barrier_teams:
         case ompt_sync_region_barrier_implementation:
           printf("%" PRIu64 ":" _TOOL_PREFIX
                  " 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_scope_end:
           break;
         case ompt_sync_region_reduction:
           printf("ompt_sync_region_reduction should never be passed to "
                  "on_ompt_callback_sync_region\n");
           exit(-1);
           break;
       }
       break;
+    case ompt_scope_beginend:
+      printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+      exit(-1);
   }
 }
 
 static void
 on_ompt_callback_sync_region_wait(
   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_implicit_workshare:
+        case ompt_sync_region_barrier_implicit_parallel:
+        case ompt_sync_region_barrier_teams:
         case ompt_sync_region_barrier_explicit:
         case ompt_sync_region_barrier_implementation:
           printf("%" PRIu64 ":" _TOOL_PREFIX
                  " 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_scope_begin:
           break;
       }
       break;
     case ompt_scope_end:
       switch(kind)
       {
         case ompt_sync_region_barrier:
         case ompt_sync_region_barrier_implicit:
+        case ompt_sync_region_barrier_implicit_workshare:
+        case ompt_sync_region_barrier_implicit_parallel:
+        case ompt_sync_region_barrier_teams:
         case ompt_sync_region_barrier_explicit:
         case ompt_sync_region_barrier_implementation:
           printf("%" PRIu64 ":" _TOOL_PREFIX
                  " 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);
case ompt_scope_end:
           break;
         case ompt_sync_region_reduction:
           printf("ompt_sync_region_reduction should never be passed to "
                  "on_ompt_callback_sync_region_wait\n");
           exit(-1);
           break;
       }
       break;
+    case ompt_scope_beginend:
+      printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+      exit(-1);
   }
 }
 
 static void on_ompt_callback_reduction(ompt_sync_region_t kind,
                                        ompt_scope_endpoint_t endpoint,
                                        ompt_data_t *parallel_data,
                                        ompt_data_t *task_data,
                                        const void *codeptr_ra) {
static void on_ompt_callback_reduction(ompt_sync_region_t kind,
   case ompt_scope_end:
     printf("%" PRIu64 ":" _TOOL_PREFIX
            " 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;
+  case ompt_scope_beginend:
+    printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+    exit(-1);
   }
 }
 
 static void
 on_ompt_callback_flush(
     ompt_data_t *thread_data,
     const void *codeptr_ra)
 {
case ompt_scope_end:
                " 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;
+    case ompt_scope_beginend:
+      printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+      exit(-1);
   }
 }
 
 static void
 on_ompt_callback_lock_init(
   ompt_mutex_t kind,
   unsigned int hint,
   unsigned int impl,
case ompt_scope_begin:
           //impl
           printf("%" PRIu64 ":" _TOOL_PREFIX
                  " ompt_event_taskloop_begin: parallel_id=%" PRIu64
                  ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
                  "\n",
                  ompt_get_thread_data()->value, parallel_data->value,
                  task_data->value, codeptr_ra, count);
           break;
+        case ompt_work_scope:
+          printf("%" PRIu64 ":" _TOOL_PREFIX
+                 " ompt_event_scope_begin: parallel_id=%" PRIu64
+                 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
+                 "\n",
+                 ompt_get_thread_data()->value, parallel_data->value,
+                 task_data->value, codeptr_ra, count);
+          break;
       }
       break;
     case ompt_scope_end:
       switch(wstype)
       {
         case ompt_work_loop:
           printf("%" PRIu64 ":" _TOOL_PREFIX
                  " ompt_event_loop_end: parallel_id=%" PRIu64
case ompt_scope_end:
           //impl
           printf("%" PRIu64 ":" _TOOL_PREFIX
                  " ompt_event_taskloop_end: parallel_id=%" PRIu64
                  ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
                  "\n",
                  ompt_get_thread_data()->value, parallel_data->value,
                  task_data->value, codeptr_ra, count);
           break;
+        case ompt_work_scope:
+          printf("%" PRIu64 ":" _TOOL_PREFIX
+                 " ompt_event_scope_end: parallel_id=%" PRIu64
+                 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
+                 "\n",
+                 ompt_get_thread_data()->value, parallel_data->value,
+                 task_data->value, codeptr_ra, count);
+          break;
       }
       break;
+    case ompt_scope_beginend:
+      printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+      exit(-1);
   }
 }
 
-static void
-on_ompt_callback_master(
-  ompt_scope_endpoint_t endpoint,
+static void on_ompt_callback_masked(ompt_scope_endpoint_t endpoint,
                                     ompt_data_t *parallel_data,
                                     ompt_data_t *task_data,
-  const void *codeptr_ra)
-{
+                                    const void *codeptr_ra) {
   switch(endpoint)
   {
     case ompt_scope_begin:
       printf("%" PRIu64 ":" _TOOL_PREFIX
-             " ompt_event_master_begin: parallel_id=%" PRIu64
+             " ompt_event_masked_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 ":" _TOOL_PREFIX
-             " ompt_event_master_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64
+             " ompt_event_masked_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;
+    case ompt_scope_beginend:
+      printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+      exit(-1);
   }
 }
 
 static void on_ompt_callback_parallel_begin(
     ompt_data_t *encountering_task_data,
     const ompt_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)
int ompt_initialize(
   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);
+  register_callback(ompt_callback_masked);
   register_callback(ompt_callback_parallel_begin);
   register_callback(ompt_callback_parallel_end);
   register_callback(ompt_callback_task_create);
   register_callback(ompt_callback_task_schedule);
   register_callback(ompt_callback_dependences);
   register_callback(ompt_callback_task_dependence);
   register_callback(ompt_callback_thread_begin);
   register_callback(ompt_callback_thread_end);

openmp/runtime/test/ompt/cancel/cancel_taskgroup.c

#pragma omp master
           printf("end execute task 4\n");
         }
         OMPT_SIGNAL(condition);
       }
     }
     #pragma omp barrier
   }
 
-
   // Check if libomp supports the callbacks for this test.
-  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_master'
+  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_masked'
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create'
-  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule'
-  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_cancel'
+  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule' 
+  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_cancel' 
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_begin'
 
-
   // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]]
-  // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_master_begin: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}
+  // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_masked_begin:
+  // CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]],
+  // CHECK-SAME: task_id=[[PARENT_TASK_ID:[0-9]+]],
+  // CHECK-SAME: codeptr_ra={{0x[0-f]*}}
 
   // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID]], parent_task_frame.exit={{0x[0-f]*}}, parent_task_frame.reenter={{0x[0-f]*}}, new_task_id=[[FIRST_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}, task_type=ompt_task_explicit=4, has_dependences=no
   // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID]], parent_task_frame.exit={{0x[0-f]*}}, parent_task_frame.reenter={{0x[0-f]*}}, new_task_id=[[SECOND_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}, task_type=ompt_task_explicit=4, has_dependences=no
   // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID]], parent_task_frame.exit={{0x[0-f]*}}, parent_task_frame.reenter={{0x[0-f]*}}, new_task_id=[[THIRD_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}, task_type=ompt_task_explicit=4, has_dependences=no
 
   // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID]], parent_task_frame.exit={{0x[0-f]*}}, parent_task_frame.reenter={{0x[0-f]*}}, new_task_id=[[CANCEL_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}, task_type=ompt_task_explicit|ompt_task_undeferred=134217732, has_dependences=no
   // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[PARENT_TASK_ID]], second_task_id=[[CANCEL_TASK_ID]], prior_task_status=ompt_task_switch=7
   // CHECK: {{^}}[[MASTER_ID]]: ompt_event_cancel: task_data=[[CANCEL_TASK_ID]], flags=ompt_cancel_taskgroup|ompt_cancel_activated=24, codeptr_ra={{0x[0-f]*}}

openmp/runtime/test/ompt/loadtool/tool_available/tool_available.c

 
 #endif /* CODE */
 
 #ifdef TOOL
 
 #include <stdio.h>
 #include <omp-tools.h>
 
-int ompt_initialize(
-  ompt_function_lookup_t lookup,
-  ompt_data_t* tool_data)
-{
+int ompt_initialize(ompt_function_lookup_t lookup, int initial_device_num,
+                    ompt_data_t *tool_data) {
   printf("0: NULL_POINTER=%p\n", (void*)NULL);
   return 1; //success
 }
 
 void ompt_finalize(ompt_data_t* tool_data)
 {
   printf("0: ompt_event_runtime_shutdown\n");
 }

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

 static void
 on_ompt_callback_thread_begin(
   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)
-{
+int ompt_initialize(ompt_function_lookup_t lookup, int initial_device_num,
+                    ompt_data_t *tool_data) {
   ompt_set_callback_t ompt_set_callback = (ompt_set_callback_t) lookup("ompt_set_callback");
   ompt_set_callback(ompt_callback_thread_begin, (ompt_callback_t)on_ompt_callback_thread_begin);
   printf("0: Tool initialized\n");
   return 1;
 }
 
 void ompt_finalize(ompt_data_t *tool_data)
 {

openmp/runtime/test/ompt/misc/api_calls_without_ompt.c

int main() {
 
   // CHECK: {{^}}[[MASTER_ID]]: ompt_get_parallel_info()=0
 
   // CHECK: {{^}}[[MASTER_ID]]: ompt_get_task_info()=0
 
   return 0;
 }
 
-int ompt_initialize(ompt_function_lookup_t lookup, ompt_data_t *tool_data) {
+int ompt_initialize(ompt_function_lookup_t lookup, int initial_device_num,
+                    ompt_data_t *tool_data) {
   ompt_set_callback = (ompt_set_callback_t)lookup("ompt_set_callback");
   ompt_get_callback = (ompt_get_callback_t)lookup("ompt_get_callback");
   ompt_get_state = (ompt_get_state_t)lookup("ompt_get_state");
   ompt_get_task_info = (ompt_get_task_info_t)lookup("ompt_get_task_info");
   ompt_get_thread_data = (ompt_get_thread_data_t)lookup("ompt_get_thread_data");
   ompt_get_parallel_info =
       (ompt_get_parallel_info_t)lookup("ompt_get_parallel_info");
   ompt_get_unique_id = (ompt_get_unique_id_t)lookup("ompt_get_unique_id");

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

case ompt_scope_begin:
       task_data->value = ompt_get_unique_id();
       if (kind == ompt_sync_region_barrier_implicit)
         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_implicit)
         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_scope_beginend:
+      printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+      exit(-1);
   }
 }
 
 static void
 on_ompt_callback_sync_region_wait(
   ompt_sync_region_t kind,
   ompt_scope_endpoint_t endpoint,
   ompt_data_t *parallel_data,
case ompt_scope_begin:
                ", 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_implicit)
         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_scope_beginend:
+      printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+      exit(-1);
   }
 }
 
 #define register_callback_t(name, type)                       \
 do{                                                           \
   type f_##name = &on_##name;                                 \
   if (ompt_set_callback(name, (ompt_callback_t)f_##name) ==   \
       ompt_set_never)                                         \
     printf("0: Could not register callback '" #name "'\n");   \
 }while(0)
 
 #define register_callback(name) register_callback_t(name, name##_t)
 
-int ompt_initialize(
-  ompt_function_lookup_t lookup,
-  ompt_data_t *tool_data)
-{
+int ompt_initialize(ompt_function_lookup_t lookup, int initial_device_num,
+                    ompt_data_t *tool_data) {
   ompt_set_callback_t ompt_set_callback;
   ompt_set_callback = (ompt_set_callback_t) lookup("ompt_set_callback");
   ompt_get_unique_id = (ompt_get_unique_id_t) lookup("ompt_get_unique_id");
   ompt_get_thread_data = (ompt_get_thread_data_t) lookup("ompt_get_thread_data");
   register_callback(ompt_callback_sync_region);
   register_callback_t(ompt_callback_sync_region_wait, ompt_callback_sync_region_t);
   register_callback(ompt_callback_thread_begin);
   printf("0: NULL_POINTER=%p\n", (void*)NULL);

openmp/runtime/test/ompt/synchronization/masked.c

+// RUN: %libomp-compile-and-run | FileCheck %s
+// REQUIRES: ompt
+// GCC generates code that does not call the runtime for the master construct
+// XFAIL: gcc
+
+#include "callback.h"
+#include <omp.h>
+
+int main() {
+  int x = 0;
+#pragma omp parallel num_threads(2)
+  {
+#pragma omp master
+    {
+      print_fuzzy_address(1);
+      x++;
+    }
+    print_current_address(2);
+  }
+
+  printf("%" PRIu64 ": x=%d\n", ompt_get_thread_data()->value, x);
+
+  return 0;
+}
+
+// Check if libomp supports the callbacks for this test.
+// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_masked'
+
+// CHECK: 0: NULL_POINTER=[[NULL:.*$]]
+
+// CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_masked_begin:
+// CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[TASK_ID:[0-9]+]],
+// CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}
+// CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]]
+// CHECK: {{^}}[[MASTER_ID]]: ompt_event_masked_end:
+// CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]],
+// CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS_END:0x[0-f]+]]
+// CHECK: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS_END]]

openmp/runtime/test/ompt/synchronization/master.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 // GCC generates code that does not call the runtime for the master construct
 // XFAIL: gcc
 
+#define USE_PRIVATE_TOOL 1
 #include "callback.h"
 #include <omp.h>
 
 int main() {
   int x = 0;
 #pragma omp parallel num_threads(2)
   {
 #pragma omp master
     {
       print_fuzzy_address(1);
       x++;
     }
     print_current_address(2);
   }
 
   printf("%" PRIu64 ": x=%d\n", ompt_get_thread_data()->value, x);
 
   return 0;
 }
 
+static void on_ompt_callback_master(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 ":" _TOOL_PREFIX
+           " ompt_event_master_begin: codeptr_ra=%p\n",
+           ompt_get_thread_data()->value, codeptr_ra);
+    break;
+  case ompt_scope_end:
+    printf("%" PRIu64 ":" _TOOL_PREFIX
+           " ompt_event_master_end: codeptr_ra=%p\n",
+           ompt_get_thread_data()->value, codeptr_ra);
+    break;
+  case ompt_scope_beginend:
+    printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+    exit(-1);
+  }
+}
+
+static void on_ompt_callback_thread_begin(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 ":" _TOOL_PREFIX
+         " 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);
+}
+
+int ompt_initialize(ompt_function_lookup_t lookup, int initial_device_num,
+                    ompt_data_t *tool_data) {
+  ompt_set_callback = (ompt_set_callback_t)lookup("ompt_set_callback");
+  ompt_get_unique_id = (ompt_get_unique_id_t)lookup("ompt_get_unique_id");
+  ompt_get_thread_data = (ompt_get_thread_data_t)lookup("ompt_get_thread_data");
+
+  register_callback(ompt_callback_master);
+  printf("0: NULL_POINTER=%p\n", (void *)NULL);
+  return 1; // success
+}
+
+void ompt_finalize(ompt_data_t *tool_data) {}
+
+ompt_start_tool_result_t *ompt_start_tool(unsigned int omp_version,
+                                          const char *runtime_version) {
+  static ompt_start_tool_result_t ompt_start_tool_result = {&ompt_initialize,
+                                                            &ompt_finalize, 0};
+  return &ompt_start_tool_result;
+}
+
 // Check if libomp supports the callbacks for this test.
 // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_master'
 
 // CHECK: 0: NULL_POINTER=[[NULL:.*$]]
 
 // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_master_begin:
-// CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[TASK_ID:[0-9]+]],
 // CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}
 // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]]
 // CHECK: {{^}}[[MASTER_ID]]: ompt_event_master_end:
-// CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]],
 // CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS_END:0x[0-f]+]]
 // CHECK: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS_END]]

openmp/runtime/test/ompt/synchronization/nest_lock.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   //need to use an OpenMP construct so that OMPT will be initialized
   #pragma omp parallel num_threads(1)
     print_ids(0);
 
   omp_nest_lock_t nest_lock;
-  printf("%" PRIu64 ": &nest_lock: %lli\n", ompt_get_thread_data()->value, (ompt_wait_id_t)(uintptr_t) &nest_lock);
+  printf("%" PRIu64 ": &nest_lock: %" PRIu64 "\n",
+         ompt_get_thread_data()->value, (ompt_wait_id_t)(uintptr_t)&nest_lock);
   omp_init_nest_lock(&nest_lock);
   print_fuzzy_address(1);
   omp_set_nest_lock(&nest_lock);
   print_fuzzy_address(2);
   omp_set_nest_lock(&nest_lock);
   print_fuzzy_address(3);
   omp_unset_nest_lock(&nest_lock);
   print_fuzzy_address(4);

openmp/runtime/test/ompt/synchronization/taskgroup.c

#pragma omp master
         }
       }
       print_current_address(2);
     }
   }
 
 
   // Check if libomp supports the callbacks for this test.
-  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_master'
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create'
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule'
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_cancel'
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_begin'
 
 
   // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]]
 

openmp/runtime/test/ompt/tasks/task_memory.c

printf("ompt_event_implicit_task_begin: task_id=%" PRIu64
            ", memory_addr=%p, memory_size=%lu, result=%d \n",
            task_data->value, addr, size, result);
     break;
   case ompt_scope_end:
     printf("ompt_event_implicit_task_end: task_id=%" PRIu64
            ", memory_addr=%p, memory_size=%lu, result=%d \n",
            task_data->value, addr, size, result);
     break;
+  case ompt_scope_beginend:
+    printf("ompt_scope_beginend should never be passed to %s\n", __func__);
+    exit(-1);
   }
 }
 
 static void
 on_ompt_callback_task_create(ompt_data_t *encountering_task_data,
                              const ompt_frame_t *encountering_task_frame,
                              ompt_data_t *new_task_data, int flags,
                              int has_dependences, const void *codeptr_ra) {