offload/src/PluginManager.cpp

   1 //===-- PluginManager.cpp - Plugin loading and communication API ---------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Functionality for handling plugins.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "PluginManager.h"
  14 #include "Shared/Debug.h"
  15 #include "Shared/Profile.h"
  16
  17 #include "llvm/Support/Error.h"
  18 #include "llvm/Support/ErrorHandling.h"
  19 #include <memory>
  20
  21 using namespace llvm;
  22 using namespace llvm::sys;
  23
  24 PluginManager *PM = nullptr;
  25
  26 // Every plugin exports this method to create an instance of the plugin type.
  27 #define PLUGIN_TARGET(Name) extern "C" GenericPluginTy *createPlugin_##Name();
  28 #include "Shared/Targets.def"
  29
  30 void PluginManager::init() {
  31   TIMESCOPE();
  32   DP("Loading RTLs...\n");
  33
  34   // Attempt to create an instance of each supported plugin.
  35 #define PLUGIN_TARGET(Name)                                                    \
  36   do {                                                                         \
  37     Plugins.emplace_back(                                                      \
  38         std::unique_ptr<GenericPluginTy>(createPlugin_##Name()));              \
  39   } while (false);
  40 #include "Shared/Targets.def"
  41
  42   DP("RTLs loaded!\n");
  43 }
  44
  45 void PluginManager::deinit() {
  46   TIMESCOPE();
  47   DP("Unloading RTLs...\n");
  48
  49   for (auto &Plugin : Plugins) {
  50     if (!Plugin->is_initialized())
  51       continue;
  52
  53     if (auto Err = Plugin->deinit()) {
  54       [[maybe_unused]] std::string InfoMsg = toString(std::move(Err));
  55       DP("Failed to deinit plugin: %s\n", InfoMsg.c_str());
  56     }
  57     Plugin.release();
  58   }
  59
  60   DP("RTLs unloaded!\n");
  61 }
  62
  63 void PluginManager::initAllPlugins() {
  64   for (auto &R : plugins()) {
  65     if (auto Err = R.init()) {
  66       [[maybe_unused]] std::string InfoMsg = toString(std::move(Err));
  67       DP("Failed to init plugin: %s\n", InfoMsg.c_str());
  68       continue;
  69     }
  70     DP("Registered plugin %s with %d visible device(s)\n", R.getName(),
  71        R.number_of_devices());
  72   }
  73 }
  74
  75 void PluginManager::registerLib(__tgt_bin_desc *Desc) {
  76   PM->RTLsMtx.lock();
  77
  78   // Add in all the OpenMP requirements associated with this binary.
  79   for (__tgt_offload_entry &Entry :
  80        llvm::make_range(Desc->HostEntriesBegin, Desc->HostEntriesEnd))
  81     if (Entry.flags == OMP_REGISTER_REQUIRES)
  82       PM->addRequirements(Entry.data);
  83
  84   // Extract the exectuable image and extra information if availible.
  85   for (int32_t i = 0; i < Desc->NumDeviceImages; ++i)
  86     PM->addDeviceImage(*Desc, Desc->DeviceImages[i]);
  87
  88   // Register the images with the RTLs that understand them, if any.
  89   for (DeviceImageTy &DI : PM->deviceImages()) {
  90     // Obtain the image and information that was previously extracted.
  91     __tgt_device_image *Img = &DI.getExecutableImage();
  92
  93     GenericPluginTy *FoundRTL = nullptr;
  94
  95     // Scan the RTLs that have associated images until we find one that supports
  96     // the current image.
  97     for (auto &R : PM->plugins()) {
  98       if (!R.is_plugin_compatible(Img))
  99         continue;
 100
 101       if (!R.is_initialized()) {
 102         if (auto Err = R.init()) {
 103           [[maybe_unused]] std::string InfoMsg = toString(std::move(Err));
 104           DP("Failed to init plugin: %s\n", InfoMsg.c_str());
 105           continue;
 106         }
 107         DP("Registered plugin %s with %d visible device(s)\n", R.getName(),
 108            R.number_of_devices());
 109       }
 110
 111       if (!R.number_of_devices()) {
 112         DP("Skipping plugin %s with no visible devices\n", R.getName());
 113         continue;
 114       }
 115
 116       for (int32_t DeviceId = 0; DeviceId < R.number_of_devices(); ++DeviceId) {
 117         if (!R.is_device_compatible(DeviceId, Img))
 118           continue;
 119
 120         DP("Image " DPxMOD " is compatible with RTL %s device %d!\n",
 121            DPxPTR(Img->ImageStart), R.getName(), DeviceId);
 122
 123         if (!R.is_device_initialized(DeviceId)) {
 124           // Initialize the device information for the RTL we are about to use.
 125           auto ExclusiveDevicesAccessor = getExclusiveDevicesAccessor();
 126
 127           int32_t UserId = ExclusiveDevicesAccessor->size();
 128
 129           // Set the device identifier offset in the plugin.
 130 #ifdef OMPT_SUPPORT
 131           R.set_device_identifier(UserId, DeviceId);
 132 #endif
 133
 134           auto Device = std::make_unique<DeviceTy>(&R, UserId, DeviceId);
 135           if (auto Err = Device->init()) {
 136             [[maybe_unused]] std::string InfoMsg = toString(std::move(Err));
 137             DP("Failed to init device %d: %s\n", DeviceId, InfoMsg.c_str());
 138             continue;
 139           }
 140
 141           ExclusiveDevicesAccessor->push_back(std::move(Device));
 142
 143           // We need to map between the plugin's device identifier and the one
 144           // that OpenMP will use.
 145           PM->DeviceIds[std::make_pair(&R, DeviceId)] = UserId;
 146         }
 147
 148         // Initialize (if necessary) translation table for this library.
 149         PM->TrlTblMtx.lock();
 150         if (!PM->HostEntriesBeginToTransTable.count(Desc->HostEntriesBegin)) {
 151           PM->HostEntriesBeginRegistrationOrder.push_back(
 152               Desc->HostEntriesBegin);
 153           TranslationTable &TT =
 154               (PM->HostEntriesBeginToTransTable)[Desc->HostEntriesBegin];
 155           TT.HostTable.EntriesBegin = Desc->HostEntriesBegin;
 156           TT.HostTable.EntriesEnd = Desc->HostEntriesEnd;
 157         }
 158
 159         // Retrieve translation table for this library.
 160         TranslationTable &TT =
 161             (PM->HostEntriesBeginToTransTable)[Desc->HostEntriesBegin];
 162
 163         DP("Registering image " DPxMOD " with RTL %s!\n",
 164            DPxPTR(Img->ImageStart), R.getName());
 165
 166         auto UserId = PM->DeviceIds[std::make_pair(&R, DeviceId)];
 167         if (TT.TargetsTable.size() < static_cast<size_t>(UserId + 1)) {
 168           TT.DeviceTables.resize(UserId + 1, {});
 169           TT.TargetsImages.resize(UserId + 1, nullptr);
 170           TT.TargetsEntries.resize(UserId + 1, {});
 171           TT.TargetsTable.resize(UserId + 1, nullptr);
 172         }
 173
 174         // Register the image for this target type and invalidate the table.
 175         TT.TargetsImages[UserId] = Img;
 176         TT.TargetsTable[UserId] = nullptr;
 177
 178         PM->UsedImages.insert(Img);
 179         FoundRTL = &R;
 180
 181         PM->TrlTblMtx.unlock();
 182       }
 183     }
 184     if (!FoundRTL)
 185       DP("No RTL found for image " DPxMOD "!\n", DPxPTR(Img->ImageStart));
 186   }
 187   PM->RTLsMtx.unlock();
 188
 189   bool UseAutoZeroCopy = Plugins.size() > 0;
 190
 191   auto ExclusiveDevicesAccessor = getExclusiveDevicesAccessor();
 192   for (const auto &Device : *ExclusiveDevicesAccessor)
 193     UseAutoZeroCopy &= Device->useAutoZeroCopy();
 194
 195   // Auto Zero-Copy can only be currently triggered when the system is an
 196   // homogeneous APU architecture without attached discrete GPUs.
 197   // If all devices suggest to use it, change requirment flags to trigger
 198   // zero-copy behavior when mapping memory.
 199   if (UseAutoZeroCopy)
 200     addRequirements(OMPX_REQ_AUTO_ZERO_COPY);
 201
 202   DP("Done registering entries!\n");
 203 }
 204
 205 // Temporary forward declaration, old style CTor/DTor handling is going away.
 206 int target(ident_t *Loc, DeviceTy &Device, void *HostPtr,
 207            KernelArgsTy &KernelArgs, AsyncInfoTy &AsyncInfo);
 208
 209 void PluginManager::unregisterLib(__tgt_bin_desc *Desc) {
 210   DP("Unloading target library!\n");
 211
 212   PM->RTLsMtx.lock();
 213   // Find which RTL understands each image, if any.
 214   for (DeviceImageTy &DI : PM->deviceImages()) {
 215     // Obtain the image and information that was previously extracted.
 216     __tgt_device_image *Img = &DI.getExecutableImage();
 217
 218     GenericPluginTy *FoundRTL = NULL;
 219
 220     // Scan the RTLs that have associated images until we find one that supports
 221     // the current image. We only need to scan RTLs that are already being used.
 222     for (auto &R : PM->plugins()) {
 223       if (R.is_initialized())
 224         continue;
 225
 226       // Ensure that we do not use any unused images associated with this RTL.
 227       if (!UsedImages.contains(Img))
 228         continue;
 229
 230       FoundRTL = &R;
 231
 232       DP("Unregistered image " DPxMOD " from RTL\n", DPxPTR(Img->ImageStart));
 233
 234       break;
 235     }
 236
 237     // if no RTL was found proceed to unregister the next image
 238     if (!FoundRTL) {
 239       DP("No RTLs in use support the image " DPxMOD "!\n",
 240          DPxPTR(Img->ImageStart));
 241     }
 242   }
 243   PM->RTLsMtx.unlock();
 244   DP("Done unregistering images!\n");
 245
 246   // Remove entries from PM->HostPtrToTableMap
 247   PM->TblMapMtx.lock();
 248   for (__tgt_offload_entry *Cur = Desc->HostEntriesBegin;
 249        Cur < Desc->HostEntriesEnd; ++Cur) {
 250     PM->HostPtrToTableMap.erase(Cur->addr);
 251   }
 252
 253   // Remove translation table for this descriptor.
 254   auto TransTable =
 255       PM->HostEntriesBeginToTransTable.find(Desc->HostEntriesBegin);
 256   if (TransTable != PM->HostEntriesBeginToTransTable.end()) {
 257     DP("Removing translation table for descriptor " DPxMOD "\n",
 258        DPxPTR(Desc->HostEntriesBegin));
 259     PM->HostEntriesBeginToTransTable.erase(TransTable);
 260   } else {
 261     DP("Translation table for descriptor " DPxMOD " cannot be found, probably "
 262        "it has been already removed.\n",
 263        DPxPTR(Desc->HostEntriesBegin));
 264   }
 265
 266   PM->TblMapMtx.unlock();
 267
 268   DP("Done unregistering library!\n");
 269 }
 270
 271 Expected<DeviceTy &> PluginManager::getDevice(uint32_t DeviceNo) {
 272   auto ExclusiveDevicesAccessor = getExclusiveDevicesAccessor();
 273   if (DeviceNo >= ExclusiveDevicesAccessor->size())
 274     return createStringError(
 275         inconvertibleErrorCode(),
 276         "Device number '%i' out of range, only %i devices available", DeviceNo,
 277         ExclusiveDevicesAccessor->size());
 278
 279   return *(*ExclusiveDevicesAccessor)[DeviceNo];
 280 }