[SYCL][PI] Replace PI_CALL family of macros with new plugin_impl class (#1030)

The changeset removes the family of PI_CALL macros, and replaces them with
call API in a new plugin_impl class. The object of this class is stored in
Platform class. When multiple platforms are associated with the same Plugin,
they will have shared_ptr to the same plugin_impl object. Eg: An OpenCLPlugin
can have multiple platforms attached to it.

To effectively use this change, following additional fetaures/changes
were added:

- To make access to the plugin_impl class easy, getPlugin() API has been
  introduced to some *_impl classes, that eventually call the
  platform_impl->getPlugin() API. It has been included in context_impl,
  event_impl, kernel_impl, platform_impl, program_impl, queue_impl. Is not
  present in accessor_impl(Does not call PI), buffer_impl (Needs only in the
  constructor where context is passed), sampler_impl (Does not have a single
  context), stream_impl (Does not call PI), usm_impl (Has no member sycl_impl
  objects.) The API returns const reference to plugin_impl class.
- Use of PiApiKind enum to uniquely identify the PI API.
- PI API calls are done using : plugin_impl.call, plugin_impl.call_nocheck,
  plugin_impl.checkPiResult<Exception>
- GlobalPlugin is a SharedPtr to a globally available Plugin for the use with
  Interoperability Constructors. It is used as a shared_ptr to avoid making
  copies of it.
- Changes in *_info structs and get() methods. They now take a const
  plugin_impl& argument.
- To make Pi Api calls by host to check if certain events are finished on a
  device, the plugin_impl class is needed. At such places, event_impl is passed
  instead of a PiEvent. Eg: memory_manager.cpp
- The use of Global variable has been restricted to only the GlobalPlugin now.

Signed-off-by: Garima Gupta <[email protected]>

Author: garimagu

sycl/include/CL/sycl/buffer.hpp

@@ -195,8 +195,10 @@ class buffer {
       : Range{0} {
 
     size_t BufSize = 0;
-    PI_CALL(piMemGetInfo)(detail::pi::cast<detail::RT::PiMem>(MemObject),
-                          CL_MEM_SIZE, sizeof(size_t), &BufSize, nullptr);
+    const detail::plugin &Plugin = detail::getSyclObjImpl(SyclContext)->getPlugin();
+    Plugin.call<detail::PiApiKind::piMemGetInfo>(
+        detail::pi::cast<detail::RT::PiMem>(MemObject), CL_MEM_SIZE,
+        sizeof(size_t), &BufSize, nullptr);
 
     Range[0] = BufSize / sizeof(T);
     impl = std::make_shared<detail::buffer_impl>(

sycl/include/CL/sycl/detail/context_impl.hpp

@@ -59,7 +59,10 @@ class context_impl {
   ///
   /// @param PiContext is an instance of a valid plug-in context handle.
   /// @param AsyncHandler is an instance of async_handler.
-  context_impl(RT::PiContext PiContext, async_handler AsyncHandler);
+  /// @param &Plugin is the reference to the underlying Plugin that this context
+  /// is associated with.
+  context_impl(RT::PiContext PiContext, async_handler AsyncHandler,
+               const plugin &Plugin);
 
   ~context_impl();
 
@@ -78,6 +81,12 @@ class context_impl {
   /// @return an instance of SYCL async_handler.
   const async_handler &get_async_handler() const;
 
+  /// @return the Plugin associated with the platform of this context.
+  const plugin &getPlugin() const { return MPlatform->getPlugin(); }
+
+  /// @return the PlatformImpl associated with this context.
+  PlatformImplPtr getPlatformImpl() const { return MPlatform; }
+
   /// Queries this context for information.
   ///
   /// The return type depends on information being queried.

sycl/include/CL/sycl/detail/context_info.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <CL/sycl/detail/common.hpp>
+#include <CL/sycl/detail/context_impl.hpp>
 #include <CL/sycl/info/info_desc.hpp>
 
 __SYCL_INLINE namespace cl {
@@ -19,11 +20,12 @@ template <info::context param> struct get_context_info {
   using RetType =
       typename info::param_traits<info::context, param>::return_type;
 
-  static RetType get(RT::PiContext ctx) {
+  static RetType get(RT::PiContext ctx, const plugin &Plugin) {
     RetType Result = 0;
     // TODO catch an exception and put it to list of asynchronous exceptions
-    PI_CALL(piContextGetInfo)(ctx, pi::cast<pi_context_info>(param),
-                              sizeof(Result), &Result, nullptr);
+    Plugin.call<PiApiKind::piContextGetInfo>(ctx,
+                                             pi::cast<pi_context_info>(param),
+                                             sizeof(Result), &Result, nullptr);
     return Result;
   }
 };

sycl/include/CL/sycl/detail/device_impl.hpp

@@ -23,16 +23,21 @@ namespace detail {
 
 // Forward declaration
 class platform_impl;
-class platform_impl_pi;
+using PlatformImplPtr = std::shared_ptr<platform_impl>;
 
 // TODO: Make code thread-safe
 class device_impl {
 public:
   /// Constructs a SYCL device instance as a host device.
   device_impl();
+
   /// Constructs a SYCL device instance using the provided
   /// PI device instance.
-  explicit device_impl(RT::PiDevice Device);
+  explicit device_impl(RT::PiDevice Device, PlatformImplPtr Platform);
+
+  /// Constructs a SYCL device instance using the provided
+  /// PI device instance.
+  explicit device_impl(RT::PiDevice Device, const plugin &Plugin);
 
   ~device_impl();
 
@@ -100,6 +105,9 @@ class device_impl {
   /// @return The associated SYCL platform.
   platform get_platform() const;
 
+  /// @return the associated plugin with this device.
+  const plugin &getPlugin() const { return MPlatform->getPlugin(); }
+
   /// Check SYCL extension support by device
   ///
   /// @param ExtensionName is a name of queried extension.
@@ -165,7 +173,7 @@ class device_impl {
     }
     return get_device_info<
         typename info::param_traits<info::device, param>::return_type,
-        param>::get(this->getHandleRef());
+        param>::get(this->getHandleRef(), this->getPlugin());
   }
 
   /// Check if affinity partitioning by specified domain is supported by device
@@ -176,10 +184,13 @@ class device_impl {
   is_affinity_supported(info::partition_affinity_domain AffinityDomain) const;
 
 private:
+  explicit device_impl(RT::PiDevice Device, PlatformImplPtr Platform,
+                       const plugin &Plugin);
   RT::PiDevice MDevice = 0;
   RT::PiDeviceType MType;
   bool MIsRootDevice = false;
   bool MIsHostDevice;
+  PlatformImplPtr MPlatform;
 }; // class device_impl
 
 } // namespace detail