[OpenMP][libomptarget] Simplify resource managers in NextGen plugins

[kevinsala]

Summary

This patch removes the classes GenericStreamManagerTy and GenericEventManagerTy
from the PluginInterface header.

[jdoerfert]

LG

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

private:
   virtual Error getDeviceHeapSize(uint64_t &V) = 0;
   virtual Error setDeviceHeapSize(uint64_t V) = 0;
 
   /// Indicate whether the device should setup the device environment. Notice
   /// that returning false in this function will change the behavior of the
   /// setupDeviceEnvironment() function.
   virtual bool shouldSetupDeviceEnvironment() const { return true; }
 
+  /// Pointer to the memory manager or nullptr if not available.
+  MemoryManagerTy *MemoryManager;
+
   /// Environment variables defined by the OpenMP standard.
   Int32Envar OMP_TeamLimit;
   Int32Envar OMP_NumTeams;
   Int32Envar OMP_TeamsThreadLimit;
 
   /// Environment variables defined by the LLVM OpenMP implementation.
   Int32Envar OMPX_DebugKind;
   UInt32Envar OMPX_SharedMemorySize;
   UInt64Envar OMPX_TargetStackSize;
   UInt64Envar OMPX_TargetHeapSize;
 
-  /// Pointer to the memory manager or nullptr if not available.
-  MemoryManagerTy *MemoryManager;
-
 protected:
+  /// Environment variables defined by the LLVM OpenMP implementation
+  /// regarding the initial number of streams and events.
+  UInt32Envar OMPX_InitialNumStreams;
+  UInt32Envar OMPX_InitialNumEvents;
+
   /// Array of images loaded into the device. Images are automatically
   /// deallocated by the allocator.
   llvm::SmallVector<DeviceImageTy *> LoadedImages;
 
   /// The identifier of the device within the plugin. Notice this is not a
   /// global device id and is not the device id visible to the OpenMP user.
   const int32_t DeviceId;
 
public:
 
   /// Create a plugin-specific device.
   static GenericDeviceTy *createDevice(int32_t DeviceId, int32_t NumDevices);
 
   /// Create a plugin-specific global handler.
   static GenericGlobalHandlerTy *createGlobalHandler();
 };
 
-/// Auxiliary interface class for GenericDeviceResourcePoolTy. This class acts
-/// as a reference to a device resource, such as a stream, and requires some
-/// basic functions to be implemented. The derived class should define an empty
-/// constructor that creates an empty and invalid resource reference. Do not
-/// create a new resource on the ctor, but on the create() function instead.
+/// Auxiliary interface class for GenericDeviceResourceManagerTy. This class
+/// acts as a reference to a device resource, such as a stream, and requires
+/// some basic functions to be implemented. The derived class should define an
+/// empty constructor that creates an empty and invalid resource reference. Do
+/// not create a new resource on the ctor, but on the create() function instead.
 struct GenericDeviceResourceRef {
   /// Create a new resource and stores a reference.
   virtual Error create(GenericDeviceTy &Device) = 0;
 
   /// Destroy and release the resources pointed by the reference.
   virtual Error destroy(GenericDeviceTy &Device) = 0;
 
 protected:
   ~GenericDeviceResourceRef() = default;
 };
 
 /// Class that implements a resource pool belonging to a device. This class
 /// operates with references to the actual resources. These reference must
 /// derive from the GenericDeviceResourceRef class and implement the create
 /// and destroy virtual functions.
-template <typename ResourceRef> class GenericDeviceResourcePoolTy {
-  using ResourcePoolTy = GenericDeviceResourcePoolTy<ResourceRef>;
+template <typename ResourceRef> class GenericDeviceResourceManagerTy {
+  using ResourcePoolTy = GenericDeviceResourceManagerTy<ResourceRef>;
 
 public:
   /// Create an empty resource pool for a specific device.
-  GenericDeviceResourcePoolTy(GenericDeviceTy &Device)
+  GenericDeviceResourceManagerTy(GenericDeviceTy &Device)
       : Device(Device), NextAvailable(0) {}
 
   /// Destroy the resource pool. At this point, the deinit() function should
   /// already have been executed so the resource pool should be empty.
-  virtual ~GenericDeviceResourcePoolTy() {
+  virtual ~GenericDeviceResourceManagerTy() {
     assert(ResourcePool.empty() && "Resource pool not empty");
   }
 
   /// Initialize the resource pool.
   Error init(uint32_t InitialSize) {
     assert(ResourcePool.empty() && "Resource pool already initialized");
     return ResourcePoolTy::resizeResourcePool(InitialSize);
   }
Error deinit() {
     if (auto Err = ResourcePoolTy::resizeResourcePool(NextAvailable))
       return Err;
 
     ResourcePool.clear();
 
     return Plugin::success();
   }
 
-protected:
   /// Get resource from the pool or create new resources.
   ResourceRef getResource() {
     const std::lock_guard<std::mutex> Lock(Mutex);
 
     assert(NextAvailable <= ResourcePool.size() &&
            "Resource pool is corrupted");
 
     if (NextAvailable == ResourcePool.size()) {
private:
   /// be called with the mutex acquired.
   Error resizeResourcePool(uint32_t NewSize) {
     uint32_t OldSize = ResourcePool.size();
 
     // Nothing to do.
     if (OldSize == NewSize)
       return Plugin::success();
 
-    if (OldSize > NewSize) {
-      // Decrease the number of resources.
-      auto Err = ResourcePoolTy::resizeResourcePoolImpl(OldSize, NewSize);
+    if (OldSize < NewSize) {
+      // Increase the number of resources.
       ResourcePool.resize(NewSize);
-      return Err;
+      return ResourcePoolTy::resizeResourcePoolImpl(OldSize, NewSize);
     }
 
-    // Increase the number of resources otherwise.
+    // Decrease the number of resources otherwise.
+    auto Err = ResourcePoolTy::resizeResourcePoolImpl(OldSize, NewSize);
     ResourcePool.resize(NewSize);
-    return ResourcePoolTy::resizeResourcePoolImpl(OldSize, NewSize);
+
+    return Err;
   }
 
   /// The device to which the resources belong
   GenericDeviceTy &Device;
 
   /// Mutex for the resource pool.
   std::mutex Mutex;
 
   /// The next available resource in the pool.
   uint32_t NextAvailable;
 
-protected:
   /// The actual resource pool.
   std::deque<ResourceRef> ResourcePool;
 };
 
-/// Class implementing a common stream manager. This class can be directly used
-/// by the specific plugins if necessary. The StreamRef type should derive from
-/// the GenericDeviceResourceRef. Look at its description to know the details of
-/// their requirements.
-template <typename StreamRef>
-class GenericStreamManagerTy : public GenericDeviceResourcePoolTy<StreamRef> {
-  using ResourcePoolTy = GenericDeviceResourcePoolTy<StreamRef>;
-
-public:
-  /// Create a stream manager with space for an initial number of streams. No
-  /// stream will be created until the init() function is called.
-  GenericStreamManagerTy(GenericDeviceTy &Device, uint32_t DefNumStreams = 32)
-      : ResourcePoolTy(Device),
-        InitialNumStreams("LIBOMPTARGET_NUM_INITIAL_STREAMS", DefNumStreams) {}
-
-  /// Initialize the stream pool and their resources with the initial number of
-  /// streams.
-  Error init() { return ResourcePoolTy::init(InitialNumStreams.get()); }
-
-  /// Get an available stream or create new.
-  StreamRef getStream() { return ResourcePoolTy::getResource(); }
-
-  /// Return idle stream.
-  void returnStream(StreamRef Stream) {
-    ResourcePoolTy::returnResource(Stream);
-  }
-
-private:
-  /// The initial stream pool size, potentially defined by an envar.
-  UInt32Envar InitialNumStreams;
-};
-
-/// Class implementing a common event manager. This class can be directly used
-/// by the specific plugins if necessary. The EventRef type should derive from
-/// the GenericDeviceResourceRef. Look at its description to know the details of
-/// their requirements.
-template <typename EventRef>
-struct GenericEventManagerTy : public GenericDeviceResourcePoolTy<EventRef> {
-  using ResourcePoolTy = GenericDeviceResourcePoolTy<EventRef>;
-
-public:
-  /// Create an event manager with space for an initial number of events. No
-  /// event will be created until the init() function is called.
-  GenericEventManagerTy(GenericDeviceTy &Device, uint32_t DefNumEvents = 32)
-      : ResourcePoolTy(Device),
-        InitialNumEvents("LIBOMPTARGET_NUM_INITIAL_EVENTS", DefNumEvents) {}
-
-  /// Initialize the event pool and their resources with the initial number of
-  /// events.
-  Error init() { return ResourcePoolTy::init(InitialNumEvents.get()); }
-
-  /// Get an available event or create new.
-  EventRef getEvent() { return ResourcePoolTy::getResource(); }
-
-  /// Return an idle event.
-  void returnEvent(EventRef Event) { ResourcePoolTy::returnResource(Event); }
-
-private:
-  /// The initial event pool size, potentially defined by an envar.
-  UInt32Envar InitialNumEvents;
-};
-
 } // namespace plugin
 } // namespace target
 } // namespace omp
 } // namespace llvm
 
 #endif // OPENMP_LIBOMPTARGET_PLUGINS_COMMON_PLUGININTERFACE_H

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

if (isSPMDMode()) {
       PreferredNumBlocks = LoopTripCount;
     }
   }
   return std::min(PreferredNumBlocks, GenericDevice.getBlockLimit());
 }
 
 GenericDeviceTy::GenericDeviceTy(int32_t DeviceId, int32_t NumDevices,
                                  const llvm::omp::GV &OMPGridValues)
-    : OMP_TeamLimit("OMP_TEAM_LIMIT"), OMP_NumTeams("OMP_NUM_TEAMS"),
+    : MemoryManager(nullptr), OMP_TeamLimit("OMP_TEAM_LIMIT"),
+      OMP_NumTeams("OMP_NUM_TEAMS"),
       OMP_TeamsThreadLimit("OMP_TEAMS_THREAD_LIMIT"),
       OMPX_DebugKind("LIBOMPTARGET_DEVICE_RTL_DEBUG"),
       OMPX_SharedMemorySize("LIBOMPTARGET_SHARED_MEMORY_SIZE"),
       // Do not initialize the following two envars since they depend on the
       // device initialization. These cannot be consulted until the device is
       // initialized correctly. We intialize them in GenericDeviceTy::init().
-      OMPX_TargetStackSize(), OMPX_TargetHeapSize(), MemoryManager(nullptr),
+      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() {
   if (OMP_NumTeams > 0)
     GridValues.GV_Max_Teams =
         std::min(GridValues.GV_Max_Teams, uint32_t(OMP_NumTeams));
 
   if (OMP_TeamsThreadLimit > 0)
     GridValues.GV_Max_WG_Size =

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

 namespace omp {
 namespace target {
 namespace plugin {
 
 /// Forward declarations for all specialized data structures.
 struct CUDAKernelTy;
 struct CUDADeviceTy;
 struct CUDAPluginTy;
-struct CUDAStreamManagerTy;
-struct CUDAEventManagerTy;
 
 /// Class implementing the CUDA kernel functionalities which derives from the
 /// generic kernel class.
 struct CUDAKernelTy : public GenericKernelTy {
   /// Create a CUDA kernel with a name, an execution mode, and the kernel
   /// function.
   CUDAKernelTy(const char *Name, OMPTgtExecModeFlags ExecutionMode,
                CUfunction Func)
Error initImpl(GenericPluginTy &Plugin) override {
     Res = cuDevicePrimaryCtxRetain(&Context, Device);
     if (auto Err = Plugin::check(Res, "Error in cuDevicePrimaryCtxRetain: %s"))
       return Err;
 
     if (auto Err = setContext())
       return Err;
 
     // Initialize stream pool.
-    if (auto Err = CUDAStreamManager.init())
+    if (auto Err = CUDAStreamManager.init(OMPX_InitialNumStreams))
       return Err;
 
     // Initialize event pool.
-    if (auto Err = CUDAEventManager.init())
+    if (auto Err = CUDAEventManager.init(OMPX_InitialNumEvents))
       return Err;
 
     // Query attributes to determine number of threads/block and blocks/grid.
     if (auto Err = getDeviceAttr(CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X,
                                  GridValues.GV_Max_Teams))
       return Err;
 
     if (auto Err = getDeviceAttr(CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X,
Error setContext() override {
     CUresult Res = cuCtxSetCurrent(Context);
     return Plugin::check(Res, "Error in cuCtxSetCurrent: %s");
   }
 
   /// Get the stream of the asynchronous info sructure or get a new one.
   CUstream getStream(AsyncInfoWrapperTy &AsyncInfoWrapper) {
     CUstream &Stream = AsyncInfoWrapper.getQueueAs<CUstream>();
     if (!Stream)
-      Stream = CUDAStreamManager.getStream();
+      Stream = CUDAStreamManager.getResource();
     return Stream;
   }
 
   /// Getters of CUDA references.
   CUcontext getCUDAContext() const { return Context; }
   CUdevice getCUDADevice() const { return Device; }
 
   /// Load the binary image into the device and allocate an image object.
struct CUDADeviceTy : public GenericDeviceTy {
   /// Synchronize current thread with the pending operations on the async info.
   Error synchronizeImpl(__tgt_async_info &AsyncInfo) override {
     CUstream Stream = reinterpret_cast<CUstream>(AsyncInfo.Queue);
     CUresult Res = cuStreamSynchronize(Stream);
 
     // Once the stream is synchronized, return it to stream pool and reset
     // AsyncInfo. This is to make sure the synchronization only works for its
     // own tasks.
-    CUDAStreamManager.returnStream(Stream);
+    CUDAStreamManager.returnResource(Stream);
     AsyncInfo.Queue = nullptr;
 
     return Plugin::check(Res, "Error in cuStreamSynchronize: %s");
   }
 
   /// Submit data to the device (host to device transfer).
   Error dataSubmitImpl(void *TgtPtr, const void *HstPtr, int64_t Size,
                        AsyncInfoWrapperTy &AsyncInfoWrapper) override {
if (!DeviceInfo->Device)
       DeviceInfo->Device = reinterpret_cast<void *>(Device);
 
     return Plugin::success();
   }
 
   /// Create an event.
   Error createEventImpl(void **EventPtrStorage) override {
     CUevent *Event = reinterpret_cast<CUevent *>(EventPtrStorage);
-    *Event = CUDAEventManager.getEvent();
+    *Event = CUDAEventManager.getResource();
     return Plugin::success();
   }
 
   /// Destroy a previously created event.
   Error destroyEventImpl(void *EventPtr) override {
     CUevent Event = reinterpret_cast<CUevent>(EventPtr);
-    CUDAEventManager.returnEvent(Event);
+    CUDAEventManager.returnResource(Event);
     return Plugin::success();
   }
 
   /// Record the event.
   Error recordEventImpl(void *EventPtr,
                         AsyncInfoWrapperTy &AsyncInfoWrapper) override {
     CUevent Event = reinterpret_cast<CUevent>(EventPtr);
 
struct CUDADeviceTy : public GenericDeviceTy {
   Error getDeviceAttr(uint32_t Kind, uint32_t &Value) {
     // TODO: Warn if the new value is larger than the old.
     CUresult Res =
         cuDeviceGetAttribute((int *)&Value, (CUdevice_attribute)Kind, Device);
     return Plugin::check(Res, "Error in cuDeviceGetAttribute: %s");
   }
 
 private:
-  using CUDAStreamManagerTy = GenericStreamManagerTy<CUDAStreamRef>;
-  using CUDAEventManagerTy = GenericEventManagerTy<CUDAEventRef>;
+  using CUDAStreamManagerTy = GenericDeviceResourceManagerTy<CUDAStreamRef>;
+  using CUDAEventManagerTy = GenericDeviceResourceManagerTy<CUDAEventRef>;
 
   /// Stream manager for CUDA streams.
   CUDAStreamManagerTy CUDAStreamManager;
 
   /// Event manager for CUDA events.
   CUDAEventManagerTy CUDAEventManager;
 
   /// The device's context. This context should be set before performing