[openmp] Add OMPT initialization in libomptarget

[lechenyu]

Summary

When loading libomptarget, the init function in libomptarget/src/rtl.cpp
will search for the libomptarget_start_tool function using libdl.
libomptarget_start_tool will pass those OMPT callbacks related to target
constructs to libomptarget

[lechenyu]

Run clang-format to fix warnings in code style

[grokos]

openmp/libomptarget/src/ompt-target.h

13

ompt_internal.h resides under runtime/src/, not libomptarget/src/.

openmp/libomptarget/src/rtl.cpp

71

If the call to start_tool failed, is it correct to claim that ompt is initialized? On the other hand, maybe it's enough that you've set ompt_target_enabled to 0.

[protze.joachim]

openmp/libomptarget/src/rtl.cpp

60

Below in line 103, __kmpc_get_target_offload is called directly without dlsym. Is that the preferred way to call into libomp?

71

The OMPT initialization mechanism should happen once during the execution of an application.
Is there a scenario, where this code might execute twice, so that the if(!ompt_initialized) might have any effect?

I just realized, that we will need to check what libomp is doing after forking a process, but that's a separate issue.

openmp/runtime/src/ompt-general.cpp

134

This function is called by libomptarget and should not be weak.

138–140

This will call __kmp_middle_initialize whenever libomptarget gets initialized. Is this ok?

[lechenyu]

Update ompt initialization in libomptarget:
    1. Change the initialization function name to "libomp_start_tool"
    2. Libomptarget uses weak symbol rather than libdl to retrieve
       libomp_start_tool
    3. Libomp_start_tool only sets the bitmap, since libomptarget will
       delegate the callback invocation to libomp. Libomptarget no
       longer needs the addresses of OMPT callbacks and entry points

[grokos]

openmp/libomptarget/src/interface.cpp

312–314 ↗

(On Diff #338233)

Remove

[lechenyu]

Remove an unnecessary conditional directive

[lechenyu]

openmp/libomptarget/src/interface.cpp

312–314 ↗

(On Diff #338233)

I have removed it in the new diff

openmp/libomptarget/src/ompt-target.h

13

This file no longer needs "ompt-internal.h" in the updated diff. For omp-tools.h, I have added LIBOMP_INCLUDE_DIR into LIBOMPTARGET_LLVM_INCLUDE_DIRS (at openmp/libomptarget/src/CMakeLists.txt:25).

[jdoerfert]

reverse ping.

Can we move this along? Are there blockers? If we need discussion let's do it next Wednesday.

[lechenyu]

Remove redundant macro definitions in omp-tools.h.var and rebase to the llvm/main

[hbae]

openmp/libomptarget/src/rtl.cpp

199

Can we also turn if off when !libomp_start_tool?

[protze.joachim]

openmp/libomptarget/src/rtl.cpp

199

Do you mean the ompt_initialized variable? I think, we just can remove this variable. LoadRTLs should only be called once during the execution.

All other code just looks at ompt_target_enabled, which is 0 if !libomp_start_tool.

[hbae]

openmp/libomptarget/src/rtl.cpp

199

Looks OK for now.
We may be able to add any clean-up changes in the follow-up patches.

[lechenyu]

Remove the unnecessary variable "libomp_start_tool".

[protze.joachim]

The fixed version LGTM

openmp/libomptarget/src/rtl.cpp

199

The ompt_initialized variable is gone now.

[hbae]

LGTM

openmp/libomptarget/CMakeLists.txt

 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} x86_64-pc-linux-gnu")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} nvptx64-nvidia-cuda")
 
 # Once the plugins for the different targets are validated, they will be added to
 # the list of supported targets in the current system.
 set (LIBOMPTARGET_SYSTEM_TARGETS "")
 set (LIBOMPTARGET_TESTED_PLUGINS "")
 
+# Check OMPT support
+set(OMPT_DEFAULT_IN_LIBOMPTARGET FALSE)
+if ((LIBOMP_HAVE_OMPT_SUPPORT) AND (NOT WIN32))
+  set(OMPT_DEFAULT_IN_LIBOMPTARGET TRUE)
+endif()
+set(LIBOMP_OMPT_SUPPORT_IN_LIBOMPTARGET ${OMPT_DEFAULT_IN_LIBOMPTARGET} CACHE BOOL
+        "OMPT-support in libomptarget?")
+if(LIBOMP_OMPT_SUPPORT_IN_LIBOMPTARGET)
+  message(STATUS "OMPT enabled in libomptarget")
+else()
+  message(STATUS "OMPT disabled in libomptarget")
+endif()
+
 # Check whether using debug mode. In debug mode, allow dumping progress
 # messages at runtime by default. Otherwise, it can be enabled
 # independently using the LIBOMPTARGET_ENABLE_DEBUG option.
 string( TOLOWER "${CMAKE_BUILD_TYPE}" LIBOMPTARGET_CMAKE_BUILD_TYPE)
 if(LIBOMPTARGET_CMAKE_BUILD_TYPE MATCHES debug)
   option(LIBOMPTARGET_ENABLE_DEBUG "Allow debug output with the environment variable LIBOMPTARGET_DEBUG=1" ON)
 else()
   option(LIBOMPTARGET_ENABLE_DEBUG "Allow debug output with the environment variable LIBOMPTARGET_DEBUG=1" OFF)

openmp/libomptarget/src/CMakeLists.txt

 set(LIBOMPTARGET_SRC_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/api.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/interface.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/rtl.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/omptarget.cpp
 )
 
-set(LIBOMPTARGET_SRC_FILES ${LIBOMPTARGET_SRC_FILES} PARENT_SCOPE)
+if(LIBOMP_OMPT_SUPPORT_IN_LIBOMPTARGET)
+  list(APPEND LIBOMPTARGET_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/ompt-target.cpp)
+  list(APPEND LIBOMPTARGET_LLVM_INCLUDE_DIRS ${LIBOMP_INCLUDE_DIR})
+endif()
 
+set(LIBOMPTARGET_SRC_FILES ${LIBOMPTARGET_SRC_FILES} PARENT_SCOPE)
 include_directories(${LIBOMPTARGET_LLVM_INCLUDE_DIRS})
 
 # Build libomptarget library with libdl dependency.
 add_library(omptarget SHARED ${LIBOMPTARGET_SRC_FILES})
 if (OPENMP_ENABLE_LIBOMPTARGET_PROFILING)
   # Add LLVMSupport dependency if profiling is enabled.
   # Linking with LLVM component libraries also requires
   # aligning the compile flags.

openmp/libomptarget/src/ompt-target.h

+#ifndef LIBOMPTARGET_OMPT_TARGET_H
+#define LIBOMPTARGET_OMPT_TARGET_H
+
+#include "omp-tools.h"
+
+#define _OMP_EXTERN extern "C"
+
+#define OMPT_WEAK_ATTRIBUTE __attribute__((weak))
+
+// The following structs are used to pass target-related OMPT callbacks to
+// libomptarget. The structs' definitions should be in sync with the definitions
+// in libomptarget/src/ompt_internal.h
+
+/* Bitmap to mark OpenMP 5.1 target events as registered*/
+typedef struct ompt_target_callbacks_active_s {
+  unsigned int enabled : 1;
+#define ompt_event_macro(event, callback, eventid) unsigned int event : 1;
+
+  FOREACH_OMPT_51_TARGET_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+} ompt_target_callbacks_active_t;
+
+extern ompt_target_callbacks_active_t ompt_target_enabled;
+
+_OMP_EXTERN OMPT_WEAK_ATTRIBUTE bool
+libomp_start_tool(ompt_target_callbacks_active_t *libomptarget_ompt_enabled);
+
+#endif // LIBOMPTARGET_OMPT_TARGET_H

openmp/libomptarget/src/ompt-target.cpp

+#include "ompt-target.h"
+
+ompt_target_callbacks_active_t ompt_target_enabled;

openmp/libomptarget/src/rtl.cpp

 //===----------- rtl.cpp - Target independent OpenMP target RTL -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Functionality for handling RTL plugins.
 //
 //===----------------------------------------------------------------------===//
 
 #include "rtl.h"
 #include "device.h"
 #include "private.h"
 
+#if OMPT_SUPPORT
+#include "ompt-target.h"
+#endif
+
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
 #include <dlfcn.h>
 #include <mutex>
 #include <string>
 
 // List of all plugins that can support offloading.
#ifdef OMPTARGET_PROFILE_ENABLED
   if (ProfileTraceFile)
     llvm::timeTraceProfilerInitialize(500 /* us */, "libomptarget");
 #endif
 }
 
 __attribute__((destructor(101))) void deinit() {
   DP("Deinit target library!\n");
   delete PM;
 
 #ifdef OMPTARGET_PROFILE_ENABLED
   if (ProfileTraceFile) {
     // TODO: add env var for file output
     if (auto E = llvm::timeTraceProfilerWrite(ProfileTraceFile, "-"))
       fprintf(stderr, "Error writing out the time trace\n");
 
     llvm::timeTraceProfilerCleanup();
   }
 #endif
 }
 
 void RTLsTy::LoadRTLs() {
   // Parse environment variable OMP_TARGET_OFFLOAD (if set)
   PM->TargetOffloadPolicy =
       (kmp_target_offload_kind_t)__kmpc_get_target_offload();
   if (PM->TargetOffloadPolicy == tgt_disabled) {
     return;
   }
 
#endif
     *((void **)&R.supports_empty_images) =
         dlsym(dynlib_handle, "__tgt_rtl_supports_empty_images");
     *((void **)&R.set_info_flag) =
         dlsym(dynlib_handle, "__tgt_rtl_set_info_flag");
     *((void **)&R.print_device_info) =
         dlsym(dynlib_handle, "__tgt_rtl_print_device_info");
   }
 
+#if OMPT_SUPPORT
+  DP("OMPT_SUPPORT is enabled in libomptarget\n");
+  DP("Init OMPT for libomptarget\n");
+  if (libomp_start_tool) {
+    DP("Retrieve libomp_start_tool successfully\n");
+    if (!libomp_start_tool(&ompt_target_enabled)) {
+      DP("Turn off OMPT in libomptarget because libomp_start_tool returns "
+         "false\n");
+      memset(&ompt_target_enabled, 0, sizeof(ompt_target_enabled));
+    }
+  }
+#endif
+
   DP("RTLs loaded!\n");
 
   return;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Functionality for registering libs
 

openmp/runtime/cmake/config-ix.cmake

#      (LIBOMP_ARCH STREQUAL arm) OR
       (LIBOMP_ARCH STREQUAL riscv64))
      AND # OS supported?
      ((WIN32 AND LIBOMP_HAVE_PSAPI) OR APPLE OR (NOT WIN32 AND LIBOMP_HAVE_WEAK_ATTRIBUTE)))
     set(LIBOMP_HAVE_OMPT_SUPPORT TRUE)
   else()
     set(LIBOMP_HAVE_OMPT_SUPPORT FALSE)
   endif()
 endif()
+set(LIBOMP_HAVE_OMPT_SUPPORT ${LIBOMP_HAVE_OMPT_SUPPORT} PARENT_SCOPE)
 
 # Check if HWLOC support is available
 if(${LIBOMP_USE_HWLOC})
   set(CMAKE_REQUIRED_INCLUDES ${LIBOMP_HWLOC_INSTALL_DIR}/include)
   check_include_file(hwloc.h LIBOMP_HAVE_HWLOC_H)
   set(CMAKE_REQUIRED_INCLUDES)
   find_library(LIBOMP_HWLOC_LIBRARY
     NAMES hwloc libhwloc

openmp/runtime/src/exports_so.txt

global: # Exported symbols.
         # "Normal" symbols.
         #
         omp_*;     # Standard OpenMP functions.
         OMP_*;     # Standard OpenMP symbols.
 
         #
         # OMPT API
         #
-        ompt_start_tool;     # OMPT start interface
+        ompt_start_tool;           # OMPT start interface
+        libomp_start_tool;         # OMPT start interface for libomptarget
+        libomp_ompt_*;             # OMPT callback functions
 
         ompc_*;    # omp.h renames some standard functions to ompc_*.
         kmp_*;     # Intel extensions.
         kmpc_*;    # Intel extensions.
         __kmpc_*;  # Functions called by compiler-generated code.
         GOMP_*;    # GNU C compatibility functions.
 
         _You_must_link_with_*;     # Mutual detection/MS compatibility symbols.

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

 
 
 #define FOREACH_KMP_MUTEX_IMPL(macro)                                                \
     macro (kmp_mutex_impl_none, 0)         /* unknown implementation */              \
     macro (kmp_mutex_impl_spin, 1)         /* based on spin */                       \
     macro (kmp_mutex_impl_queuing, 2)      /* based on some fair policy */           \
     macro (kmp_mutex_impl_speculative, 3)  /* based on HW-supported speculation */
 
-#define FOREACH_OMPT_EVENT(macro)                                                                                        \
+#define FOREACH_OMPT_HOST_EVENT(macro)                                                                                   \
                                                                                                                          \
     /*--- Mandatory Events ---*/                                                                                         \
     macro (ompt_callback_thread_begin,      ompt_callback_thread_begin_t,       1) /* thread begin                    */ \
     macro (ompt_callback_thread_end,        ompt_callback_thread_end_t,         2) /* thread end                      */ \
                                                                                                                          \
     macro (ompt_callback_parallel_begin,    ompt_callback_parallel_begin_t,     3) /* parallel begin                  */ \
     macro (ompt_callback_parallel_end,      ompt_callback_parallel_end_t,       4) /* parallel end                    */ \
                                                                                                                          \
     macro (ompt_callback_task_create,       ompt_callback_task_create_t,        5) /* task begin                      */ \
     macro (ompt_callback_task_schedule,     ompt_callback_task_schedule_t,      6) /* task schedule                   */ \
     macro (ompt_callback_implicit_task,     ompt_callback_implicit_task_t,      7) /* implicit task                   */ \
                                                                                                                          \
-    macro (ompt_callback_target,            ompt_callback_target_t,             8) /* target                          */ \
-    macro (ompt_callback_target_data_op,    ompt_callback_target_data_op_t,     9) /* target data op                  */ \
-    macro (ompt_callback_target_submit,     ompt_callback_target_submit_t,     10) /* target  submit                  */ \
                                                                                                                          \
     macro (ompt_callback_control_tool,      ompt_callback_control_tool_t,      11) /* control tool                    */ \
                                                                                                                          \
-    macro (ompt_callback_device_initialize, ompt_callback_device_initialize_t, 12) /* device initialize               */ \
-    macro (ompt_callback_device_finalize,   ompt_callback_device_finalize_t,   13) /* device finalize                 */ \
-                                                                                                                         \
-    macro (ompt_callback_device_load,       ompt_callback_device_load_t,       14) /* device load                     */ \
-    macro (ompt_callback_device_unload,     ompt_callback_device_unload_t,     15) /* device unload                   */ \
                                                                                                                          \
     /* Optional Events */                                                                                                \
     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_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_error,             ompt_callback_error_t,             37) /* error                           */
+
+
+#define FOREACH_OMPT_DEVICE_EVENT(macro)                                                                                 \
+    macro (ompt_callback_device_initialize, ompt_callback_device_initialize_t, 12) /* device initialize               */ \
+    macro (ompt_callback_device_finalize,   ompt_callback_device_finalize_t,   13) /* device finalize                 */ \
+                                                                                                                         \
+    macro (ompt_callback_device_load,       ompt_callback_device_load_t,       14) /* device load                     */ \
+    macro (ompt_callback_device_unload,     ompt_callback_device_unload_t,     15) /* device unload                   */ \
+
+
+#define FOREACH_OMPT_NOEMI_EVENT(macro)                                                                                  \
+    macro (ompt_callback_target,            ompt_callback_target_t,             8) /* target                          */ \
+    macro (ompt_callback_target_data_op,    ompt_callback_target_data_op_t,     9) /* target data op                  */ \
+    macro (ompt_callback_target_submit,     ompt_callback_target_submit_t,     10) /* target  submit                  */ \
+    macro (ompt_callback_target_map,        ompt_callback_target_map_t,        22) /* target map                      */ \
+
+
+#define FOREACH_OMPT_EMI_EVENT(macro)                                                                                    \
     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                           */
+
+#define FOREACH_OMPT_50_TARGET_EVENT(macro)                                                                              \
+    FOREACH_OMPT_DEVICE_EVENT(macro)                                                                                     \
+    FOREACH_OMPT_NOEMI_EVENT(macro) 
+
+#define FOREACH_OMPT_51_TARGET_EVENT(macro)                                                                              \
+    FOREACH_OMPT_DEVICE_EVENT(macro)                                                                                     \
+    FOREACH_OMPT_EMI_EVENT(macro) 
+
+#define FOREACH_OMPT_EVENT(macro)                                                                                        \
+    FOREACH_OMPT_HOST_EVENT(macro)                                                                                       \
+    FOREACH_OMPT_DEVICE_EVENT(macro)                                                                                     \
+    FOREACH_OMPT_NOEMI_EVENT(macro)                                                                                      \
+    FOREACH_OMPT_EMI_EVENT(macro)
+
+#define FOREACH_OMPT_51_EVENT(macro)                                                                                     \
+    FOREACH_OMPT_HOST_EVENT(macro)                                                                                       \
+    FOREACH_OMPT_DEVICE_EVENT(macro)                                                                                     \
+    FOREACH_OMPT_EMI_EVENT(macro)
 
 /*****************************************************************************
  * 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)

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

 
 #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_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_target_map_implemented ompt_event_MAY_ALWAYS_OPTIONAL
+#define ompt_callback_target_map_emi_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #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

openmp/runtime/src/ompt-general.cpp

 };
 
 /*****************************************************************************
  * global variables
  ****************************************************************************/
 
 ompt_callbacks_active_t ompt_enabled;
 
+ompt_target_callbacks_active_t ompt_target_enabled;
+
 ompt_state_info_t ompt_state_info[] = {
 #define ompt_state_macro(state, code) {#state, state},
     FOREACH_OMPT_STATE(ompt_state_macro)
 #undef ompt_state_macro
 };
 
 kmp_mutex_impl_info_t kmp_mutex_impl_info[] = {
 #define kmp_mutex_impl_macro(name, id) {#name, name},
     FOREACH_KMP_MUTEX_IMPL(kmp_mutex_impl_macro)
 #undef kmp_mutex_impl_macro
 };
 
 ompt_callbacks_internal_t ompt_callbacks;
 
+ompt_target_callbacks_internal_t ompt_target_callbacks;
+
+ompt_callbacks_internal_noemi_t ompt_callbacks_noemi;
+
 static ompt_start_tool_result_t *ompt_start_tool_result = NULL;
 
 #if KMP_OS_WINDOWS
 static HMODULE ompt_tool_module = NULL;
 #define OMPT_DLCLOSE(Lib) FreeLibrary(Lib)
 #else
 static void *ompt_tool_module = NULL;
 #define OMPT_DLCLOSE(Lib) dlclose(Lib)

 
 /*****************************************************************************
  * initialization and finalization (private operations)
  ****************************************************************************/
 
 typedef ompt_start_tool_result_t *(*ompt_start_tool_t)(unsigned int,
                                                        const char *);
 
+_OMP_EXTERN OMPT_WEAK_ATTRIBUTE bool
+libomp_start_tool(ompt_target_callbacks_active_t *libomptarget_ompt_enabled) {
+  if (!TCR_4(__kmp_init_middle)) {
+    __kmp_middle_initialize();
+  }
+  bool ret = false;
+  libomptarget_ompt_enabled->enabled = ompt_enabled.enabled;
+  if (ompt_enabled.enabled) {
+    ret = true;
+#define ompt_event_macro(event_name, callback_type, event_id)                  \
+  libomptarget_ompt_enabled->event_name = ompt_target_enabled.event_name;
+
+    FOREACH_OMPT_51_TARGET_EVENT(ompt_event_macro)
+#undef ompt_event_macro
+  }
+  return ret;
+}
+
+void ompt_callback_target_data_op_emi_wrapper(
+    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) {}
+
+void ompt_callback_target_emi_wrapper(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) {}
+
+void ompt_callback_target_map_emi_wrapper(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) {}
+
+void ompt_callback_target_submit_emi_wrapper(ompt_scope_endpoint_t endpoint,
+                                             ompt_data_t *target_data,
+                                             ompt_id_t *host_op_id,
+                                             unsigned int requested_num_teams) {
+
+}
+
 #if KMP_OS_DARWIN
 
 // While Darwin supports weak symbols, the library that wishes to provide a new
 // implementation has to link against this runtime which defeats the purpose
 // of having tools that are agnostic of the underlying runtime implementation.
 //
 // Fortunately, the linker includes all symbols of an executable in the global
 // symbol table by default so dlsym() even finds static implementations of
#define ompt_event_macro(event_name, callback_type, event_id)                  \
   case event_name:                                                             \
     ompt_callbacks.ompt_callback(event_name) = (callback_type)callback;        \
     ompt_enabled.event_name = (callback != 0);                                 \
     if (callback)                                                              \
       return ompt_event_implementation_status(event_name);                     \
     else                                                                       \
       return ompt_set_always;
 
-    FOREACH_OMPT_EVENT(ompt_event_macro)
+    FOREACH_OMPT_HOST_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+
+#define ompt_event_macro(event_name, callback_type, event_id)                  \
+  case event_name:                                                             \
+    ompt_target_callbacks.ompt_callback(event_name) = (callback_type)callback; \
+    ompt_target_enabled.event_name = (callback != 0);                          \
+    if (callback)                                                              \
+      return ompt_event_implementation_status(event_name);                     \
+    else                                                                       \
+      return ompt_set_always;
+
+    FOREACH_OMPT_51_TARGET_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+
+#define ompt_event_macro(event_name, callback_type, event_id)                  \
+  case event_name:                                                             \
+    ompt_callbacks_noemi.ompt_callback(event_name) = (callback_type)callback;  \
+    ompt_target_enabled.ompt_emi_event(event_name) = (callback != 0);          \
+    if (callback) {                                                            \
+      ompt_target_callbacks.ompt_emi_callback(event_name) =                    \
+          (ompt_emi_callback_type(event_name))(&ompt_emi_wrapper(event_name)); \
+      return ompt_event_implementation_status(event_name);                     \
+    } else {                                                                   \
+      ompt_target_callbacks.ompt_emi_callback(event_name) = NULL;              \
+      return ompt_set_always;                                                  \
+    }
+
+    FOREACH_OMPT_NOEMI_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 
   default:
     return ompt_set_error;
   }
 }
 
ompt_callback_t mycb =                                                     \
         (ompt_callback_t)ompt_callbacks.ompt_callback(event_name);             \
     if (ompt_enabled.event_name && mycb) {                                     \
       *callback = mycb;                                                        \
       return ompt_get_callback_success;                                        \
     }                                                                          \
     return ompt_get_callback_failure;                                          \
   }
 
-    FOREACH_OMPT_EVENT(ompt_event_macro)
+    FOREACH_OMPT_HOST_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+
+#define ompt_event_macro(event_name, callback_type, event_id)                  \
+  case event_name: {                                                           \
+    ompt_callback_t mycb =                                                     \
+        (ompt_callback_t)ompt_target_callbacks.ompt_callback(event_name);      \
+    if (ompt_target_enabled.event_name && mycb) {                              \
+      *callback = mycb;                                                        \
+      return ompt_get_callback_success;                                        \
+    }                                                                          \
+    return ompt_get_callback_failure;                                          \
+  }
+
+    FOREACH_OMPT_DEVICE_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+
+#define ompt_event_macro(event_name, callback_type, event_id)                  \
+  case ompt_emi_event(event_name): {                                           \
+    ompt_callback_t mycb =                                                     \
+        (ompt_callback_t)ompt_target_callbacks.ompt_emi_callback(event_name);  \
+    if (ompt_target_enabled.ompt_emi_event(event_name) &&                      \
+        mycb != (ompt_callback_t)(&ompt_emi_wrapper(event_name))) {            \
+      *callback = mycb;                                                        \
+      return ompt_get_callback_success;                                        \
+    }                                                                          \
+    return ompt_get_callback_failure;                                          \
+  }
+
+    FOREACH_OMPT_NOEMI_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+
+#define ompt_event_macro(event_name, callback_type, event_id)                  \
+  case event_name: {                                                           \
+    ompt_callback_t mycb =                                                     \
+        (ompt_callback_t)ompt_callbacks_noemi.ompt_callback(event_name);       \
+    ompt_callback_t wrapper =                                                  \
+        (ompt_callback_t)ompt_target_callbacks.ompt_emi_callback(event_name);  \
+    if (ompt_target_enabled.ompt_emi_event(event_name) &&                      \
+        wrapper == (ompt_callback_t)(&ompt_emi_wrapper(event_name))) {         \
+      *callback = mycb;                                                        \
+      return ompt_get_callback_success;                                        \
+    }                                                                          \
+    return ompt_get_callback_failure;                                          \
+  }
+
+    FOREACH_OMPT_NOEMI_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 
   default:
     return ompt_get_callback_failure;
   }
 }
 

openmp/runtime/src/ompt-internal.h

 #define _OMP_EXTERN extern "C"
 
 #define OMPT_INVOKER(x)                                                        \
   ((x == fork_context_gnu) ? ompt_parallel_invoker_program                     \
                            : ompt_parallel_invoker_runtime)
 
 #define ompt_callback(e) e##_callback
 
+#define ompt_emi_callback(e) e##_emi_callback
+
+#define ompt_emi_callback_type(e) e##_emi_t
+
+#define ompt_emi_wrapper(e) e##_emi_wrapper
+
+#define ompt_emi_event(e) e##_emi
+
+/* Struct to collect host callback pointers */
 typedef struct ompt_callbacks_internal_s {
 #define ompt_event_macro(event, callback, eventid)                             \
   callback ompt_callback(event);
 
-  FOREACH_OMPT_EVENT(ompt_event_macro)
+  FOREACH_OMPT_HOST_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 } ompt_callbacks_internal_t;
 
+/* Struct to collect target callback pointers */
+typedef struct ompt_target_callbacks_internal_s {
+#define ompt_event_macro(event, callback, eventid)                             \
+  callback ompt_callback(event);
+
+  FOREACH_OMPT_51_TARGET_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+} ompt_target_callbacks_internal_t;
+
+/* Struct to collect noemi callback pointers */
+typedef struct ompt_callbacks_internal_noemi_s {
+#define ompt_event_macro(event, callback, eventid)                             \
+  callback ompt_callback(event);
+
+  FOREACH_OMPT_NOEMI_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+} ompt_callbacks_internal_noemi_t;
+
+/* Bitmap to mark OpenMP 5.1 host events as registered*/
 typedef struct ompt_callbacks_active_s {
   unsigned int enabled : 1;
 #define ompt_event_macro(event, callback, eventid) unsigned int event : 1;
 
-  FOREACH_OMPT_EVENT(ompt_event_macro)
+  FOREACH_OMPT_HOST_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 } ompt_callbacks_active_t;
 
+/* Bitmap to mark OpenMP 5.1 target events as registered*/
+typedef struct ompt_target_callbacks_active_s {
+  unsigned int enabled : 1;
+#define ompt_event_macro(event, callback, eventid) unsigned int event : 1;
+
+  FOREACH_OMPT_51_TARGET_EVENT(ompt_event_macro)
+
+#undef ompt_event_macro
+} ompt_target_callbacks_active_t;
+
 #define TASK_TYPE_DETAILS_FORMAT(info)                                         \
   ((info->td_flags.task_serial || info->td_flags.tasking_ser)                  \
        ? ompt_task_undeferred                                                  \
        : 0x0) |                                                                \
       ((!(info->td_flags.tiedness)) ? ompt_task_untied : 0x0) |                \
       (info->td_flags.final ? ompt_task_final : 0x0) |                         \
       (info->td_flags.merged_if0 ? ompt_task_mergeable : 0x0)
 
typedef struct {
   ompt_state_t state;
   ompt_wait_id_t wait_id;
   int ompt_task_yielded;
   int parallel_flags; // information for the last parallel region invoked
   void *idle_frame;
 } ompt_thread_info_t;
 
 extern ompt_callbacks_internal_t ompt_callbacks;
+extern ompt_target_callbacks_internal_t ompt_target_callbacks;
+extern ompt_callbacks_internal_noemi_t ompt_callbacks_noemi;
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
 #if USE_FAST_MEMORY
 #define KMP_OMPT_DEPS_ALLOC __kmp_fast_allocate
 #define KMP_OMPT_DEPS_FREE __kmp_fast_free
 #else
 #define KMP_OMPT_DEPS_ALLOC __kmp_thread_malloc
 #define KMP_OMPT_DEPS_FREE __kmp_thread_free

 void ompt_fini(void);
 
 #define OMPT_GET_RETURN_ADDRESS(level) __builtin_return_address(level)
 #define OMPT_GET_FRAME_ADDRESS(level) __builtin_frame_address(level)
 
 int __kmp_control_tool(uint64_t command, uint64_t modifier, void *arg);
 
 extern ompt_callbacks_active_t ompt_enabled;
+extern ompt_target_callbacks_active_t ompt_target_enabled;
 
 #if KMP_OS_WINDOWS
 #define UNLIKELY(x) (x)
 #define OMPT_NOINLINE __declspec(noinline)
 #else
 #define UNLIKELY(x) __builtin_expect(!!(x), 0)
 #define OMPT_NOINLINE __attribute__((noinline))
 #endif
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif