[OpenMP] [OMPT] [amdgpu] [5/8] Implemented device init/fini/load callbacks

[mhalk]

Summary

Added support in the generic plugin to invoke registered callbacks.

Depends on D124070

Patch from John Mellor-Crummey <[e-mail]>
(With contributions from Dhruva Chakrabarti <[e-mail]>)

[dhruvachak]

Rebased

[jplehr]

openmp/libomptarget/include/ompt_device_callbacks.h

18

Should this be rather <string> or <cstring>?

openmp/libomptarget/plugins/amdgpu/src/ompt_callback.cpp

30 ↗

(On Diff #438557)

I'm not sure about this line. I understand it as it may leak memory, and invalidate all OmptDeviceTy pointers that may have been acquired. At least if this is executed more than once (for whatever reason).

[jplehr]

openmp/libomptarget/include/ompt_device_callbacks.h

53

In other parts I saw that C-style casts were changed to static_cast or reinterpret_cast.
Potentially stick to these C++ casts instead is preferable.

[jplehr]

Rebase / update

[jplehr]

Fixing build error in Debug configuration

[jplehr]

Rebased

[mhalk]

Rebased + related fixes

[mhalk]

Refactored patch for use with nextgen plugins.

[jplehr]

Thanks for moving this forward.

openmp/libomptarget/include/ompt_device_callbacks.h

52

If I recall correctly, methods should be formulated more in active voice, e.g., initializeOmptCallbackDevice, and start with a lower-case letter. I believe this is true for the other methods in this class as well.

141

I think this should be renamed to allocate or so, as the comment suggests that it allocates and does not resize.

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

30

Probably better use nullptr here.

33

Potentially we should not allocate if Devices already holds a pointer, i.e., is not nullptr? This looks suspiciously as if we can leak memory here.

39

Do we want / need to guard against out-of-bounds access here?

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

538–541

Idk if there is a guideline for it, but I personally would prefer to have this read as /* FileName= */ nullptr, ...

[mhalk]

When more changes have accumulated I'll update this diff with the changes I replied to with 'Done'.

openmp/libomptarget/include/ompt_device_callbacks.h

52

Agreed.
If more people request this NFC, I'll gladly incorporate this in the patch stack.
I decided against this, since I wanted to concentrate on the core of the patches and not defer them any longer.

141

Agreed. Done.

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

30

Done.

33

Agreed. I'll simply send a DebugPrint when allocation failed.
That is, when: zero or negative NumDevices were requested or when Devices was already allocated / non-nullptr.

39

I think we should.
Done.

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

538–541

I would be interested in that, too -- in the previous version of these files it was this (nullptr /* FileName= */,) way.
But TBH I don't find that intuitively either, i.e. I would also prefer your proposal.
Any other thoughts or info on this would be appreciated.

[dhruvachak]

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

33

Why not assert that Devices is nullptr before allocation?

[mhalk]

Patch rework; implemented feedback.

[mhalk]

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

33

I decided to update the revision, so you can see how I handled things "in the meantime".
(Hopefully, my intermediate changes won't break this, otherwise I'll have to update the whole patch stack.)

[dhruvachak]

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

33

I would not introduce a new variable for number of devices. I would just add an assert for what we are expecting.

[jdoerfert]

Read the large comment first, this might also result in changes to other patches. The design should match nextgen and it should be a proper part of it, not some attached afterthought.

openmp/libomptarget/include/ompt_device_callbacks.h

149

I don'n understand why there are so many static members and functions everywhere, but alas.

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

30

Also above?

31

Now there are static members, and static non members, I mean, why?

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

425

So, these OmptDevices are stored in 4 or so static members mostly inside OmptDeviceCallbacksTy, and initialized via a member of OmptDeviceCallbacks which is a global object that flies around.

This is really too much.

Let's approach this differently:
One OmptDeviceTy per device of a plugin, right?
If so, make one such object a member of GenericDeviceTy, all that array stuff and 4 functions can be removed, init and deinit are performed via constructor/destructor or init/deinit of the parent.
Funnily, once you do that, the entire OmptDeviceTy code would be moot and all you really put into GenericDeviceTy::(de)init is one conditional to check and call the callback.
You can even make a variadic macro that checks the callback and calls it, forwarding the args, which will simplify the pattern to sth like:

ompt_callback(device_initialize, DeviceNum, Type, reinterpret_cast<ompt_device_t *>(this), doLookup, Documentation);

Then, why do we need OmptDeviceCallbacksTy in the first place?
Shouldn't the callbacks be close to their invocation, e.g., in GenericDeviceTy, etc.

538–541

/* Name */ Value, which is hopefully what the rest of the code does.

[dhruvachak]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

425

I agree all or most of those statics can go away. There is a single instance of OmptDeviceCallbacksTy in libomptarget and another instance in the plugin. So those statics are redundant.

About OmptDeviceCallbacksTy, I suggest splitting it up into 2 structs. The first, OmptHostEventsCallbacksTy would contain the host callback function ptrs. The second, OmptDeviceEventsCallbacksTy would contain the 4 device callback function ptrs: load, unload, init, and fini. This is along the lines of the categories already present in omp-tools.h. Then, libomptarget would instantiate only OmptHostEventsCallbacksTy by using the "connect" interface to libomp. Similarly, the plugin would instantiate only OmptDeviceEventsCallbacksTy by using the "connect" interface to libomp. (In the current patch, the plugin connects to libomptarget, that will have to be changed.) The object of type OmptDeviceEventsCallbacksTy can reside in GenericDeviceTy. (Later on, when we introduce support for trace records, we will need new OMPT entry points that the tool can call. Examples: ompt_start_trace, ompt_flush_trace, etc. At that point, another struct OmptDeviceEntryPointsTy holding those entry points can be introduced, residing in GenericDeviceTy. But that's for later.) The object of type OmptHostEventsCallbacksTy can stay as a global object like in current trunk unless we find a better place for it.

[dhruvachak]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

1164

This will be a problem the way these patches currently are. GenericPluginTy::init() will kick in for multiple plugins, so multiple plugins will initialize the callbacks. Not a problem per se but where it will fail today is during tracking the finalizer in libomptarget. libomptarget is currently set up to track only 1 finalizer.

See openmp/libomptarget/src/OmptCallback.cpp
/// Object that will maintain the finalizer of the plugin
static LibomptargetRtlFinalizer LibOmptTargetRTLFinalizer;

So multiple plugins will have callbacks initialized and the last finalizer will overwrite the rest, not a good thing. (We should actually assert on this condition.)

One solution is to move the call to OmptCallbackInit() within the device-specific plugin implementations, e.g. in AMDGPUPluginTy::initImpl().

[mhalk]

Rebase + implementation of feedback

[mhalk]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

1164

Thanks and good catch -- I moved the calls to ompt::connectLibrary(); into the specific amdgpu & cuda plugins.
(This comment will be removed in a following diff update. Oversight.)

[mhalk]

Removed debug prints / comments and fixed a problem when no OMPT was initialized.

[mhalk]

Updated to accomodate the changes made in the previous patch.

[jdoerfert]

openmp/libomptarget/CMakeLists.txt

70

?

openmp/libomptarget/include/OmptConnector.h

103–104

?

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

35

Style, here and elsewhere. We use LLVM code style in the plugins, at least outside the C-bindings.

openmp/runtime/src/exports_so.txt

29 ↗

(On Diff #517683)

?

openmp/runtime/src/kmp_utility.cpp

410 ↗

(On Diff #517683)

?

[mhalk]

Addressed style issues, dreaded whitespace & removed DEBUG_PREFIX testing

[mhalk]

openmp/libomptarget/CMakeLists.txt

70

Had some issues, that was a testing leftover -- sorry!

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

35

Thanks! Should be addressed (catched three locations).

[mhalk]

This comment was removed by mhalk.

[mhalk]

Update + rebase to reflect the landing of https://reviews.llvm.org/D124070

@jdoerfert If there are any issues left or further improvements that should be implemented, please let me know.

[dhruvachak]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

29

Guard it with OMPT_SUPPORT?

858

So now the size of GenericDeviceTy varies based on whether OMPT support is compiled in or not. I would prefer removing the ifdef here and in the ctor (so that proper init happens) so that the size is the same regardless of cmake config. But I am not requesting this change, would be curious what others feel. I just like it that way since it helps debugging when there is a problem.

865

Give it a more meaningful name, it's just an atomic boolean now. Some OMPT APIs require an opaque ompt_device_t. In the previous version, we would pass a handle to OmptDevice for those APIs, so that may have to refactored when the time comes.

[dhruvachak]

openmp/libomptarget/src/OmptCallback.cpp

100

I thought we got rid of these 2 statics.

[mhalk]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

29

Yes, absolutely.

865

Check w.r.t. "API" and I'd tend to sth. like OmptInitialized, since we're already looking at a "Device" this should convey the fact that we're looking at a boolean that's true when this device's OMPT relatied init has been executed.

[dhruvachak]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

865

Ignore the second part of this comment about ompt_device_t. I see what you are doing already in this patch for the opaque handle and that looks good.

[jplehr]

Thanks for moving this forward.

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

425

Nit: I believe this should start w/ capital letter.

487

captial E

[mhalk]

Update: Removed statics (libomptarget->plugins). Style.

[mhalk]

openmp/libomptarget/src/OmptCallback.cpp

100

We wanted to get rid of these statics in openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp
Nevertheless good catch, since those were accidentally re-introduced by a rebase.

AFAIK:
We wanted to keep these here, to make sure the libomp->libomptarget connection stays alive (esp. w.r.t. the result).
But the libomptarget->plugin ones should not be static, since we can have multiple plugins.

[mhalk]

@jdoerfert *ping*

[mhalk]

If there are further requests / improvements I should implement, please let me know.
Otherwise, I'd like to move on with this patch.

Thank you!

[mhalk]

Rebase
Add multiple plugin finalization
Fix cmake not disabling libomptarget OMPT support, when libomp's OMPT support was disabled in the first place

[jplehr]

I know you did quite a bit of testing, so I assume this works. Just the one nit.
LGTM

openmp/libomptarget/src/OmptCallback.cpp

82

Should we assert here that LibraryFinalizer is actually nullptr, so we would catch any changes in assumptions about how often something is called early?

[mhalk]

Thank you @jplehr, that is much appreciated.

openmp/libomptarget/src/OmptCallback.cpp

82

Yes, I'll add an assert here -- making sure LibraryFinalizer == nullptr before creating the object.

[mhalk]

Added assert w.r.t. LibraryFinalizer == nullptr

[mhalk]

@jdoerfert @dreachem *ping*

In case you have any further feedback.

[dhruvachak]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

477

Is there a reason you need to pass in the GenericPluginTy here? I don't see it getting used.

538–541

Yes, that is the guideline. /* Name=*/Value
See https://llvm.org/docs/CodingStandards.html#commenting

openmp/runtime/src/ompt-general.cpp

883

This looks unrelated. Can you verify whether we really need this for this patch?

[mhalk]

Thanks @dhruvachak I'll rebase (esp. w.r.t. the deletion of the legacy plugins), then check the upcoming changes and if I don't see problems: submit here.

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

477

Very good catch, this *was* needed initally, when the init and fini was done within the generic plugin.
But this change is not necessary anymore as the patch has undergone a lot of changes since then.

openmp/runtime/src/ompt-general.cpp

883

Yes, we actually use this in this patch, to provide access to a "callback function lookup by code" (rather than name):
ompt_get_callback_t lookupCallbackByCode
It will be used to bind the actual OMPT callback functions to their declarations.

My idea was: This should provide a lookup with less overhead, than by name (comparing integers vs. strcmp, esp. since the function names are prefixed with ompt_callback_).

[mhalk]

Rebase + reverted signature change of GenericDeviceTy::deinit()

[dhruvachak]

Looks good. Thanks for the changes.

openmp/libomptarget/CMakeLists.txt

 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)
 endif()
 if(LIBOMPTARGET_ENABLE_DEBUG)
   add_definitions(-DOMPTARGET_DEBUG)
 endif()
 
 # OMPT support for libomptarget
 # Follow host OMPT support and check if host support has been requested.
 # LIBOMP_HAVE_OMPT_SUPPORT indicates whether host OMPT support has been implemented.
 # LIBOMP_OMPT_SUPPORT indicates whether host OMPT support has been requested (default is ON).
 # LIBOMPTARGET_OMPT_SUPPORT indicates whether target OMPT support has been requested (default is ON).
 set(OMPT_TARGET_DEFAULT FALSE)
 if ((LIBOMP_HAVE_OMPT_SUPPORT) AND (LIBOMP_OMPT_SUPPORT) AND (NOT WIN32))
   set (OMPT_TARGET_DEFAULT TRUE)
 endif()
 set(LIBOMPTARGET_OMPT_SUPPORT ${OMPT_TARGET_DEFAULT} CACHE BOOL "OMPT-target-support?")
 if ((OMPT_TARGET_DEFAULT) AND (LIBOMPTARGET_OMPT_SUPPORT))
   add_definitions(-DOMPT_SUPPORT=1)
   message(STATUS "OMPT target enabled")
 else()
+  set(LIBOMPTARGET_OMPT_SUPPORT FALSE)
   message(STATUS "OMPT target disabled")
 endif()
 
 pythonize_bool(LIBOMPTARGET_OMPT_SUPPORT)
 
 # Check if this build supports the GPU libc.
 set(LIBC_GPU_SUPPORT FALSE)
 if("libc" IN_LIST LLVM_ENABLE_RUNTIMES AND (LIBC_GPU_BUILD OR

openmp/libomptarget/include/OmptCallback.h

+//===---- OmptCallback.h - Target independent OMPT callbacks --*- C++ -*---===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Interface used by target-independent runtimes to coordinate registration and
+// invocation of OMPT callbacks and initialization / finalization.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _OMPTCALLBACK_H
+#define _OMPTCALLBACK_H
+
+#ifdef OMPT_SUPPORT
+
+#include "omp-tools.h"
+
+#define DEBUG_PREFIX "OMPT"
+
+#define FOREACH_OMPT_TARGET_CALLBACK(macro)                                    \
+  FOREACH_OMPT_DEVICE_EVENT(macro)                                             \
+  FOREACH_OMPT_NOEMI_EVENT(macro)                                              \
+  FOREACH_OMPT_EMI_EVENT(macro)
+
+#define performOmptCallback(CallbackName, ...)                                 \
+  do {                                                                         \
+    if (ompt_callback_##CallbackName##_fn)                                     \
+      ompt_callback_##CallbackName##_fn(__VA_ARGS__);                          \
+  } while (0)
+
+namespace llvm {
+namespace omp {
+namespace target {
+namespace ompt {
+
+#define declareOmptCallback(Name, Type, Code) extern Name##_t Name##_fn;
+FOREACH_OMPT_NOEMI_EVENT(declareOmptCallback)
+FOREACH_OMPT_EMI_EVENT(declareOmptCallback)
+#undef declareOmptCallback
+
+/// This function will call an OpenMP API function. Which in turn will lookup a
+/// given enum value of type \p ompt_callbacks_t and copy the address of the
+/// corresponding callback funtion into the provided pointer.
+/// The pointer to the runtime function is passed during 'initializeLibrary'.
+/// \p which the enum value of the requested callback function
+/// \p callback the destination pointer where the address shall be copied
+extern ompt_get_callback_t lookupCallbackByCode;
+
+/// Lookup function to be used by the lower layer (e.g. the plugin). This
+/// function has to be provided when actually calling callback functions like
+/// 'ompt_callback_device_initialize_fn' (param: 'lookup').
+/// The pointer to the runtime function is passed during 'initializeLibrary'.
+/// \p InterfaceFunctionName the name of the OMPT callback function to look up
+extern ompt_function_lookup_t lookupCallbackByName;
+
+/// This is the function called by the higher layer (libomp / libomtarget)
+/// responsible for initializing OMPT in this library. This is passed to libomp
+/// as part of the OMPT connector object.
+/// \p lookup to be used to query callbacks registered with libomp
+/// \p initial_device_num initial device num (id) provided by libomp
+/// \p tool_data as provided by the tool
+int initializeLibrary(ompt_function_lookup_t lookup, int initial_device_num,
+                      ompt_data_t *tool_data);
+
+/// This function is passed to libomp / libomtarget as part of the OMPT
+/// connector object. It is called by libomp during finalization of OMPT in
+/// libomptarget -OR- by libomptarget during finalization of OMPT in the plugin.
+/// \p tool_data as provided by the tool
+void finalizeLibrary(ompt_data_t *tool_data);
+
+/// This function will connect the \p initializeLibrary and \p finalizeLibrary
+/// functions to their respective higher layer.
+void connectLibrary();
+
+} // namespace ompt
+} // namespace target
+} // namespace omp
+} // namespace llvm
+
+#endif // OMPT_SUPPORT
+
+#endif // _OMPTCALLBACK_H

openmp/libomptarget/include/OmptConnector.h

-//=== ompt_connector.h - Target independent OpenMP target RTL -- C++ ------===//
+//===- OmptConnector.h - Target independent OpenMP target RTL -- C++ ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Support used by OMPT implementation to establish communication between
 // various OpenMP runtime libraries: host openmp library, target-independent
 // runtime library, and device-dependent runtime libraries.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _OMPT_CONNECTOR_H
-#define _OMPT_CONNECTOR_H
+#ifndef _OMPTCONNECTOR_H
+#define _OMPTCONNECTOR_H
 
 #ifdef OMPT_SUPPORT
 
 #include "llvm/Support/DynamicLibrary.h"
 
 #include <memory>
 #include <string>
 
private:
 
   /// Ensure initialization occurs only once
   bool IsInitialized;
   /// Handle of connect routine provided by source library
   OmptConnectRtnTy LibConnHandle;
   /// Name of connect routine provided by source library
   std::string LibIdent;
 };
 
-#undef DEBUG_PREFIX
-
 #endif // OMPT_SUPPORT
 
-#endif // _OMPT_CONNECTOR_H
+#endif // _OMPTCONNECTOR_H

openmp/libomptarget/include/ompt_device_callbacks.h

-//===--------- ompt_device_callbacks.h - OMPT callbacks -- C++ ----------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Interface used by both target-independent and device-dependent runtimes
-// to coordinate registration and invocation of OMPT callbacks
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _OMPT_DEVICE_CALLBACKS_H
-#define _OMPT_DEVICE_CALLBACKS_H
-
-#ifdef OMPT_SUPPORT
-
-#include "Debug.h"
-#include <omp-tools.h>
-
-#define DEBUG_PREFIX "OMPT"
-
-#define FOREACH_OMPT_TARGET_CALLBACK(macro)                                    \
-  FOREACH_OMPT_DEVICE_EVENT(macro)                                             \
-  FOREACH_OMPT_NOEMI_EVENT(macro)                                              \
-  FOREACH_OMPT_EMI_EVENT(macro)
-
-/// Internal representation for OMPT device callback functions.
-class OmptDeviceCallbacksTy {
-public:
-  /// Initialize the enabled flag and all the callbacks
-  void init() {
-    Enabled = false;
-#define initName(Name, Type, Code) Name##_fn = 0;
-    FOREACH_OMPT_TARGET_CALLBACK(initName)
-#undef initName
-  }
-
-  /// Used to register callbacks. \p Lookup is used to query a given callback
-  /// by name and the result is assigned to the corresponding callback function.
-  void registerCallbacks(ompt_function_lookup_t Lookup) {
-    Enabled = true;
-#define OmptBindCallback(Name, Type, Code)                                     \
-  Name##_fn = (Name##_t)Lookup(#Name);                                         \
-  DP("OMPT: class bound %s=%p\n", #Name, ((void *)(uint64_t)Name##_fn));
-
-    FOREACH_OMPT_TARGET_CALLBACK(OmptBindCallback);
-#undef OmptBindCallback
-  }
-
-  /// Used to find a callback given its name
-  ompt_interface_fn_t lookupCallback(const char *InterfaceFunctionName) {
-#define OmptLookup(Name, Type, Code)                                           \
-  if (strcmp(InterfaceFunctionName, #Name) == 0)                               \
-    return (ompt_interface_fn_t)Name##_fn;
-
-    FOREACH_OMPT_TARGET_CALLBACK(OmptLookup);
-#undef OmptLookup
-    return (ompt_interface_fn_t) nullptr;
-  }
-
-  /// Wrapper function to find a callback given its name
-  static ompt_interface_fn_t doLookup(const char *InterfaceFunctionName);
-
-private:
-  /// Set to true if callbacks for this library have been initialized
-  bool Enabled;
-
-  /// Callback functions
-#define DeclareName(Name, Type, Code) Name##_t Name##_fn;
-  FOREACH_OMPT_TARGET_CALLBACK(DeclareName)
-#undef DeclareName
-};
-
-/// Device callbacks object for the library that performs the instantiation
-extern OmptDeviceCallbacksTy OmptDeviceCallbacks;
-
-#endif // OMPT_SUPPORT
-
-#endif // _OMPT_DEVICE_CALLBACKS_H

openmp/libomptarget/plugins-nextgen/amdgpu/src/rtl.cpp

 #include <string>
 #include <system_error>
 #include <unistd.h>
 #include <unordered_map>
 
 #include "Debug.h"
 #include "DeviceEnvironment.h"
 #include "GlobalHandler.h"
+#include "OmptCallback.h"
 #include "PluginInterface.h"
 #include "Utilities.h"
 #include "UtilitiesRTL.h"
 #include "omptarget.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
if (Status != HSA_STATUS_SUCCESS) {
       DP("Failed to initialize AMDGPU's HSA library\n");
       return 0;
     }
 
     // The initialization of HSA was successful. It should be safe to call
     // HSA functions from now on, e.g., hsa_shut_down.
     Initialized = true;
 
+#ifdef OMPT_SUPPORT
+    ompt::connectLibrary();
+#endif
+
     // Register event handler to detect memory errors on the devices.
     Status = hsa_amd_register_system_event_handler(eventHandler, nullptr);
     if (auto Err = Plugin::check(
             Status, "Error in hsa_amd_register_system_event_handler: %s"))
       return std::move(Err);
 
     // List of host (CPU) agents.
     llvm::SmallVector<hsa_agent_t> HostAgents;

openmp/libomptarget/plugins-nextgen/common/OMPT/OmptCallback.cpp

 //===---------- OmptCallback.cpp - Generic OMPT callbacks --------- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // OMPT support for PluginInterface
 //
 //===----------------------------------------------------------------------===//
 
 #ifdef OMPT_SUPPORT
-#include <atomic>
-#include <cstdio>
-#include <string.h>
-#include <vector>
 
-#include "Debug.h"
-#include "ompt_connector.h"
-#include "ompt_device_callbacks.h"
+#include "llvm/Support/DynamicLibrary.h"
 
-/// Object maintaining all the callbacks in the plugin
-OmptDeviceCallbacksTy OmptDeviceCallbacks;
+#include <cstdlib>
+#include <cstring>
+#include <memory>
 
-/// Lookup function used for querying callback functions maintained
-/// by the plugin
-ompt_interface_fn_t
-OmptDeviceCallbacksTy::doLookup(const char *InterfaceFunctionName) {
-  // TODO This will be populated with device tracing functions
-  return (ompt_interface_fn_t) nullptr;
-}
+#include "Debug.h"
+#include "OmptCallback.h"
+#include "OmptConnector.h"
 
-/// Used to indicate whether OMPT was enabled for this library
-static bool OmptEnabled = false;
+using namespace llvm::omp::target::ompt;
 
-/// This function is passed to libomptarget as part of the OMPT connector
-/// object. It is called by libomptarget during initialization of OMPT in the
-/// plugin. \p lookup to be used to query callbacks registered with libomptarget
-/// \p initial_device_num Initial device num provided by libomptarget
-/// \p tool_data as provided by the tool
-static int OmptDeviceInit(ompt_function_lookup_t lookup, int initial_device_num,
+ompt_get_callback_t llvm::omp::target::ompt::lookupCallbackByCode = nullptr;
+ompt_function_lookup_t llvm::omp::target::ompt::lookupCallbackByName = nullptr;
+
+int llvm::omp::target::ompt::initializeLibrary(ompt_function_lookup_t lookup,
+                                               int initial_device_num,
                                                ompt_data_t *tool_data) {
-  DP("OMPT: Enter OmptDeviceInit\n");
-  OmptEnabled = true;
-  // The lookup parameter is provided by libomptarget which already has the tool
-  // callbacks registered at this point. The registration call below causes the
-  // same callback functions to be registered in the plugin as well.
-  OmptDeviceCallbacks.registerCallbacks(lookup);
-  DP("OMPT: Exit OmptDeviceInit\n");
+  DP("OMPT: Executing initializeLibrary (libomptarget)\n");
+#define bindOmptFunctionName(OmptFunction, DestinationFunction)                \
+  if (lookup)                                                                  \
+    DestinationFunction = (OmptFunction##_t)lookup(#OmptFunction);             \
+  DP("OMPT: initializeLibrary (libomptarget) bound %s=%p\n",                   \
+     #DestinationFunction, ((void *)(uint64_t)DestinationFunction));
+
+  bindOmptFunctionName(ompt_get_callback, lookupCallbackByCode);
+#undef bindOmptFunctionName
+
+  // Store pointer of 'ompt_libomp_target_fn_lookup' for use by the plugin
+  lookupCallbackByName = lookup;
+
   return 0;
 }
 
-/// This function is passed to libomptarget as part of the OMPT connector
-/// object. It is called by libomptarget during finalization of OMPT in the
-/// plugin.
-static void OmptDeviceFini(ompt_data_t *tool_data) {
-  DP("OMPT: Executing OmptDeviceFini\n");
+void llvm::omp::target::ompt::finalizeLibrary(ompt_data_t *tool_data) {
+  DP("OMPT: Executing finalizeLibrary (libomptarget)\n");
 }
 
-/// Used to initialize callbacks implemented by the tool. This interface will
-/// lookup the callbacks table in libomptarget and assign them to the callbacks
-/// table maintained in the calling plugin library.
-void OmptCallbackInit() {
-  DP("OMPT: Entering OmptCallbackInit\n");
+void llvm::omp::target::ompt::connectLibrary() {
+  DP("OMPT: Entering connectLibrary (libomptarget)\n");
   /// Connect plugin instance with libomptarget
   OmptLibraryConnectorTy LibomptargetConnector("libomptarget");
   ompt_start_tool_result_t OmptResult;
 
   // Initialize OmptResult with the init and fini functions that will be
   // called by the connector
-  OmptResult.initialize = OmptDeviceInit;
-  OmptResult.finalize = OmptDeviceFini;
+  OmptResult.initialize = ompt::initializeLibrary;
+  OmptResult.finalize = ompt::finalizeLibrary;
   OmptResult.tool_data.value = 0;
 
-  // Initialize the device callbacks first
-  OmptDeviceCallbacks.init();
-
   // Now call connect that causes the above init/fini functions to be called
   LibomptargetConnector.connect(&OmptResult);
-  DP("OMPT: Exiting OmptCallbackInit\n");
+  DP("OMPT: Exiting connectLibrary (libomptarget)\n");
 }
+
 #endif

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

 
 #include "Debug.h"
 #include "DeviceEnvironment.h"
 #include "GlobalHandler.h"
 #include "JIT.h"
 #include "MemoryManager.h"
 #include "RPC.h"
 #include "Utilities.h"
 #include "omptarget.h"
 
+#ifdef OMPT_SUPPORT
+#include "omp-tools.h"
+#endif
+
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include "llvm/Frontend/OpenMP/OMPGridValues.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/raw_ostream.h"
protected:
   /// the device I can access device J's memory directly. However, notice this
   /// does not mean that device J can access device I's memory directly.
   llvm::SmallVector<PeerAccessState> PeerAccesses;
   std::mutex PeerAccessesLock;
 
   /// Map of host pinned allocations used for optimize device transfers.
   PinnedAllocationMapTy PinnedAllocs;
 
   /// A pointer to an RPC server instance attached to this device if present.
   /// This is used to run the RPC server during task synchronization.
   RPCHandleTy *RPCHandle;
+
+#ifdef OMPT_SUPPORT
+  /// OMPT callback functions
+#define defineOmptCallback(Name, Type, Code) Name##_t Name##_fn = nullptr;
+  FOREACH_OMPT_DEVICE_EVENT(defineOmptCallback)
+#undef defineOmptCallback
+
+  /// Internal representation for OMPT device (initialize & finalize)
+  std::atomic<bool> OmptInitialized;
+#endif
 };
 
 /// Class implementing common functionalities of offload plugins. Each plugin
 /// should define the specific plugin class, derive from this generic one, and
 /// implement the necessary virtual function members.
 struct GenericPluginTy {
 
   /// Construct a plugin instance.

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

 #include "PluginInterface.h"
 #include "Debug.h"
 #include "GlobalHandler.h"
 #include "JIT.h"
 #include "elf_common.h"
 #include "omptarget.h"
 #include "omptargetplugin.h"
 
+#ifdef OMPT_SUPPORT
+#include "OmptCallback.h"
+#include "omp-tools.h"
+#endif
+
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <cstdint>
 #include <limits>
: MemoryManager(nullptr), OMP_TeamLimit("OMP_TEAM_LIMIT"),
       // device initialization. These cannot be consulted until the device is
       // initialized correctly. We intialize them in GenericDeviceTy::init().
       OMPX_TargetStackSize(), OMPX_TargetHeapSize(),
       // By default, the initial number of streams and events are 32.
       OMPX_InitialNumStreams("LIBOMPTARGET_NUM_INITIAL_STREAMS", 32),
       OMPX_InitialNumEvents("LIBOMPTARGET_NUM_INITIAL_EVENTS", 32),
       DeviceId(DeviceId), GridValues(OMPGridValues),
       PeerAccesses(NumDevices, PeerAccessState::PENDING), PeerAccessesLock(),
-      PinnedAllocs(*this), RPCHandle(nullptr) {}
+      PinnedAllocs(*this), RPCHandle(nullptr) {
+#ifdef OMPT_SUPPORT
+  OmptInitialized.store(false);
+  // Bind the callbacks to this device's member functions
+#define bindOmptCallback(Name, Type, Code)                                     \
+  if (ompt::lookupCallbackByCode)                                              \
+    ompt::lookupCallbackByCode((ompt_callbacks_t)(Code),                       \
+                               ((ompt_callback_t *)&(Name##_fn)));             \
+  DP("OMPT: class bound %s=%p\n", #Name, ((void *)(uint64_t)Name##_fn));
+
+  FOREACH_OMPT_DEVICE_EVENT(bindOmptCallback);
+#undef bindOmptCallback
+
+#endif
+}
 
 Error GenericDeviceTy::init(GenericPluginTy &Plugin) {
   if (auto Err = initImpl(Plugin))
     return Err;
 
+#ifdef OMPT_SUPPORT
+  bool ExpectedStatus = false;
+  if (OmptInitialized.compare_exchange_strong(ExpectedStatus, true))
+    performOmptCallback(device_initialize,
+                        /* device_num */ DeviceId,
+                        /* type */ getComputeUnitKind().c_str(),
+                        /* device */ reinterpret_cast<ompt_device_t *>(this),
+                        /* lookup */ ompt::lookupCallbackByName,
+                        /* documentation */ nullptr);
+#endif
+
   // Read and reinitialize the envars that depend on the device initialization.
   // Notice these two envars may change the stack size and heap size of the
   // device, so they need the device properly initialized.
   auto StackSizeEnvarOrErr = UInt64Envar::create(
       "LIBOMPTARGET_STACK_SIZE",
       [this](uint64_t &V) -> Error { return getDeviceStackSize(V); },
       [this](uint64_t V) -> Error { return setDeviceStackSize(V); });
   if (!StackSizeEnvarOrErr)
#endif
   if (RecordReplay.isRecordingOrReplaying())
     if (auto Err = RecordReplay.init(this))
       return Err;
 
   return Plugin::success();
 }
 
 Error GenericDeviceTy::deinit() {
-  // Delete the memory manager before deinitilizing the device. Otherwise,
+  // Delete the memory manager before deinitializing the device. Otherwise,
   // we may delete device allocations after the device is deinitialized.
   if (MemoryManager)
     delete MemoryManager;
   MemoryManager = nullptr;
 
   if (RecordReplay.isRecordingOrReplaying())
     RecordReplay.deinit();
 
   if (RPCHandle)
     if (auto Err = RPCHandle->deinitDevice())
       return Err;
 
+#ifdef OMPT_SUPPORT
+  bool ExpectedStatus = true;
+  if (OmptInitialized.compare_exchange_strong(ExpectedStatus, false))
+    performOmptCallback(device_finalize, /* device_num */ DeviceId);
+#endif
+
   return deinitImpl();
 }
-
 Expected<__tgt_target_table *>
 GenericDeviceTy::loadBinary(GenericPluginTy &Plugin,
                             const __tgt_device_image *InputTgtImage) {
   assert(InputTgtImage && "Expected non-null target image");
   DP("Load data from image " DPxMOD "\n", DPxPTR(InputTgtImage->ImageStart));
 
   auto PostJITImageOrErr = Plugin.getJIT().process(*InputTgtImage, *this);
   if (!PostJITImageOrErr) {
GenericDeviceTy::loadBinary(GenericPluginTy &Plugin,
 
   // Register all offload entries of the image.
   if (auto Err = registerOffloadEntries(*Image))
     return std::move(Err);
 
   if (auto Err = setupRPCServer(Plugin, *Image))
     return std::move(Err);
 
+#ifdef OMPT_SUPPORT
+  size_t Bytes = getPtrDiff(InputTgtImage->ImageEnd, InputTgtImage->ImageStart);
+  performOmptCallback(device_load,
+                      /* device_num */ DeviceId,
+                      /* FileName */ nullptr,
+                      /* File Offset */ 0,
+                      /* VmaInFile */ nullptr,
+                      /* ImgSize */ Bytes,
+                      /* HostAddr */ InputTgtImage->ImageStart,
+                      /* DeviceAddr */ nullptr,
+                      /* FIXME: ModuleId */ 0);
+#endif
+
   // Return the pointer to the table of entries.
   return Image->getOffloadEntryTable();
 }
 
 Error GenericDeviceTy::setupDeviceEnvironment(GenericPluginTy &Plugin,
                                               DeviceImageTy &Image) {
   // There are some plugins that do not need this step.
   if (!shouldSetupDeviceEnvironment())

 }
 
 Error GenericPluginTy::init() {
   auto NumDevicesOrErr = initImpl();
   if (!NumDevicesOrErr)
     return NumDevicesOrErr.takeError();
 
   NumDevices = *NumDevicesOrErr;
   if (NumDevices == 0)
     return Plugin::success();
 
   assert(Devices.size() == 0 && "Plugin already initialized");
   Devices.resize(NumDevices, nullptr);
 
   GlobalHandler = Plugin::createGlobalHandler();
   assert(GlobalHandler && "Invalid global handler");
 

openmp/libomptarget/plugins-nextgen/cuda/src/rtl.cpp

 #include <cstddef>
 #include <cuda.h>
 #include <string>
 #include <unordered_map>
 
 #include "Debug.h"
 #include "DeviceEnvironment.h"
 #include "GlobalHandler.h"
+#include "OmptCallback.h"
 #include "PluginInterface.h"
 
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include "llvm/Frontend/OpenMP/OMPGridValues.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
struct CUDAPluginTy final : public GenericPluginTy {
   Expected<int32_t> initImpl() override {
     CUresult Res = cuInit(0);
     if (Res == CUDA_ERROR_INVALID_HANDLE) {
       // Cannot call cuGetErrorString if dlsym failed.
       DP("Failed to load CUDA shared library\n");
       return 0;
     }
 
+#ifdef OMPT_SUPPORT
+    ompt::connectLibrary();
+#endif
+
     if (Res == CUDA_ERROR_NO_DEVICE) {
       // Do not initialize if there are no devices.
       DP("There are no devices supporting CUDA.\n");
       return 0;
     }
 
     if (auto Err = Plugin::check(Res, "Error in cuInit: %s"))
       return std::move(Err);

openmp/libomptarget/src/OmptCallback.cpp

 //===-- OmptCallback.cpp - Target independent OpenMP target RTL --- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of OMPT callback interfaces for target independent layer
 //
 //===----------------------------------------------------------------------===//
 
 #ifdef OMPT_SUPPORT
 
-#include <assert.h>
-#include <atomic>
+#include "llvm/Support/DynamicLibrary.h"
+
 #include <cstdlib>
 #include <cstring>
-
-#include "omp-tools.h"
+#include <memory>
 
 #include "Debug.h"
-#include "ompt_connector.h"
-#include "ompt_device_callbacks.h"
-#include "private.h"
-
-#define fnptr_to_ptr(x) ((void *)(uint64_t)x)
-
-/// Used to indicate whether OMPT was enabled for this library
-bool OmptEnabled = false;
-/// Object maintaining all the callbacks for this library
-OmptDeviceCallbacksTy OmptDeviceCallbacks;
+#include "OmptCallback.h"
+#include "OmptConnector.h"
 
-/// Used to maintain the finalization function that is received
-/// from the plugin during connect
+using namespace llvm::omp::target::ompt;
+
+// Define OMPT callback functions (bound to actual callbacks later on)
+#define defineOmptCallback(Name, Type, Code)                                   \
+  Name##_t llvm::omp::target::ompt::Name##_fn = nullptr;
+FOREACH_OMPT_NOEMI_EVENT(defineOmptCallback)
+FOREACH_OMPT_EMI_EVENT(defineOmptCallback)
+#undef defineOmptCallback
+
+/// Used to maintain the finalization functions that are received
+/// from the plugins during connect.
+/// Note: Currently, there are no plugin-specific finalizations, so each plugin
+/// will call the same (empty) function.
 class LibomptargetRtlFinalizer {
 public:
-  LibomptargetRtlFinalizer() : RtlFinalization(nullptr) {}
+  LibomptargetRtlFinalizer() {}
+
   void registerRtl(ompt_finalize_t FinalizationFunction) {
-    assert((RtlFinalization == nullptr) &&
-           "RTL finalization may only be registered once");
-    RtlFinalization = FinalizationFunction;
+    if (FinalizationFunction) {
+      RtlFinalizationFunctions.emplace_back(FinalizationFunction);
     }
+  }
+
   void finalize() {
-    if (RtlFinalization)
-      RtlFinalization(nullptr /* tool_data */);
-    RtlFinalization = nullptr;
+    for (auto FinalizationFunction : RtlFinalizationFunctions)
+      FinalizationFunction(/* tool_data */ nullptr);
+    RtlFinalizationFunctions.clear();
   }
 
 private:
-  ompt_finalize_t RtlFinalization;
+  llvm::SmallVector<ompt_finalize_t> RtlFinalizationFunctions;
 };
 
 /// Object that will maintain the RTL finalizer from the plugin
-static LibomptargetRtlFinalizer LibraryFinalizer;
+LibomptargetRtlFinalizer *LibraryFinalizer = nullptr;
 
-/// Lookup function to be used by libomptarget library
-ompt_interface_fn_t
-OmptDeviceCallbacksTy::doLookup(const char *InterfaceFunctionName) {
-  return OmptDeviceCallbacks.lookupCallback(InterfaceFunctionName);
-}
+ompt_get_callback_t llvm::omp::target::ompt::lookupCallbackByCode = nullptr;
+ompt_function_lookup_t llvm::omp::target::ompt::lookupCallbackByName = nullptr;
 
-/// This is the function called by the higher layer (libomp) responsible
-/// for initializing OMPT in this library. This is passed to libomp
-/// as part of the OMPT connector object.
-/// \p lookup to be used to query callbacks registered with libomp
-/// \p initial_device_num Initial device num provided by libomp
-/// \p tool_data as provided by the tool
-static int ompt_libomptarget_initialize(ompt_function_lookup_t lookup,
+int llvm::omp::target::ompt::initializeLibrary(ompt_function_lookup_t lookup,
                                                int initial_device_num,
                                                ompt_data_t *tool_data) {
-  DP("enter ompt_libomptarget_initialize!\n");
-  OmptEnabled = true;
-  // The lookup parameter is provided by libomp which already has the
-  // tool callbacks registered at this point. The registration call
-  // below causes the same callback functions to be registered in
-  // libomptarget as well
-  OmptDeviceCallbacks.registerCallbacks(lookup);
-  DP("exit ompt_libomptarget_initialize!\n");
+  DP("OMPT: Executing initializeLibrary (libomp)\n");
+#define bindOmptFunctionName(OmptFunction, DestinationFunction)                \
+  DestinationFunction = (OmptFunction##_t)lookup(#OmptFunction);               \
+  DP("OMPT: initializeLibrary (libomp) bound %s=%p\n", #DestinationFunction,   \
+     ((void *)(uint64_t)DestinationFunction));
+
+  bindOmptFunctionName(ompt_get_callback, lookupCallbackByCode);
+#undef bindOmptFunctionName
+
+  // Store pointer of 'ompt_libomp_target_fn_lookup' for use by libomptarget
+  lookupCallbackByName = lookup;
+
+  assert(lookupCallbackByCode && "lookupCallbackByCode should be non-null");
+  assert(lookupCallbackByName && "lookupCallbackByName should be non-null");
+  assert(LibraryFinalizer == nullptr &&
+         "LibraryFinalizer should not be initialized yet");
+
+  LibraryFinalizer = new LibomptargetRtlFinalizer();
+
   return 0;
 }
 
-/// This function is passed to libomp as part of the OMPT connector object.
-/// It is called by libomp during finalization of OMPT in libomptarget.
-static void ompt_libomptarget_finalize(ompt_data_t *data) {
-  DP("enter ompt_libomptarget_finalize!\n");
-  // Before disabling OMPT, call the finalizer (of the plugin) that was
-  // registered with this library
-  LibraryFinalizer.finalize();
-  OmptEnabled = false;
-  DP("exit ompt_libomptarget_finalize!\n");
-}
-
-/*****************************************************************************
- * constructor
- *****************************************************************************/
-/// Used to initialize callbacks implemented by the tool. This interface
-/// will lookup the callbacks table in libomp and assign them to the callbacks
-/// maintained in libomptarget.
-void InitOmptLibomp() {
-  DP("OMPT: Enter InitOmptLibomp\n");
+void llvm::omp::target::ompt::finalizeLibrary(ompt_data_t *data) {
+  DP("OMPT: Executing finalizeLibrary (libomp)\n");
+  // Before disabling OMPT, call the (plugin) finalizations that were registered
+  // with this library
+  LibraryFinalizer->finalize();
+  delete LibraryFinalizer;
+}
+
+void llvm::omp::target::ompt::connectLibrary() {
+  DP("OMPT: Entering connectLibrary (libomp)\n");
   // Connect with libomp
   static OmptLibraryConnectorTy LibompConnector("libomp");
   static ompt_start_tool_result_t OmptResult;
 
   // Initialize OmptResult with the init and fini functions that will be
   // called by the connector
-  OmptResult.initialize = ompt_libomptarget_initialize;
-  OmptResult.finalize = ompt_libomptarget_finalize;
+  OmptResult.initialize = ompt::initializeLibrary;
+  OmptResult.finalize = ompt::finalizeLibrary;
   OmptResult.tool_data.value = 0;
 
-  // Initialize the device callbacks first
-  OmptDeviceCallbacks.init();
-
   // Now call connect that causes the above init/fini functions to be called
   LibompConnector.connect(&OmptResult);
-  DP("OMPT: Exit InitOmptLibomp\n");
+
+#define bindOmptCallback(Name, Type, Code)                                     \
+  if (lookupCallbackByCode)                                                    \
+    lookupCallbackByCode(                                                      \
+        (ompt_callbacks_t)(Code),                                              \
+        (ompt_callback_t *)&(llvm::omp::target::ompt::Name##_fn));
+  FOREACH_OMPT_NOEMI_EVENT(bindOmptCallback)
+  FOREACH_OMPT_EMI_EVENT(bindOmptCallback)
+#undef bindOmptCallback
+
+  DP("OMPT: Exiting connectLibrary (libomp)\n");
 }
 
 extern "C" {
 /// Used for connecting libomptarget with a plugin
 void ompt_libomptarget_connect(ompt_start_tool_result_t *result) {
   DP("OMPT: Enter ompt_libomptarget_connect\n");
-  if (OmptEnabled && result) {
-    // Cache the fini function so that it can be invoked on exit
-    LibraryFinalizer.registerRtl(result->finalize);
+  if (result && LibraryFinalizer) {
+    // Cache each fini function, so that they can be invoked on exit
+    LibraryFinalizer->registerRtl(result->finalize);
     // Invoke the provided init function with the lookup function maintained
     // in this library so that callbacks maintained by this library are
     // retrieved.
-    result->initialize(OmptDeviceCallbacksTy::doLookup,
-                       0 /* initial_device_num */, nullptr /* tool_data */);
+    result->initialize(lookupCallbackByName,
+                       /* initial_device_num */ 0, /* tool_data */ nullptr);
   }
   DP("OMPT: Leave ompt_libomptarget_connect\n");
 }
 }
 #else
 extern "C" {
 /// Dummy definition when OMPT is disabled
 void ompt_libomptarget_connect() {}
 }
 #endif // OMPT_SUPPORT

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 "llvm/Object/OffloadBinary.h"
 
+#include "OmptCallback.h"
 #include "device.h"
 #include "private.h"
 #include "rtl.h"
 
 #include "Utilities.h"
 
 #include <cassert>
 #include <cstdlib>
static const char *RTLNames[] = {
     /* AMDGPU target        */ "libomptarget.rtl.amdgpu",
 };
 
 PluginManager *PM;
 
 static char *ProfileTraceFile = nullptr;
 
 #ifdef OMPT_SUPPORT
-extern void InitOmptLibomp();
+extern void ompt::connectLibrary();
 #endif
 
 __attribute__((constructor(101))) void init() {
   DP("Init target library!\n");
 
   bool UseEventsForAtomicTransfers = true;
   if (const char *ForceAtomicMap = getenv("LIBOMPTARGET_MAP_FORCE_ATOMIC")) {
     std::string ForceAtomicMapStr(ForceAtomicMap);
     if (ForceAtomicMapStr == "false" || ForceAtomicMapStr == "FALSE")
       UseEventsForAtomicTransfers = false;
     else if (ForceAtomicMapStr != "true" && ForceAtomicMapStr != "TRUE")
       fprintf(stderr,
               "Warning: 'LIBOMPTARGET_MAP_FORCE_ATOMIC' accepts only "
               "'true'/'TRUE' or 'false'/'FALSE' as options, '%s' ignored\n",
               ForceAtomicMap);
   }
 
   PM = new PluginManager(UseEventsForAtomicTransfers);
 
   ProfileTraceFile = getenv("LIBOMPTARGET_PROFILE");
   // TODO: add a configuration option for time granularity
   if (ProfileTraceFile)
     timeTraceProfilerInitialize(500 /* us */, "libomptarget");
 
-  #ifdef OMPT_SUPPORT
-    // Initialize OMPT first
-    InitOmptLibomp();
-  #endif
+  ompt::connectLibrary();
 
   PM->RTLs.loadRTLs();
   PM->registerDelayedLibraries();
 }
 
 __attribute__((destructor(101))) void deinit() {
   DP("Deinit target library!\n");
   delete PM;

openmp/libomptarget/test/ompt/veccopy.c

 // RUN: %libomptarget-compile-run-and-check-generic
 // REQUIRES: ompt
-// UNSUPPORTED: nvptx64-nvidia-cuda
-// UNSUPPORTED: nvptx64-nvidia-cuda-oldDriver
-// UNSUPPORTED: nvptx64-nvidia-cuda-LTO
 // UNSUPPORTED: x86_64-pc-linux-gnu
 // UNSUPPORTED: x86_64-pc-linux-gnu-oldDriver
 // UNSUPPORTED: x86_64-pc-linux-gnu-LTO
 
 /*
  * Example OpenMP program that registers non-EMI callbacks
  */
 
for (i = 0; i < N; i++)
     }
 
   if (!rc)
     printf("Success\n");
 
   return rc;
 }
 
-/// CHECK: Could not register callback 'ompt_callback_device_initialize'
-/// CHECK: Could not register callback 'ompt_callback_device_finalize'
-/// CHECK: Could not register callback 'ompt_callback_device_load'
 /// CHECK: Could not register callback 'ompt_callback_target_data_op'
 /// CHECK: Could not register callback 'ompt_callback_target'
 /// CHECK: Could not register callback 'ompt_callback_target_submit'
 
-/// CHECK: Success
+/// CHECK: Callback Init:
+/// CHECK: Callback Load:
+/// CHECK: Callback Fini:

openmp/libomptarget/test/ompt/veccopy_disallow_both.c

 // RUN: %libomptarget-compile-run-and-check-generic
 // REQUIRES: ompt
-// UNSUPPORTED: nvptx64-nvidia-cuda
-// UNSUPPORTED: nvptx64-nvidia-cuda-oldDriver
-// UNSUPPORTED: nvptx64-nvidia-cuda-LTO
 // UNSUPPORTED: x86_64-pc-linux-gnu
 // UNSUPPORTED: x86_64-pc-linux-gnu-oldDriver
 // UNSUPPORTED: x86_64-pc-linux-gnu-LTO
 
 /*
  * Example OpenMP program that shows that both EMI and non-EMI
  * callbacks cannot be registered for the same type. In the
  * current implementation, the EMI callback overrides the non-EMI
for (i = 0; i < N; i++)
     }
 
   if (!rc)
     printf("Success\n");
 
   return rc;
 }
 
-/// CHECK: Could not register callback 'ompt_callback_device_initialize'
-/// CHECK: Could not register callback 'ompt_callback_device_finalize'
-/// CHECK: Could not register callback 'ompt_callback_device_load'
 /// CHECK: Could not register callback 'ompt_callback_target_data_op'
 /// CHECK: Could not register callback 'ompt_callback_target'
 /// CHECK: Could not register callback 'ompt_callback_target_submit'
 
-/// CHECK: Success
+/// CHECK: Callback Init:
+/// CHECK: Callback Load:
+/// CHECK: Callback Fini:

openmp/libomptarget/test/ompt/veccopy_emi.c

 // RUN: %libomptarget-compile-run-and-check-generic
 // REQUIRES: ompt
-// UNSUPPORTED: nvptx64-nvidia-cuda
-// UNSUPPORTED: nvptx64-nvidia-cuda-oldDriver
-// UNSUPPORTED: nvptx64-nvidia-cuda-LTO
 // UNSUPPORTED: x86_64-pc-linux-gnu
 // UNSUPPORTED: x86_64-pc-linux-gnu-oldDriver
 // UNSUPPORTED: x86_64-pc-linux-gnu-LTO
 
 /*
  * Example OpenMP program that registers EMI callbacks
  */
 
for (i = 0; i < N; i++)
     }
 
   if (!rc)
     printf("Success\n");
 
   return rc;
 }
 
-/// CHECK: Could not register callback 'ompt_callback_device_initialize'
-/// CHECK: Could not register callback 'ompt_callback_device_finalize'
-/// CHECK: Could not register callback 'ompt_callback_device_load'
 /// CHECK: Could not register callback 'ompt_callback_target_data_op_emi'
 /// CHECK: Could not register callback 'ompt_callback_target_emi'
 /// CHECK: Could not register callback 'ompt_callback_target_submit_emi'
 
-/// CHECK: Success
+/// CHECK: Callback Init:
+/// CHECK: Callback Load:
+/// CHECK: Callback Fini:

openmp/libomptarget/test/ompt/veccopy_emi_map.c

 // RUN: %libomptarget-compile-run-and-check-generic
 // REQUIRES: ompt
-// UNSUPPORTED: nvptx64-nvidia-cuda
-// UNSUPPORTED: nvptx64-nvidia-cuda-oldDriver
-// UNSUPPORTED: nvptx64-nvidia-cuda-LTO
 // UNSUPPORTED: x86_64-pc-linux-gnu
 // UNSUPPORTED: x86_64-pc-linux-gnu-oldDriver
 // UNSUPPORTED: x86_64-pc-linux-gnu-LTO
 
 /*
  * Example OpenMP program that shows that map-EMI callbacks are not supported.
  */
 
for (i = 0; i < N; i++)
     }
 
   if (!rc)
     printf("Success\n");
 
   return rc;
 }
 
-/// CHECK: Could not register callback 'ompt_callback_device_initialize'
-/// CHECK: Could not register callback 'ompt_callback_device_finalize'
-/// CHECK: Could not register callback 'ompt_callback_device_load'
 /// CHECK: Could not register callback 'ompt_callback_target_data_op_emi'
 /// CHECK: Could not register callback 'ompt_callback_target_emi'
 /// CHECK: Could not register callback 'ompt_callback_target_submit_emi'
 /// CHECK: Could not register callback 'ompt_callback_target_map_emi'
 
-/// CHECK: Success
+/// CHECK: Callback Init:
+/// CHECK: Callback Load:
+/// CHECK: Callback Fini:

openmp/libomptarget/test/ompt/veccopy_map.c

 // RUN: %libomptarget-compile-run-and-check-generic
 // REQUIRES: ompt
-// UNSUPPORTED: nvptx64-nvidia-cuda
-// UNSUPPORTED: nvptx64-nvidia-cuda-oldDriver
-// UNSUPPORTED: nvptx64-nvidia-cuda-LTO
 // UNSUPPORTED: x86_64-pc-linux-gnu
 // UNSUPPORTED: x86_64-pc-linux-gnu-oldDriver
 // UNSUPPORTED: x86_64-pc-linux-gnu-LTO
 
 /*
  * Example OpenMP program that shows that map callbacks are not supported.
  */
 
for (i = 0; i < N; i++)
     }
 
   if (!rc)
     printf("Success\n");
 
   return rc;
 }
 
-/// CHECK: Could not register callback 'ompt_callback_device_initialize'
-/// CHECK: Could not register callback 'ompt_callback_device_finalize'
-/// CHECK: Could not register callback 'ompt_callback_device_load'
 /// CHECK: Could not register callback 'ompt_callback_target_data_op'
 /// CHECK: Could not register callback 'ompt_callback_target'
 /// CHECK: Could not register callback 'ompt_callback_target_submit'
 
-/// CHECK: Success
+/// CHECK: Callback Init:
+/// CHECK: Callback Load:
+/// CHECK: Callback Fini:

openmp/libomptarget/test/ompt/veccopy_no_device_init.c

 // RUN: %libomptarget-compile-run-and-check-generic
 // REQUIRES: ompt
-// UNSUPPORTED: nvptx64-nvidia-cuda
-// UNSUPPORTED: nvptx64-nvidia-cuda-oldDriver
-// UNSUPPORTED: nvptx64-nvidia-cuda-LTO
 // UNSUPPORTED: x86_64-pc-linux-gnu
 // UNSUPPORTED: x86_64-pc-linux-gnu-oldDriver
 // UNSUPPORTED: x86_64-pc-linux-gnu-LTO
 
 /*
  * Example OpenMP program that shows that if no device init callback
  * is registered, the other callbacks won't be activated.
  */
for (i = 0; i < N; i++)
     }
 
   if (!rc)
     printf("Success\n");
 
   return rc;
 }
 
-/// CHECK: Could not register callback 'ompt_callback_device_load'
 /// CHECK: Could not register callback 'ompt_callback_target_data_op'
 /// CHECK: Could not register callback 'ompt_callback_target'
 /// CHECK: Could not register callback 'ompt_callback_target_submit'
 
-/// CHECK: Success
+/// CHECK-NOT: Callback Init:
+/// CHECK-NOT: Callback Load:
+/// CHECK-NOT: Callback Fini:

openmp/libomptarget/test/ompt/veccopy_wrong_return.c

 // RUN: %libomptarget-compile-run-and-check-generic
 // REQUIRES: ompt
-// UNSUPPORTED: nvptx64-nvidia-cuda
-// UNSUPPORTED: nvptx64-nvidia-cuda-oldDriver
-// UNSUPPORTED: nvptx64-nvidia-cuda-LTO
 // UNSUPPORTED: x86_64-pc-linux-gnu
 // UNSUPPORTED: x86_64-pc-linux-gnu-oldDriver
 // UNSUPPORTED: x86_64-pc-linux-gnu-LTO
 
 /*
  * Example OpenMP program that shows that if the initialize function
  * returns the wrong status code, the callbacks won't be activated.
  */
for (i = 0; i < N; i++)
     }
 
   if (!rc)
     printf("Success\n");
 
   return rc;
 }
 
-/// CHECK: Could not register callback 'ompt_callback_device_initialize'
-/// CHECK: Could not register callback 'ompt_callback_device_finalize'
-/// CHECK: Could not register callback 'ompt_callback_device_load'
 /// CHECK: Could not register callback 'ompt_callback_target_data_op'
 /// CHECK: Could not register callback 'ompt_callback_target'
 /// CHECK: Could not register callback 'ompt_callback_target_submit'
 
-/// CHECK: Success
+/// CHECK-NOT: Callback Init:
+/// CHECK-NOT: Callback Load:
+/// CHECK-NOT: Callback Fini:

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

 #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_initialize_implemented ompt_event_MAY_ALWAYS
+#define ompt_callback_device_finalize_implemented ompt_event_MAY_ALWAYS
 
-#define ompt_callback_device_load_implemented ompt_event_UNIMPLEMENTED
+#define ompt_callback_device_load_implemented ompt_event_MAY_ALWAYS
 #define ompt_callback_device_unload_implemented ompt_event_UNIMPLEMENTED
 
 /*----------------------------------------------------------------------------
  | Optional Events
  +--------------------------------------------------------------------------*/
 
 #define ompt_callback_sync_region_wait_implemented                             \
   ompt_event_MAY_ALWAYS_OPTIONAL

openmp/runtime/src/ompt-general.cpp

 
 #undef ompt_interface_fn
 
   return NULL;
 }
 
 /// Lookup function to query libomp callbacks registered by the tool
 static ompt_interface_fn_t ompt_libomp_target_fn_lookup(const char *s) {
+#define provide_fn(fn)                                                         \
+  if (strcmp(s, #fn) == 0)                                                     \
+    return (ompt_interface_fn_t)fn;
+
+  provide_fn(ompt_get_callback);
+#undef provide_fn
+
 #define ompt_interface_fn(fn, type, code)                                      \
   if (strcmp(s, #fn) == 0)                                                     \
     return (ompt_interface_fn_t)ompt_callbacks.ompt_callback(fn);
 
   FOREACH_OMPT_DEVICE_EVENT(ompt_interface_fn)
   FOREACH_OMPT_EMI_EVENT(ompt_interface_fn)
   FOREACH_OMPT_NOEMI_EVENT(ompt_interface_fn)
-
 #undef ompt_interface_fn
 
   return (ompt_interface_fn_t)0;
 }
 
 /// This function is called by the libomptarget connector to assign
 /// callbacks already registered with libomp.
 _OMP_EXTERN void ompt_libomp_connect(ompt_start_tool_result_t *result) {
-  OMPT_VERBOSE_INIT_PRINT("libomp --> OMPT: Enter libomp_ompt_connect\n");
+  OMPT_VERBOSE_INIT_PRINT("libomp --> OMPT: Enter ompt_libomp_connect\n");
 
   // Ensure libomp callbacks have been added if not already
   __ompt_force_initialization();
 
   if (ompt_enabled.enabled &&
       // Callbacks are initiated only if the device initialize callback
       // has been registered by the tool
       ompt_callbacks.ompt_callback(ompt_callback_device_initialize)) {
     if (result) {
       OMPT_VERBOSE_INIT_PRINT(
           "libomp --> OMPT: Connecting with libomptarget\n");
       // Pass in the libomp lookup function so that the already registered
       // functions can be extracted and assigned to the callbacks in
       // libomptarget
       result->initialize(ompt_libomp_target_fn_lookup,
-                         0 /* initial_device_num */, nullptr /* tool_data */);
+                         /* initial_device_num */ 0, /* tool_data */ nullptr);
       // Track the object provided by libomptarget so that the finalizer can be
       // called during OMPT finalization
       libomptarget_ompt_result = result;
     }
   }
-  OMPT_VERBOSE_INIT_PRINT("libomp --> OMPT: Exit libomp_ompt_connect\n");
+  OMPT_VERBOSE_INIT_PRINT("libomp --> OMPT: Exit ompt_libomp_connect\n");
 }