[OpenMP][libomptarget] Process resources when getting/returning from managers

[kevinsala]

Summary

This patch adds the functionality to process with a lambda the resources
obtained and returned by the resource managers in the plugins. These
processing lambdas are empty for the moment. The idea is to process them
while the resource manager mutex is acquired.

This patch can be useful to implement D154523

Depends on D155629

[jdoerfert]

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

1209–1215

Do we need this one now?

[kevinsala]

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

1209–1215

Not really. Managers that override getResource can just call the getResourcesImpl(/*Num=*/1, ...) directly. I'll remove it.

[jdoerfert]

LG

[kevinsala]

Removing unused function

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

Error deinit() {
     if (auto Err = ResourcePoolTy::resizeResourcePool(NextAvailable))
       return Err;
 
     ResourcePool.clear();
 
     return Plugin::success();
   }
 
-  /// Get a resource from the pool or create new ones. If the function succeeds,
-  /// the handle to the resource is saved in \p Handle.
-  Error getResource(ResourceHandleTy &Handle) {
-    return getResources(1, &Handle);
+  /// Get a resource from the pool or create new ones. If the function
+  /// succeeeds, the handle to the resource is saved in \p Handle.
+  virtual Error getResource(ResourceHandleTy &Handle) {
+    // Get a resource with an empty resource processor.
+    return getResourcesImpl(1, &Handle,
+                            [](ResourceHandleTy) { return Plugin::success(); });
   }
 
   /// Get multiple resources from the pool or create new ones. If the function
   /// succeeeds, the handles to the resources are saved in \p Handles.
-  Error getResources(uint32_t Num, ResourceHandleTy *Handles) {
+  virtual Error getResources(uint32_t Num, ResourceHandleTy *Handles) {
+    // Get resources with an empty resource processor.
+    return getResourcesImpl(Num, Handles,
+                            [](ResourceHandleTy) { return Plugin::success(); });
+  }
+
+  /// Return resource to the pool.
+  virtual Error returnResource(ResourceHandleTy Handle) {
+    // Return a resource with an empty resource processor.
+    return returnResourceImpl(
+        Handle, [](ResourceHandleTy) { return Plugin::success(); });
+  }
+
+protected:
+  /// Get multiple resources from the pool or create new ones. If the function
+  /// succeeeds, the handles to the resources are saved in \p Handles. Also
+  /// process each of the obtained resources with \p Processor.
+  template <typename FuncTy>
+  Error getResourcesImpl(uint32_t Num, ResourceHandleTy *Handles,
+                         FuncTy Processor) {
     const std::lock_guard<std::mutex> Lock(Mutex);
 
     assert(NextAvailable <= ResourcePool.size() &&
            "Resource pool is corrupted");
 
     if (NextAvailable + Num > ResourcePool.size())
       // Double the resource pool or resize it to provide the requested ones.
       if (auto Err = ResourcePoolTy::resizeResourcePool(
               std::max(NextAvailable * 2, NextAvailable + Num)))
         return Err;
 
     // Save the handles in the output array parameter.
     for (uint32_t r = 0; r < Num; ++r)
       Handles[r] = ResourcePool[NextAvailable + r];
 
+    // Process all obtained resources.
+    for (uint32_t r = 0; r < Num; ++r)
+      if (auto Err = Processor(Handles[r]))
+        return Err;
+
     NextAvailable += Num;
 
     return Plugin::success();
   }
 
-  /// Return resource to the pool.
-  Error returnResource(ResourceHandleTy Handle) {
+  /// Return resource to the pool and process the resource with \p Processor.
+  template <typename FuncTy>
+  Error returnResourceImpl(ResourceHandleTy Handle, FuncTy Processor) {
     const std::lock_guard<std::mutex> Lock(Mutex);
 
+    // Process the returned resource.
+    if (auto Err = Processor(Handle))
+      return Err;
+
     assert(NextAvailable > 0 && "Resource pool is corrupted");
     ResourcePool[--NextAvailable] = Handle;
 
     return Plugin::success();
   }
 
 private:
   /// The resources between \p OldSize and \p NewSize need to be created or