[openmp] Initialize OMPT in libomptarget

[lechenyu]

Summary

1. Add two files, ompt-target.h and ompt-target.cpp, for OMPT-related types, global variables and classes. For each target-related callbacks, there is an associated wrapper class. The wrapper class is used to store parameters for callbacks, and the actual OMPT callbacks are invoked in the constructor/destructor using the predefined interfaces in the runtime.
2. Initialize the bitmap and other global variables when initializing libomptarget (rtl.cpp).

[lechenyu]

Fix format issues

[lechenyu]

Fix format issues.

[jdoerfert]

Drive by

openmp/libomptarget/src/ompt-target.h

1

These files lack license headers. Can someone please add them.

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
 )
 
 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} ${LIBOMP_SRC_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})

openmp/libomptarget/src/ompt-target.h

 #ifndef LIBOMPTARGET_OMPT_TARGET_H
 #define LIBOMPTARGET_OMPT_TARGET_H
 
+#include "kmp_config.h"
+#if OMPT_SUPPORT
 #include "omp-tools.h"
+#define FROM_LIBOMPTARGET 1
+#include "ompt-target-api.h"
+#undef FROM_LIBOMPTARGET
+
+#define OMPT_GET_RETURN_ADDRESS(level) __builtin_return_address(level)
+
+#define OMPT_ARG(...) , __VA_ARGS__
+
+#define OMPT_FIRST_ARG(...) __VA_ARGS__
+
+extern ompt_target_callbacks_active_t OmptTargetEnabled;
+
+extern int HostDeviceNum;
+
+// TODO (lechenyu): Will move following classes into openmp runtime
+// TODO (lechenyu): Need to add additional parameters to initialize and clean
+// target_data for omp_target_* routines
+class OmptTargetDataOp {
+private:
+  ompt_target_data_op_t OpType;
+  void *SrcAddr;
+  int SrcDeviceNum;
+  void *DestAddr;
+  int DestDeviceNum;
+  size_t Bytes;
+  bool OmpRoutine;
+  void *CodePtr;
+  bool Active;
+
+public:
+  OmptTargetDataOp(ompt_target_data_op_t OpType, void *SrcAddr,
+                   int SrcDeviceNum, void *DestAddr, int DestDeviceNum,
+                   size_t Bytes, bool OmpRoutine, void *CodePtr);
+  ~OmptTargetDataOp();
+  void setDestAddr(void *DestAddr);
+};
+
+class OmptTargetMapping {
+private:
+  int32_t Capacity;
+  int32_t Size;
+  void **HostAddr;
+  void **DeviceAddr;
+  size_t *Bytes;
+  unsigned int *MappingFlags;
+  void *CodePtr;
+  bool Active;
+
+public:
+  typedef enum ConstructorType {
+    TARGET = 1,
+    TARGET_DATA_BEGIN = 2,
+    TARGET_DATA_END = 3
+  } ConstructorType;
+
+  OmptTargetMapping(int Capacity, void *CodePtr);
+  ~OmptTargetMapping();
+  void addMapping(void *HstAddr, void *TgtAddr, size_t Byte, int64_t ArgType,
+                  ConstructorType ConType);
+  void invokeCallback();
+};
+
+class OmptTarget {
+private:
+  ompt_target_t Kind;
+  int DeviceNum;
+  void *CodePtr;
+  bool Active;
+
+public:
+  OmptTarget(ompt_target_t Kind, int DeviceNum, void *CodePtr);
+  ~OmptTarget();
+};
+
+class OmptTargetSubmit {
+private:
+  unsigned int RequestedNumTeams;
+  bool Active;
+
+public:
+  OmptTargetSubmit(unsigned int RequestedNumTeams);
+  ~OmptTargetSubmit();
+};
+#else
 
-#define _OMP_EXTERN extern "C"
+#define OMPT_ARG(...)
+#define OMPT_FIRST_ARG(...)
 
-#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 // OMPT_SUPPORT
 
 #endif // LIBOMPTARGET_OMPT_TARGET_H

openmp/libomptarget/src/ompt-target.cpp

 #include "ompt-target.h"
+#include "omptarget.h"
 
-ompt_target_callbacks_active_t ompt_target_enabled;
+ompt_target_callbacks_active_t OmptTargetEnabled;
+
+int HostDeviceNum;
+
+OmptTargetDataOp::OmptTargetDataOp(ompt_target_data_op_t OpType, void *SrcAddr,
+                                   int SrcDeviceNum, void *DestAddr,
+                                   int DestDeviceNum, size_t Bytes,
+                                   bool OmpRoutine, void *CodePtr)
+    : OpType(OpType), SrcAddr(SrcAddr), SrcDeviceNum(SrcDeviceNum),
+      DestAddr(DestAddr), DestDeviceNum(DestDeviceNum), Bytes(Bytes),
+      OmpRoutine(OmpRoutine), CodePtr(CodePtr) {
+  this->Active = OmptTargetEnabled.enabled &&
+                 OmptTargetEnabled.ompt_callback_target_data_op_emi;
+  if (Active) {
+    libomp_ompt_callback_target_data_op_emi(
+        ompt_scope_begin, OpType, SrcAddr, SrcDeviceNum, DestAddr,
+        DestDeviceNum, Bytes, OmpRoutine, CodePtr);
+  }
+}
+
+OmptTargetDataOp::~OmptTargetDataOp() {
+  if (Active) {
+    libomp_ompt_callback_target_data_op_emi(
+        ompt_scope_end, OpType, SrcAddr, SrcDeviceNum, DestAddr, DestDeviceNum,
+        Bytes, OmpRoutine, CodePtr);
+  }
+}
+
+void OmptTargetDataOp::setDestAddr(void *DestAddr) {
+  this->DestAddr = DestAddr;
+}
+
+OmptTargetMapping::OmptTargetMapping(int Capacity, void *CodePtr)
+    : Capacity(Capacity), Size(0), CodePtr(CodePtr) {
+  this->Active = OmptTargetEnabled.enabled &&
+                 OmptTargetEnabled.ompt_callback_target_map_emi;
+  if (Active && Capacity) {
+    HostAddr = new void *[Capacity];
+    DeviceAddr = new void *[Capacity];
+    Bytes = new size_t[Capacity];
+    MappingFlags = new unsigned int[Capacity];
+  } else {
+    HostAddr = nullptr;
+    DeviceAddr = nullptr;
+    Bytes = nullptr;
+    MappingFlags = nullptr;
+  }
+}
+
+OmptTargetMapping::~OmptTargetMapping() {
+  if (Active && Capacity) {
+    delete[] HostAddr;
+    delete[] DeviceAddr;
+    delete[] Bytes;
+    delete[] MappingFlags;
+  }
+}
+
+// This function should only be invoked when capacity is non-zero
+void OmptTargetMapping::addMapping(void *HstAddr, void *TgtAddr, size_t Byte,
+                                   int64_t ArgType, ConstructorType ConType) {
+  if (Active) {
+    // Calculate mapping_flag using arg_type
+    unsigned int Flag = 0;
+    if (ConType == TARGET) {
+      if (ArgType & OMP_TGT_MAPTYPE_TO) {
+        Flag |= ompt_target_map_flag_to;
+      }
+      if (ArgType & OMP_TGT_MAPTYPE_FROM) {
+        Flag |= ompt_target_map_flag_from;
+      }
+      if (!Flag) {
+        Flag |= ompt_target_map_flag_alloc;
+      }
+    } else if (ConType == TARGET_DATA_BEGIN) {
+      if (ArgType & OMP_TGT_MAPTYPE_TO) {
+        Flag |= ompt_target_map_flag_to;
+      } else {
+        Flag |= ompt_target_map_flag_alloc;
+      }
+    } else if (ConType == TARGET_DATA_END) {
+      if (ArgType & OMP_TGT_MAPTYPE_FROM) {
+        Flag |= ompt_target_map_flag_from;
+      } else if (ArgType & OMP_TGT_MAPTYPE_DELETE) {
+        Flag |= ompt_target_map_flag_delete;
+      } else {
+        Flag |= ompt_target_map_flag_release;
+      }
+    }
+    if (ArgType & OMP_TGT_MAPTYPE_IMPLICIT) {
+      Flag |= ompt_target_map_flag_implicit;
+    }
+    if (ArgType & OMP_TGT_MAPTYPE_ALWAYS) {
+      Flag |= ompt_target_map_flag_always;
+    }
+    if (ArgType & OMP_TGT_MAPTYPE_PRESENT) {
+      Flag |= ompt_target_map_flag_present;
+    }
+    if (ArgType & OMP_TGT_MAPTYPE_CLOSE) {
+      Flag |= ompt_target_map_flag_close;
+    }
+
+    HostAddr[Size] = HstAddr;
+    DeviceAddr[Size] = TgtAddr;
+    Bytes[Size] = Byte;
+    MappingFlags[Size] = Flag;
+    Size += 1;
+  }
+}
+
+void OmptTargetMapping::invokeCallback() {
+  if (Active) {
+    libomp_ompt_callback_target_map_emi(Size, HostAddr, DeviceAddr, Bytes,
+                                        MappingFlags, CodePtr);
+  }
+}
+
+OmptTarget::OmptTarget(ompt_target_t Kind, int DeviceNum, void *CodePtr)
+    : Kind(Kind), DeviceNum(DeviceNum), CodePtr(CodePtr) {
+  this->Active =
+      OmptTargetEnabled.enabled && OmptTargetEnabled.ompt_callback_target_emi;
+  if (Active) {
+    libomp_ompt_callback_target_emi(Kind, ompt_scope_begin, DeviceNum, CodePtr);
+  }
+}
+
+OmptTarget::~OmptTarget() {
+  if (Active) {
+    libomp_ompt_callback_target_emi(Kind, ompt_scope_end, DeviceNum, CodePtr);
+  }
+}
+
+OmptTargetSubmit::OmptTargetSubmit(unsigned int RequestedNumTeams)
+    : RequestedNumTeams(RequestedNumTeams) {
+  this->Active = OmptTargetEnabled.enabled &&
+                 OmptTargetEnabled.ompt_callback_target_submit_emi;
+  if (Active) {
+    libomp_ompt_callback_target_submit_emi(ompt_scope_begin, RequestedNumTeams);
+  }
+}
+
+OmptTargetSubmit::~OmptTargetSubmit() {
+  if (Active) {
+    libomp_ompt_callback_target_submit_emi(ompt_scope_end, RequestedNumTeams);
+  }
+}

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 "ompt-target.h"
 #include "private.h"
 
 #if OMPT_SUPPORT
 #include "ompt-target.h"
 #endif
 
 #include <cassert>
 #include <cstdlib>
*((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)) {
+    if (!libomp_start_tool(&OmptTargetEnabled)) {
       DP("Turn off OMPT in libomptarget because libomp_start_tool returns "
          "false\n");
-      memset(&ompt_target_enabled, 0, sizeof(ompt_target_enabled));
+      memset(&OmptTargetEnabled, 0, sizeof(OmptTargetEnabled));
     }
   }
 #endif
 
   DP("RTLs loaded!\n");
 
   return;
 }
for (int32_t i = 0; i < desc->NumDeviceImages; ++i) {
 
     if (!FoundRTL) {
       DP("No RTL found for image " DPxMOD "!\n", DPxPTR(img->ImageStart));
     }
   }
   PM->RTLsMtx.unlock();
 
   DP("Done registering entries!\n");
+#if OMPT_SUPPORT
+  if (OmptTargetEnabled.enabled) {
+    HostDeviceNum = omp_get_initial_device();
+  }
+#endif
 }
 
 void RTLsTy::UnregisterLib(__tgt_bin_desc *desc) {
   DP("Unloading target library!\n");
 
   PM->RTLsMtx.lock();
   // Find which RTL understands each image, if any.
   for (int32_t i = 0; i < desc->NumDeviceImages; ++i) {