[openmp] Introduce optional plugin init/deinit functions

[JonChesterfield]

Summary

Will allow plugins to migrate away from using global variables to
manage lifetime, which will fix a segfault discovered in relation to D127432

[JonChesterfield]

• update comment

[JonChesterfield]

Manually tested by permuting the stubs added to the amdgpu plugin (return success, fail, delete the function). Decided init failing should be treated equivalently to failing to open the plugin at all, and deinit failing should be warning message and otherwise ignored.

[jhuber6]

LG,

Right now initialization and destruction happens from a static class in the plugins. This isn't really a good solution as per the LLVM coding standards https://llvm.org/docs/CodingStandards.html#do-not-use-static-constructors so it's good to replace these with explicit calls via these new functions.

openmp/libomptarget/include/omptargetplugin.h

 #define _OMPTARGETPLUGIN_H_
 
 #include <omptarget.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+// First method called on the plugin
+int32_t __tgt_rtl_init_plugin();
+
+// Last method called on the plugin
+int32_t __tgt_rtl_deinit_plugin();
+
 // Return the number of available devices of the type supported by the
 // target RTL.
 int32_t __tgt_rtl_number_of_devices(void);
 
 // Return an integer different from zero if the provided device image can be
 // supported by the runtime. The functionality is similar to comparing the
 // result of __tgt__rtl__load__binary to NULL. However, this is meant to be a
 // lightweight query to determine if the RTL is suitable for an image without

openmp/libomptarget/include/rtl.h

 #include <string>
 #include <vector>
 
 // Forward declarations.
 struct DeviceTy;
 struct __tgt_bin_desc;
 
 struct RTLInfoTy {
+  typedef int32_t(init_plugin_ty)();
+  typedef int32_t(deinit_plugin_ty)();
   typedef int32_t(is_valid_binary_ty)(void *);
   typedef int32_t(is_valid_binary_info_ty)(void *, void *);
   typedef int32_t(is_data_exchangable_ty)(int32_t, int32_t);
   typedef int32_t(number_of_devices_ty)();
   typedef int32_t(init_device_ty)(int32_t);
   typedef int32_t(deinit_device_ty)(int32_t);
   typedef __tgt_target_table *(load_binary_ty)(int32_t, void *);
   typedef void *(data_alloc_ty)(int32_t, int64_t, void *, int32_t);
struct RTLInfoTy {
 
   void *LibraryHandler = nullptr;
 
 #ifdef OMPTARGET_DEBUG
   std::string RTLName;
 #endif
 
   // Functions implemented in the RTL.
+  init_plugin_ty *init_plugin = nullptr;
+  deinit_plugin_ty *deinit_plugin = nullptr;
   is_valid_binary_ty *is_valid_binary = nullptr;
   is_valid_binary_info_ty *is_valid_binary_info = nullptr;
   is_data_exchangable_ty *is_data_exchangable = nullptr;
   number_of_devices_ty *number_of_devices = nullptr;
   init_device_ty *init_device = nullptr;
   deinit_device_ty *deinit_device = nullptr;
   load_binary_ty *load_binary = nullptr;
   data_alloc_ty *data_alloc = nullptr;

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

for (int32_t DeviceId = 0; DeviceId < NumberOfDevices; ++DeviceId) {
     if (!IsImageCompatibleWithEnv(info->Arch, DeviceInfo.TargetID[DeviceId]))
       return false;
   }
   DP("Image has Target ID compatible with the current environment: %s\n",
      info->Arch);
   return true;
 }
 
+int32_t __tgt_rtl_init_plugin() { return OFFLOAD_SUCCESS; }
+int32_t __tgt_rtl_deinit_plugin() { return OFFLOAD_SUCCESS; }
+
 int __tgt_rtl_number_of_devices() {
   // If the construction failed, no methods are safe to call
   if (DeviceInfo.ConstructionSucceeded) {
     return DeviceInfo.NumberOfDevices;
   }
   DP("AMDGPU plugin construction failed. Zero devices available\n");
   return 0;
 }

openmp/libomptarget/plugins/exports

 VERS1.0 {
   global:
+    __tgt_rtl_init_plugin;
+    __tgt_rtl_deinit_plugin;
     __tgt_rtl_is_valid_binary;
     __tgt_rtl_is_valid_binary_info;
     __tgt_rtl_is_data_exchangable;
     __tgt_rtl_number_of_devices;
     __tgt_rtl_init_requires;
     __tgt_rtl_init_device;
     __tgt_rtl_deinit_device;
     __tgt_rtl_load_binary;

openmp/libomptarget/src/rtl.cpp

for (auto *Name : RTLNames) {
 
     DP("Successfully loaded library '%s'!\n", Name);
 
     AllRTLs.emplace_back();
 
     // Retrieve the RTL information from the runtime library.
     RTLInfoTy &R = AllRTLs.back();
 
+    // Remove plugin on failure to call optional init_plugin
+    *((void **)&R.init_plugin) = dlsym(DynlibHandle, "__tgt_rtl_init_plugin");
+    if (R.init_plugin) {
+      int32_t Rc = R.init_plugin();
+      if (Rc != OFFLOAD_SUCCESS) {
+        DP("Unable to initialize library '%s': %u!\n", Name, Rc);
+        AllRTLs.pop_back();
+        continue;
+      }
+    }
+
     bool ValidPlugin = true;
 
     if (!(*((void **)&R.is_valid_binary) =
               dlsym(DynlibHandle, "__tgt_rtl_is_valid_binary")))
       ValidPlugin = false;
     if (!(*((void **)&R.number_of_devices) =
               dlsym(DynlibHandle, "__tgt_rtl_number_of_devices")))
       ValidPlugin = false;

 #ifdef OMPTARGET_DEBUG
     R.RTLName = Name;
 #endif
 
     DP("Registering RTL %s supporting %d devices!\n", R.RTLName.c_str(),
        R.NumberOfDevices);
 
     // Optional functions
+    *((void **)&R.deinit_plugin) =
+        dlsym(DynlibHandle, "__tgt_rtl_deinit_plugin");
     *((void **)&R.is_valid_binary_info) =
         dlsym(DynlibHandle, "__tgt_rtl_is_valid_binary_info");
     *((void **)&R.deinit_device) =
         dlsym(DynlibHandle, "__tgt_rtl_deinit_device");
     *((void **)&R.init_requires) =
         dlsym(DynlibHandle, "__tgt_rtl_init_requires");
     *((void **)&R.data_submit_async) =
         dlsym(DynlibHandle, "__tgt_rtl_data_submit_async");
void RTLsTy::unregisterLib(__tgt_bin_desc *Desc) {
   } else {
     DP("Translation table for descriptor " DPxMOD " cannot be found, probably "
        "it has been already removed.\n",
        DPxPTR(Desc->HostEntriesBegin));
   }
 
   PM->TblMapMtx.unlock();
 
-  // TODO: Remove RTL and the devices it manages if it's not used anymore?
   // TODO: Write some RTL->unload_image(...) function?
+  for (auto *R : UsedRTLs) {
+    if (R->deinit_plugin) {
+      if (R->deinit_plugin() != OFFLOAD_SUCCESS) {
+        DP("Failure deinitializing RTL %s!\n", R->RTLName.c_str());
+      }
+    }
+  }
 
   DP("Done unregistering library!\n");
 }