[SYCL] Using a single call to Plugin, and populating a Plugin

datastructure with all function pointers. Extension to this will allow
us to bind multiple plugins.

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

Author: garimagu

sycl/include/CL/sycl/detail/pi.h

@@ -377,6 +377,16 @@ typedef _pi_image_desc     pi_image_desc;
 // TODO: describe interfaces in Doxygen format
 //
 
+struct _pi_plugin;
+typedef _pi_plugin pi_plugin;
+
+// PI Plugin Initialise.
+// Must be implemented by a plugin.
+// Plugin will read the PIVersion,
+// populate the PluginVersion and update targets field and populate the PIFunctionTable with the function pointers for the APIs supported by PIVersion.
+// The pointers are in a predetermined order in pi.def file. 
+pi_result piPluginInit(pi_plugin *plugin_info);
+
 //
 // Platform
 //
@@ -903,6 +913,19 @@ pi_result piEnqueueMemUnmap(
   const pi_event * event_wait_list,
   pi_event *       event);
 
+struct _pi_plugin{
+  // PI version supported by host passed to the plugin. The Plugin this
+  // way knows the number of APIs it can write into the PIFunctionTable.
+  const char PiVersion[4] = "1.1";
+  char PluginVersion[4] = "1.1"; // Plugin edits this.
+  // TODO: what is this field for?
+  char *Targets;
+  struct FunctionPointers {
+#define _PI_API(api) decltype(::api) *api;
+#include <CL/sycl/detail/pi.def>
+  } PiFunctionTable;
+};
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus

sycl/include/CL/sycl/detail/pi.hpp

@@ -17,6 +17,11 @@
 #include <cassert>
 #include <string>
 
+namespace cl {
+namespace sycl {
+namespace detail {
+namespace pi {
+
 // Function to load the shared library
 // Implementation is OS dependent.
 void *loadOsLibrary(const std::string &Library);
@@ -25,10 +30,6 @@ void *loadOsLibrary(const std::string &Library);
 // library, implementation is OS dependent.
 void *getOsLibraryFuncAddress(void *Library, const std::string &FunctionName);
 
-namespace cl {
-namespace sycl {
-namespace detail {
-namespace pi {
 // For selection of SYCL RT back-end, now manually through the "SYCL_BE"
 // environment variable.
 //
@@ -80,8 +81,11 @@ void assertion(bool Condition, const char *Message = nullptr);
 template <class To, class From> To cast(From value);
 
 // Forward declarations of the PI dispatch entries.
-#define _PI_API(api) __SYCL_EXPORTED extern decltype(::api) *(api);
-#include <CL/sycl/detail/pi.def>
+//#define _PI_API(api) __SYCL_EXPORTED extern decltype(::api) *(api);
+//#include <CL/sycl/detail/pi.def>
+
+// Holds the PluginInformation for the plugin that is bound.
+extern pi_plugin PluginInformation;
 
 // Performs PI one-time initialization.
 void initialize();
@@ -163,7 +167,9 @@ namespace RT = cl::sycl::detail::pi;
 
 #define PI_ASSERT(cond, msg) RT::assertion((cond), "assert: " msg);
 
-#define PI_TRACE(func) RT::Trace<decltype(func)>(func, #func)
+#define PI_TRACE(func) RT::Trace<decltype(func)>(RT::PluginInformation.func, #func)
+
+#define PI_TRACE_ONLY(func) RT::Trace<decltype(func)>(func, #func)
 
 // Use this macro to initialize the Plugin, call the API, do the trace 
 // and the check for no errors.

sycl/plugins/opencl/pi_opencl.cpp

@@ -20,6 +20,7 @@
     return cast<pi_result>(reterr);                                            \
   }
 
+const char SupportedVersion[] = "1.1";
 // Want all the needed casts be explicit, do not define conversion operators.
 template <class To, class From> To cast(From value) {
   // TODO: see if more sanity checks are possible.
@@ -452,6 +453,7 @@ pi_result OCL(piEnqueueMemBufferMap)(
   return ret_err;
 }
 
+/*
 // TODO: Remove the 'OclPtr' extension used with the PI_APIs.
 // Forward calls to OpenCL RT.
 #define _PI_CL(pi_api, ocl_api)                                                \
@@ -539,4 +541,105 @@ _PI_CL(piEnqueueMemBufferMap, OCL(piEnqueueMemBufferMap))
 _PI_CL(piEnqueueMemUnmap, clEnqueueUnmapMemObject)
 
 #undef _PI_CL
+*/
+
+pi_result piPluginInit(pi_plugin *PluginInit) {
+  strcpy(PluginInit->PluginVersion, SupportedVersion);
+  int CompareVersions = strcmp(PluginInit->PiVersion, SupportedVersion);
+  if (CompareVersions < 0) {
+    // PI interface supports lower version of PI.
+    assert(false && "incompatible versions.!!\n");
+    return PI_INVALID_OPERATION;
+  } else {
+    // PI interface supports higher version or the same version.
+
+#define _PI_CL(pi_api, ocl_api)                                                \
+  (PluginInit->PiFunctionTable).pi_api = (decltype(&::pi_api))(&ocl_api);
+
+    // Platform
+    _PI_CL(piPlatformsGet, OCL(piPlatformsGet))
+    _PI_CL(piPlatformGetInfo, clGetPlatformInfo)
+    // Device
+    _PI_CL(piDevicesGet, OCL(piDevicesGet))
+    _PI_CL(piDeviceGetInfo, clGetDeviceInfo)
+    _PI_CL(piDevicePartition, clCreateSubDevices)
+    _PI_CL(piDeviceRetain, clRetainDevice)
+    _PI_CL(piDeviceRelease, clReleaseDevice)
+    _PI_CL(piextDeviceSelectBinary, OCL(piextDeviceSelectBinary))
+    _PI_CL(piextGetDeviceFunctionPointer, OCL(piextGetDeviceFunctionPointer))
+    // Context
+    _PI_CL(piContextCreate, OCL(piContextCreate))
+    _PI_CL(piContextGetInfo, clGetContextInfo)
+    _PI_CL(piContextRetain, clRetainContext)
+    _PI_CL(piContextRelease, clReleaseContext)
+    // Queue
+    _PI_CL(piQueueCreate, OCL(piQueueCreate))
+    _PI_CL(piQueueGetInfo, clGetCommandQueueInfo)
+    _PI_CL(piQueueFinish, clFinish)
+    _PI_CL(piQueueRetain, clRetainCommandQueue)
+    _PI_CL(piQueueRelease, clReleaseCommandQueue)
+    // Memory
+    _PI_CL(piMemBufferCreate, OCL(piMemBufferCreate))
+    _PI_CL(piMemImageCreate, OCL(piMemImageCreate))
+    _PI_CL(piMemGetInfo, clGetMemObjectInfo)
+    _PI_CL(piMemImageGetInfo, clGetImageInfo)
+    _PI_CL(piMemRetain, clRetainMemObject)
+    _PI_CL(piMemRelease, clReleaseMemObject)
+    _PI_CL(piMemBufferPartition, OCL(piMemBufferPartition))
+    // Program
+    _PI_CL(piProgramCreate, OCL(piProgramCreate))
+    _PI_CL(piclProgramCreateWithSource, OCL(piclProgramCreateWithSource))
+    _PI_CL(piclProgramCreateWithBinary, OCL(piclProgramCreateWithBinary))
+    _PI_CL(piProgramGetInfo, clGetProgramInfo)
+    _PI_CL(piProgramCompile, clCompileProgram)
+    _PI_CL(piProgramBuild, clBuildProgram)
+    _PI_CL(piProgramLink, OCL(piProgramLink))
+    _PI_CL(piProgramGetBuildInfo, clGetProgramBuildInfo)
+    _PI_CL(piProgramRetain, clRetainProgram)
+    _PI_CL(piProgramRelease, clReleaseProgram)
+    // Kernel
+    _PI_CL(piKernelCreate, OCL(piKernelCreate))
+    _PI_CL(piKernelSetArg, clSetKernelArg)
+    _PI_CL(piKernelGetInfo, clGetKernelInfo)
+    _PI_CL(piKernelGetGroupInfo, clGetKernelWorkGroupInfo)
+    _PI_CL(piKernelGetSubGroupInfo, clGetKernelSubGroupInfo)
+    _PI_CL(piKernelRetain, clRetainKernel)
+    _PI_CL(piKernelRelease, clReleaseKernel)
+    // Event
+    _PI_CL(piEventCreate, OCL(piEventCreate))
+    _PI_CL(piEventGetInfo, clGetEventInfo)
+    _PI_CL(piEventGetProfilingInfo, clGetEventProfilingInfo)
+    _PI_CL(piEventsWait, clWaitForEvents)
+    _PI_CL(piEventSetCallback, clSetEventCallback)
+    _PI_CL(piEventSetStatus, clSetUserEventStatus)
+    _PI_CL(piEventRetain, clRetainEvent)
+    _PI_CL(piEventRelease, clReleaseEvent)
+    // Sampler
+    _PI_CL(piSamplerCreate, OCL(piSamplerCreate))
+    _PI_CL(piSamplerGetInfo, clGetSamplerInfo)
+    _PI_CL(piSamplerRetain, clRetainSampler)
+    _PI_CL(piSamplerRelease, clReleaseSampler)
+    // Queue commands
+    _PI_CL(piEnqueueKernelLaunch, clEnqueueNDRangeKernel)
+    _PI_CL(piEnqueueNativeKernel, clEnqueueNativeKernel)
+    _PI_CL(piEnqueueEventsWait, clEnqueueMarkerWithWaitList)
+    _PI_CL(piEnqueueMemBufferRead, clEnqueueReadBuffer)
+    _PI_CL(piEnqueueMemBufferReadRect, clEnqueueReadBufferRect)
+    _PI_CL(piEnqueueMemBufferWrite, clEnqueueWriteBuffer)
+    _PI_CL(piEnqueueMemBufferWriteRect, clEnqueueWriteBufferRect)
+    _PI_CL(piEnqueueMemBufferCopy, clEnqueueCopyBuffer)
+    _PI_CL(piEnqueueMemBufferCopyRect, clEnqueueCopyBufferRect)
+    _PI_CL(piEnqueueMemBufferFill, clEnqueueFillBuffer)
+    _PI_CL(piEnqueueMemImageRead, clEnqueueReadImage)
+    _PI_CL(piEnqueueMemImageWrite, clEnqueueWriteImage)
+    _PI_CL(piEnqueueMemImageCopy, clEnqueueCopyImage)
+    _PI_CL(piEnqueueMemImageFill, clEnqueueFillImage)
+    _PI_CL(piEnqueueMemBufferMap, OCL(piEnqueueMemBufferMap))
+    _PI_CL(piEnqueueMemUnmap, clEnqueueUnmapMemObject)
+
+#undef _PI_CL
+  }
+  return PI_SUCCESS;
 }
+
+} // end extern 'C'

sycl/source/detail/linux_pi.cpp

@@ -1,6 +1,11 @@
 #include <dlfcn.h>
 #include <string>
 
+namespace cl {
+namespace sycl {
+namespace detail {
+namespace pi {
+
 void *loadOsLibrary(const std::string &PluginPath) {
   // TODO: Check if the option RTLD_NOW is correct. Explore using
   // RTLD_DEEPBIND option when there are multiple plugins.
@@ -10,3 +15,8 @@ void *loadOsLibrary(const std::string &PluginPath) {
 void *getOsLibraryFuncAddress(void *Library, const std::string &FunctionName) {
   return dlsym(Library, FunctionName.c_str());
 }
+
+} // namespace pi
+} // namespace detail
+} // namespace sycl
+} // namespace cl

sycl/source/detail/pi.cpp

@@ -48,8 +48,10 @@ bool useBackend(Backend TheBackend) {
 
 // Definitions of the PI dispatch entries, they will be initialized
 // at their first use with piInitialize.
-#define _PI_API(api) decltype(::api) *api = nullptr;
-#include <CL/sycl/detail/pi.def>
+//#define _PI_API(api) decltype(::api) *api = nullptr;
+//#include <CL/sycl/detail/pi.def>
+
+pi_plugin PluginInformation;
 
 // Find the plugin at the appropriate location and return the location.
 // TODO: Change the function appropriately when there are multiple plugins.
@@ -74,18 +76,27 @@ void *loadPlugin(const std::string &PluginPath) {
 // needs to setup infrastructure to route PI_CALLs to the appropriate plugins.
 // Currently, we bind to a singe plugin.
 bool bindPlugin(void *Library) {
-#define STRINGIZE(x) #x
-
-#define _PI_API(api)                                                           \
-  decltype(&api) api##_ptr = ((decltype(&api))(                                \
-      getOsLibraryFuncAddress(Library, STRINGIZE(api##OclPtr))));              \
-  if (!api##_ptr)                                                              \
-    return false;                                                              \
-  api = *api##_ptr;
-#include <CL/sycl/detail/pi.def>
-
-#undef STRINGIZE
-#undef _PI_API
+
+  decltype(::piPluginInit) *PluginInitializeFunction =
+      (decltype(&::piPluginInit))(
+          getOsLibraryFuncAddress(Library, "piPluginInit"));
+  // FuncTable is a list of all Interface Function pointers, where each
+  // Interface Function is located at a predetermined offset.
+  int err = PluginInitializeFunction(&PluginInformation);
+ 
+  // TODO: Check err code. 
+ 
+  // At the predetermined api's offset from the FunctionTable, the function
+  // pointer for "api" is stored. So we dereference the location to get the
+  // function pointer.
+
+//#define _PI_API(api)                                                   \
+  api = ((decltype(api))(PluginInformation.PiFunctionTable.api));
+
+//#include <CL/sycl/detail/pi.def>
+
+// #undef _PI_API
+
   return true;
 }
 

sycl/source/detail/windows_pi.cpp

@@ -2,10 +2,20 @@
 #include <winreg.h>
 #include <string>
 
+namespace cl {
+namespace sycl {
+namespace detail {
+namespace pi {
+
 void *loadOsLibrary(const std::string &PluginPath) {
   return (void *)LoadLibraryA(PluginPath.c_str());
 }
 
 void *getOsLibraryFuncAddress(void *Library, const std::string &FunctionName) {
   return GetProcAddress((HMODULE)Library, FunctionName.c_str());
 }
+
+} // namespace pi
+} // namespace detail
+} // namespace sycl
+} // namespace cl