[SYCL] removal of dependency on pi.hpp file in opencl

garimagu · garimagu · commit 844eccbda06a · 2019-10-14T16:49:33.000-07:00
plugin:pi_opencl.cpp
- changed the dependency to pi.h, which contains declarations and no
other defined macros or defintions.

Signed-off-by: Garima Gupta &lt;garima.gupta@intel.com&gt;
diff --git a/sycl/include/CL/sycl/detail/pi.hpp b/sycl/include/CL/sycl/detail/pi.hpp
@@ -184,7 +184,7 @@ namespace RT = cl::sycl::detail::pi;
 // Want all the needed casts be explicit, do not define conversion operators.
 template <class To, class From> To pi::cast(From value) {
   // TODO: see if more sanity checks are possible.
-  assert(sizeof(From) == sizeof(To) && "cast failed size check");
+  PI_ASSERT(sizeof(From) == sizeof(To), "cast failed size check");
   return (To)(value);
 }
 
diff --git a/sycl/plugins/opencl/CMakeLists.txt b/sycl/plugins/opencl/CMakeLists.txt
@@ -10,7 +10,7 @@
 #TODO: Currently, the pi.hpp header is common between sycl and plugin library sources. 
 #This can be changed by copying the pi.hpp file in the plugins project.
 add_library(pi_opencl SHARED
-  "${sycl_inc_dir}/CL/sycl/detail/pi.hpp"
+  "${sycl_inc_dir}/CL/sycl/detail/pi.h"
   "pi_opencl.cpp"
   )
 
diff --git a/sycl/plugins/opencl/pi_opencl.cpp b/sycl/plugins/opencl/pi_opencl.cpp
@@ -6,19 +6,26 @@
 //
 //===----------------------------------------------------------------------===//
 #include "CL/opencl.h"
-#include <CL/sycl/detail/pi.hpp>
+#include <CL/sycl/detail/pi.h>
 #include <cassert>
 #include <cstring>
-
-namespace PI = cl::sycl::detail::pi;
-
-#define CHECK_ERR_SET_NULL_RET(err,ptr,reterr) \
-  if (err != CL_SUCCESS) { \
-    if (ptr != nullptr) \
-      *ptr = nullptr; \
-    return PI::cast<pi_result>(reterr); \
+#include <string>
+#include <vector>
+
+#define CHECK_ERR_SET_NULL_RET(err, ptr, reterr)                               \
+  if (err != CL_SUCCESS) {                                                     \
+    if (ptr != nullptr)                                                        \
+      *ptr = nullptr;                                                          \
+    return cast<pi_result>(reterr);                                            \
   }
 
+// 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.
+  static_assert(sizeof(From) == sizeof(To) && "cast failed size check");
+  return (To)(value);
+}
+
 extern "C" {
 
 // Convenience macro makes source code search easier
@@ -27,35 +34,35 @@ extern "C" {
 // Example of a PI interface that does not map exactly to an OpenCL one.
 pi_result OCL(piPlatformsGet)(pi_uint32 num_entries, pi_platform *platforms,
                               pi_uint32 *num_platforms) {
-  cl_int result = clGetPlatformIDs(PI::cast<cl_uint>(num_entries),
-                                   PI::cast<cl_platform_id *>(platforms),
-                                   PI::cast<cl_uint *>(num_platforms));
+  cl_int result = clGetPlatformIDs(cast<cl_uint>(num_entries),
+                                   cast<cl_platform_id *>(platforms),
+                                   cast<cl_uint *>(num_platforms));
 
   // Absorb the CL_PLATFORM_NOT_FOUND_KHR and just return 0 in num_platforms
   if (result == CL_PLATFORM_NOT_FOUND_KHR) {
     assert(num_platforms != 0);
     *num_platforms = 0;
     result = PI_SUCCESS;
   }
-  return PI::cast<pi_result>(result);
+  return static_cast<pi_result>(result);
 }
 
 // Example of a PI interface that does not map exactly to an OpenCL one.
 pi_result OCL(piDevicesGet)(pi_platform platform, pi_device_type device_type,
                             pi_uint32 num_entries, pi_device *devices,
                             pi_uint32 *num_devices) {
   cl_int result = clGetDeviceIDs(
-      PI::cast<cl_platform_id>(platform), PI::cast<cl_device_type>(device_type),
-      PI::cast<cl_uint>(num_entries), PI::cast<cl_device_id *>(devices),
-      PI::cast<cl_uint *>(num_devices));
+      cast<cl_platform_id>(platform), cast<cl_device_type>(device_type),
+      cast<cl_uint>(num_entries), cast<cl_device_id *>(devices),
+      cast<cl_uint *>(num_devices));
 
   // Absorb the CL_DEVICE_NOT_FOUND and just return 0 in num_devices
   if (result == CL_DEVICE_NOT_FOUND) {
     assert(num_devices != 0);
     *num_devices = 0;
     result = PI_SUCCESS;
   }
-  return PI::cast<pi_result>(result);
+  return cast<pi_result>(result);
 }
 
 pi_result OCL(piextDeviceSelectBinary)(
@@ -82,69 +89,67 @@ pi_result OCL(piQueueCreate)(pi_context context, pi_device device,
 
   cl_platform_id curPlatform;
   cl_int ret_err =
-      clGetDeviceInfo(PI::cast<cl_device_id>(device), CL_DEVICE_PLATFORM,
+      clGetDeviceInfo(cast<cl_device_id>(device), CL_DEVICE_PLATFORM,
                       sizeof(cl_platform_id), &curPlatform, NULL);
 
-  CHECK_ERR_SET_NULL_RET(ret_err,queue,ret_err);
+  CHECK_ERR_SET_NULL_RET(ret_err, queue, ret_err);
 
   size_t platVerSize;
   ret_err = clGetPlatformInfo(curPlatform, CL_PLATFORM_VERSION, 0, NULL,
                               &platVerSize);
 
-  CHECK_ERR_SET_NULL_RET(ret_err,queue,ret_err);
+  CHECK_ERR_SET_NULL_RET(ret_err, queue, ret_err);
 
   std::string platVer(platVerSize, '\0');
   ret_err = clGetPlatformInfo(curPlatform, CL_PLATFORM_VERSION, platVerSize,
                               &platVer.front(), NULL);
 
-  CHECK_ERR_SET_NULL_RET(ret_err,queue,ret_err);
+  CHECK_ERR_SET_NULL_RET(ret_err, queue, ret_err);
 
   if (platVer.find("OpenCL 1.0") != std::string::npos ||
       platVer.find("OpenCL 1.1") != std::string::npos ||
       platVer.find("OpenCL 1.2") != std::string::npos) {
-    *queue = PI::cast<pi_queue>(clCreateCommandQueue(
-        PI::cast<cl_context>(context), PI::cast<cl_device_id>(device),
-        PI::cast<cl_command_queue_properties>(properties), &ret_err));
-    return PI::cast<pi_result>(ret_err);
+    *queue = cast<pi_queue>(clCreateCommandQueue(
+        cast<cl_context>(context), cast<cl_device_id>(device),
+        cast<cl_command_queue_properties>(properties), &ret_err));
+    return cast<pi_result>(ret_err);
   }
 
   cl_queue_properties CreationFlagProperties[] = {
-      CL_QUEUE_PROPERTIES, PI::cast<cl_command_queue_properties>(properties),
-      0};
-  *queue = PI::cast<pi_queue>(clCreateCommandQueueWithProperties(
-      PI::cast<cl_context>(context), PI::cast<cl_device_id>(device),
+      CL_QUEUE_PROPERTIES, cast<cl_command_queue_properties>(properties), 0};
+  *queue = cast<pi_queue>(clCreateCommandQueueWithProperties(
+      cast<cl_context>(context), cast<cl_device_id>(device),
       CreationFlagProperties, &ret_err));
-  return PI::cast<pi_result>(ret_err);
+  return cast<pi_result>(ret_err);
 }
 
 pi_result OCL(piProgramCreate)(pi_context context, const void *il,
                                size_t length, pi_program *res_program) {
 
   size_t deviceCount;
 
-  cl_int ret_err = clGetContextInfo(PI::cast<cl_context>(context),
+  cl_int ret_err = clGetContextInfo(cast<cl_context>(context),
                                     CL_CONTEXT_DEVICES, 0, NULL, &deviceCount);
 
   std::vector<cl_device_id> devicesInCtx(deviceCount);
- 
-   
+
   if (ret_err != CL_SUCCESS || deviceCount < 1) {
     if (res_program != nullptr)
       *res_program = nullptr;
-    return PI::cast<pi_result>(CL_INVALID_CONTEXT);
+    return cast<pi_result>(CL_INVALID_CONTEXT);
   }
 
-  ret_err = clGetContextInfo(PI::cast<cl_context>(context), CL_CONTEXT_DEVICES,
+  ret_err = clGetContextInfo(cast<cl_context>(context), CL_CONTEXT_DEVICES,
                              deviceCount * sizeof(cl_device_id),
                              devicesInCtx.data(), NULL);
 
-  CHECK_ERR_SET_NULL_RET(ret_err,res_program,CL_INVALID_CONTEXT);
+  CHECK_ERR_SET_NULL_RET(ret_err, res_program, CL_INVALID_CONTEXT);
 
   cl_platform_id curPlatform;
   ret_err = clGetDeviceInfo(devicesInCtx[0], CL_DEVICE_PLATFORM,
                             sizeof(cl_platform_id), &curPlatform, NULL);
 
-  CHECK_ERR_SET_NULL_RET(ret_err,res_program,CL_INVALID_CONTEXT);
+  CHECK_ERR_SET_NULL_RET(ret_err, res_program, CL_INVALID_CONTEXT);
 
   size_t devVerSize;
   ret_err =
@@ -153,16 +158,16 @@ pi_result OCL(piProgramCreate)(pi_context context, const void *il,
   ret_err = clGetPlatformInfo(curPlatform, CL_PLATFORM_VERSION, devVerSize,
                               &devVer.front(), NULL);
 
-  CHECK_ERR_SET_NULL_RET(ret_err,res_program,CL_INVALID_CONTEXT);
+  CHECK_ERR_SET_NULL_RET(ret_err, res_program, CL_INVALID_CONTEXT);
 
   pi_result err = PI_SUCCESS;
   if (devVer.find("OpenCL 1.0") == std::string::npos &&
       devVer.find("OpenCL 1.1") == std::string::npos &&
       devVer.find("OpenCL 1.2") == std::string::npos &&
       devVer.find("OpenCL 2.0") == std::string::npos) {
     if (res_program != nullptr)
-      *res_program = PI::cast<pi_program>(clCreateProgramWithIL(
-          PI::cast<cl_context>(context), il, length, PI::cast<cl_int *>(&err)));
+      *res_program = cast<pi_program>(clCreateProgramWithIL(
+          cast<cl_context>(context), il, length, cast<cl_int *>(&err)));
     return err;
   }
 
@@ -177,7 +182,7 @@ pi_result OCL(piProgramCreate)(pi_context context, const void *il,
       extStr.find("cl_khr_il_program") == std::string::npos) {
     if (res_program != nullptr)
       *res_program = nullptr;
-    return PI::cast<pi_result>(CL_INVALID_CONTEXT);
+    return cast<pi_result>(CL_INVALID_CONTEXT);
   }
 
   using apiFuncT =
@@ -188,10 +193,10 @@ pi_result OCL(piProgramCreate)(pi_context context, const void *il,
 
   assert(funcPtr != nullptr);
   if (res_program != nullptr)
-    *res_program = PI::cast<pi_program>(funcPtr(
-        PI::cast<cl_context>(context), il, length, PI::cast<cl_int *>(&err)));
+    *res_program = cast<pi_program>(
+        funcPtr(cast<cl_context>(context), il, length, cast<cl_int *>(&err)));
   else
-	err = PI_INVALID_VALUE;
+    err = PI_INVALID_VALUE;
 
   return err;
 }
@@ -221,9 +226,9 @@ pi_result OCL(piSamplerCreate)(pi_context context,
   }
 
   // Always call OpenCL 1.0 API
-  *result_sampler = PI::cast<pi_sampler>(clCreateSampler(
-      PI::cast<cl_context>(context), normalizedCoords, addressingMode,
-      filterMode, PI::cast<cl_int *>(&error_code)));
+  *result_sampler = cast<pi_sampler>(
+      clCreateSampler(cast<cl_context>(context), normalizedCoords,
+                      addressingMode, filterMode, cast<cl_int *>(&error_code)));
   return error_code;
 }
 
@@ -233,11 +238,11 @@ pi_result OCL(piextGetDeviceFunctionPointer)(pi_device device,
                                              pi_uint64 *function_pointer_ret) {
   pi_platform platform;
   cl_int ret_err =
-      clGetDeviceInfo(PI::cast<cl_device_id>(device), PI_DEVICE_INFO_PLATFORM,
+      clGetDeviceInfo(cast<cl_device_id>(device), PI_DEVICE_INFO_PLATFORM,
                       sizeof(platform), &platform, nullptr);
 
   if (ret_err != CL_SUCCESS) {
-    return PI::cast<pi_result>(ret_err);
+    return cast<pi_result>(ret_err);
   }
 
   using FuncT =
@@ -246,8 +251,7 @@ pi_result OCL(piextGetDeviceFunctionPointer)(pi_device device,
   // TODO: add check that device supports corresponding extension
   FuncT func_ptr =
       reinterpret_cast<FuncT>(clGetExtensionFunctionAddressForPlatform(
-          PI::cast<cl_platform_id>(platform),
-          "clGetDeviceFunctionPointerINTEL"));
+          cast<cl_platform_id>(platform), "clGetDeviceFunctionPointerINTEL"));
   // TODO: once we have check that device supports corresponding extension,
   // we can insert an assertion that func_ptr is not nullptr. For now, let's
   // just return an error if failed to query such function
@@ -261,15 +265,15 @@ pi_result OCL(piextGetDeviceFunctionPointer)(pi_device device,
     return PI_INVALID_DEVICE;
   }
 
-  return PI::cast<pi_result>(func_ptr(PI::cast<cl_device_id>(device),
-                                      PI::cast<cl_program>(program), func_name,
-                                      function_pointer_ret));
+  return cast<pi_result>(func_ptr(cast<cl_device_id>(device),
+                                  cast<cl_program>(program), func_name,
+                                  function_pointer_ret));
 }
 
 // TODO: Remove the 'OclPtr' extension used with the PI_APIs.
 // Forward calls to OpenCL RT.
 #define _PI_CL(pi_api, ocl_api)                                                \
-  decltype(::pi_api) *pi_api##OclPtr = PI::cast<decltype(&::pi_api)>(&ocl_api);
+  decltype(::pi_api) *pi_api##OclPtr = cast<decltype(&::pi_api)>(&ocl_api);
 
 // Platform
 _PI_CL(piPlatformsGet, OCL(piPlatformsGet))
diff --git a/sycl/source/detail/pi.cpp b/sycl/source/detail/pi.cpp
@@ -38,10 +38,11 @@ std::string platformInfoToString(pi_platform_info info) {
 // Check for manually selected BE at run-time.
 bool useBackend(Backend TheBackend) {
   static const char *GetEnv = std::getenv("SYCL_BE");
-  static const Backend Use = std::map<std::string, Backend>{
-      {"PI_OPENCL", SYCL_BE_PI_OPENCL}, {"PI_OTHER", SYCL_BE_PI_OTHER}
-      // Any other value would yield PI_OPENCL (current default)
-  }[GetEnv ? GetEnv : "PI_OPENCL"];
+  // Current default backend as SYCL_BE_PI_OPENCL
+  // Valid values of GetEnv are "PI_OPENCL" and "PI_OTHER"
+  std::string StringGetEnv = (GetEnv ? GetEnv : "PI_OPENCL");
+  static const Backend Use =
+      (StringGetEnv == "PI_OTHER" ? SYCL_BE_PI_OTHER : SYCL_BE_PI_OPENCL);
   return TheBackend == Use;
 }
 
@@ -53,17 +54,19 @@ bool useBackend(Backend TheBackend) {
 // Find the plugin at the appropriate location and return the location in
 // PluginPath
 // TODO: Change the function appropriately when there are multiple plugins.
-bool findPlugin(std::string &PluginPath) {
+std::string findPlugin() {
   // TODO: Based on final design discussions, change the location where the
   // plugin must be searched; how to identify the plugins etc. Currently the
-  // search is done for libpi_opencl.so file in LD_LIBRARY_PATH env only.
-  PluginPath = PLUGIN_NAME;
-  return true;
+  // search is done for libpi_opencl.so/pi_opencl.dll file in LD_LIBRARY_PATH
+  // env only.
+  return PLUGIN_NAME;
 }
 
 // Load the Plugin by calling the OS dependent library loading call.
 // Return the handle to the Library.
-void *loadPlugin(const std::string &PluginPath) { return loadOsLibrary(PluginPath); }
+void *loadPlugin(const std::string &PluginPath) {
+  return loadOsLibrary(PluginPath);
+}
 
 // Binds all the PI Interface APIs to Plugin Library Function Addresses.
 // TODO: Remove the 'OclPtr' extension to PI_API.
@@ -100,17 +103,20 @@ void initialize() {
     die("Unknown SYCL_BE");
   }
 
-  std::string PluginPath;
-  if (!findPlugin(PluginPath))
+  std::string PluginPath = findPlugin();
+  if (PluginPath.empty())
     die("Plugin Not Found.");
 
   void *Library = loadPlugin(PluginPath);
   if (!Library) {
-    die("Failed to load plugin. Check if plugin is present.");
+    std::string Message =
+        "Check if plugin is present. Failed to load plugin: " + PluginPath;
+    die(Message.c_str());
   }
 
   if (!bindPlugin(Library)) {
-    die("Failed to bind PI APIs to the plugin.");
+    std::string Message = "Failed to bind PI APIs to the plugin: " + PluginPath;
+    die(Message.c_str());
   }
 
   Initialized = true;
diff --git a/sycl/source/detail/windows_pi.cpp b/sycl/source/detail/windows_pi.cpp
@@ -3,7 +3,6 @@
 #include <string>
 
 void *loadOsLibrary(const std::string &PluginPath) {
-  // TODO: Check if the option RTLD_NOW is correct.
   return (void *)LoadLibraryA(PluginPath.c_str());
 }
 

Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ namespace RT = cl::sycl::detail::pi;`
`184`	`184`	`// Want all the needed casts be explicit, do not define conversion operators.`
`185`	`185`	`template <class To, class From> To pi::cast(From value) {`
`186`	`186`	`// TODO: see if more sanity checks are possible.`
`187`		`- assert(sizeof(From) == sizeof(To) && "cast failed size check");`
	`187`	`+ PI_ASSERT(sizeof(From) == sizeof(To), "cast failed size check");`
`188`	`188`	`return (To)(value);`
`189`	`189`	`}`
`190`	`190`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`#TODO: Currently, the pi.hpp header is common between sycl and plugin library sources.`
`11`	`11`	`#This can be changed by copying the pi.hpp file in the plugins project.`
`12`	`12`	`add_library(pi_opencl SHARED`
`13`		`- "${sycl_inc_dir}/CL/sycl/detail/pi.hpp"`
	`13`	`+ "${sycl_inc_dir}/CL/sycl/detail/pi.h"`
`14`	`14`	`"pi_opencl.cpp"`
`15`	`15`	`)`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`#include <string>`
`4`	`4`
`5`	`5`	`void *loadOsLibrary(const std::string &PluginPath) {`
`6`		`- // TODO: Check if the option RTLD_NOW is correct.`
`7`	`6`	`return (void *)LoadLibraryA(PluginPath.c_str());`
`8`	`7`	`}`
`9`	`8`