[SYCL][CUDA] Code style and cleanup to CUDA support

Signed-off-by: Alexander Johnston <[email protected]>

Author: Alexander Johnston

clang/include/clang/Config/config.h.cmake

@@ -81,7 +81,7 @@
 #cmakedefine01 CLANG_ENABLE_STATIC_ANALYZER
 
 /* Define if we have SYCL PI CUDA support */
-#cmakedefine SYCL_HAVE_PI_CUDA ${SYCL_HAVE_PI_CUDA}
+#cmakedefine01 SYCL_HAVE_PI_CUDA
 
 /* Spawn a new process clang.exe for the CC1 tool invocation, when necessary */
 #cmakedefine01 CLANG_SPAWN_CC1

clang/lib/Frontend/InitPreprocessor.cpp

@@ -1103,9 +1103,6 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
     if (TI.getTriple().isNVPTX()) {
         Builder.defineMacro("__SYCL_NVPTX__", "1");
     }
-
-    if (!getenv("DISABLE_INFER_AS"))
-      Builder.defineMacro("__SYCL_ENABLE_INFER_AS__", "1");
   }
   if (LangOpts.SYCLUnnamedLambda)
     Builder.defineMacro("__SYCL_UNNAMED_LAMBDA__", "1");

sycl/CMakeLists.txt

@@ -142,6 +142,7 @@ set(sycl_inc_dir ${CMAKE_CURRENT_SOURCE_DIR}/include)
 set(sycl_src_dir ${CMAKE_CURRENT_SOURCE_DIR}/source)
 set(sycl_detail_inc_dir ${CMAKE_CURRENT_SOURCE_DIR}/include/CL/sycl/detail)
 set(sycl_detail_src_dir ${CMAKE_CURRENT_SOURCE_DIR}/source/detail)
+set(sycl_plugin_dir ${CMAKE_CURRENT_SOURCE_DIR}/plugins)
 string(TIMESTAMP __SYCL_COMPILER_VERSION "%Y%m%d")
 set(version_header "${sycl_inc_dir}/CL/sycl/version.hpp")
 configure_file("${version_header}.in" "${version_header}")

sycl/include/CL/sycl/context.hpp

@@ -33,10 +33,10 @@ class context {
   /// exceptions.
   ///
   /// @param AsyncHandler is an instance of async_handler.
-  /// @param useCUDAPrimaryContext is a bool determining whether to use the
+  /// @param UseCUDAPrimaryContext is a bool determining whether to use the
   ///        primary context in the CUDA backend.
   explicit context(const async_handler &AsyncHandler = {},
-                   bool useCUDAPrimaryContext = false);
+                   bool UseCUDAPrimaryContext = false);
 
   /// Constructs a SYCL context instance using the provided device.
   ///
@@ -47,10 +47,10 @@ class context {
   ///
   /// @param Device is an instance of SYCL device.
   /// @param AsyncHandler is an instance of async_handler.
-  /// @param useCUDAPrimaryContext is a bool determining whether to use the
+  /// @param UseCUDAPrimaryContext is a bool determining whether to use the
   ///        primary context in the CUDA backend.
   context(const device &Device, async_handler AsyncHandler = {},
-          bool useCUDAPrimaryContext = false);
+          bool UseCUDAPrimaryContext = false);
 
   /// Constructs a SYCL context instance using the provided platform.
   ///
@@ -61,10 +61,10 @@ class context {
   ///
   /// @param Platform is an instance of SYCL platform.
   /// @param AsyncHandler is an instance of async_handler.
-  /// @param useCUDAPrimaryContext is a bool determining whether to use the
+  /// @param UseCUDAPrimaryContext is a bool determining whether to use the
   ///        primary context in the CUDA backend.
   context(const platform &Platform, async_handler AsyncHandler = {},
-          bool useCUDAPrimaryContext = false);
+          bool UseCUDAPrimaryContext = false);
 
   /// Constructs a SYCL context instance using list of devices.
   ///
@@ -76,10 +76,10 @@ class context {
   ///
   /// @param DeviceList is a list of SYCL device instances.
   /// @param AsyncHandler is an instance of async_handler.
-  /// @param useCUDAPrimaryContext is a bool determining whether to use the
+  /// @param UseCUDAPrimaryContext is a bool determining whether to use the
   ///        primary context in the CUDA backend.
   context(const vector_class<device> &DeviceList,
-          async_handler AsyncHandler = {}, bool useCUDAPrimaryContext = false);
+          async_handler AsyncHandler = {}, bool UseCUDAPrimaryContext = false);
 
   /// Constructs a SYCL context instance from OpenCL cl_context.
   ///

sycl/include/CL/sycl/detail/cg.hpp

@@ -177,7 +177,7 @@ class InteropTask {
   std::function<void(cl::sycl::interop_handler)> MFunc;
 
 public:
-  InteropTask(std::function<void(cl::sycl::interop_handler)> Func)
+  InteropTask(function_class<void(cl::sycl::interop_handler)> Func)
       : MFunc(Func) {}
   void call(cl::sycl::interop_handler &h) { MFunc(h); }
 };

sycl/include/CL/sycl/handler.hpp

@@ -773,9 +773,9 @@ class handler {
 #endif
   }
 
-  // Similar to single_task, but passed lambda will be executed on host
-  // dependencies are satisfied on the device.
-  // Functor takes an interop_handler argument
+  /// Invokes a lambda on the host. Dependencies are satisfied on the host.
+  ///
+  /// @param Func is a lambda that is executed on the host
   template <typename FuncT> void interop_task(FuncT Func) {
 
     MInteropTask.reset(new detail::InteropTask(std::move(Func)));

sycl/plugins/cuda/CMakeLists.txt

@@ -17,7 +17,7 @@ set_target_properties(
 add_library(pi_cuda SHARED
   "${sycl_inc_dir}/CL/sycl/detail/pi.h"
   "${sycl_inc_dir}/CL/sycl/detail/pi.hpp"
-  "${sycl_inc_dir}/CL/sycl/detail/pi_cuda.hpp"
+  "pi_cuda.hpp"
   "pi_cuda.cpp"
 )
 

sycl/plugins/cuda/pi_cuda.cpp

@@ -8,7 +8,7 @@
 
 #include <CL/sycl/backend/cuda.hpp>
 #include <CL/sycl/detail/pi.hpp>
-#include <CL/sycl/detail/pi_cuda.hpp>
+#include <pi_cuda.hpp>
 #include <algorithm>
 #include <cassert>
 #include <cuda.h>

sycl/include/CL/sycl/detail/pi_cuda.hpp renamed to sycl/plugins/cuda/pi_cuda.hpp

@@ -13,7 +13,7 @@
 #ifndef PI_CUDA_HPP
 #define PI_CUDA_HPP
 
-#include "pi.h"
+#include "CL/sycl/detail/pi.h"
 #include <array>
 #include <atomic>
 #include <cassert>

sycl/source/CMakeLists.txt

@@ -4,7 +4,6 @@
 #cmake_policy(SET CMP0057 NEW)
 #include(AddLLVM)
 
-
 function(add_sycl_rt_library LIB_NAME)
 
   add_library(${LIB_NAME} SHARED ${ARGN})
@@ -49,6 +48,7 @@ set(SYCL_SOURCES
     "detail/builtins_integer.cpp"
     "detail/builtins_math.cpp"
     "detail/builtins_relational.cpp"
+    "detail/cg.cpp"
     "detail/pi.cpp"
     "detail/common.cpp"
     "detail/config.cpp"
@@ -84,7 +84,6 @@ set(SYCL_SOURCES
     "detail/usm/usm_impl.cpp"
     "detail/util.cpp"
     "accessor.cpp"
-    "cg.cpp"
     "context.cpp"
     "device.cpp"
     "device_selector.cpp"

sycl/source/context.cpp

@@ -24,21 +24,21 @@
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
-context::context(const async_handler &AsyncHandler, bool usePrimaryContext)
+context::context(const async_handler &AsyncHandler, bool UsePrimaryContext)
     : context(default_selector().select_device(), AsyncHandler,
-              usePrimaryContext) {}
+              UsePrimaryContext) {}
 
 context::context(const device &Device, async_handler AsyncHandler,
-                 bool usePrimaryContext)
+                 bool UsePrimaryContext)
     : context(vector_class<device>(1, Device), AsyncHandler,
-              usePrimaryContext) {}
+              UsePrimaryContext) {}
 
 context::context(const platform &Platform, async_handler AsyncHandler,
-                 bool usePrimaryContext)
-    : context(Platform.get_devices(), AsyncHandler, usePrimaryContext) {}
+                 bool UsePrimaryContext)
+    : context(Platform.get_devices(), AsyncHandler, UsePrimaryContext) {}
 
 context::context(const vector_class<device> &DeviceList,
-                 async_handler AsyncHandler, bool usePrimaryContext) {
+                 async_handler AsyncHandler, bool UsePrimaryContext) {
   if (DeviceList.empty()) {
     throw invalid_parameter_error("DeviceList is empty.");
   }
@@ -48,7 +48,7 @@ context::context(const vector_class<device> &DeviceList,
   if (NonHostDeviceIter == DeviceList.end())
     impl =
         std::make_shared<detail::context_impl>(DeviceList[0], AsyncHandler,
-                                               usePrimaryContext);
+                                               UsePrimaryContext);
   else {
     const device &NonHostDevice = *NonHostDeviceIter;
     const auto &NonHostPlatform = NonHostDevice.get_platform().get();
@@ -62,7 +62,7 @@ context::context(const vector_class<device> &DeviceList,
           "Can't add devices across platforms to a single context.");
     else
       impl = std::make_shared<detail::context_impl>(DeviceList, AsyncHandler,
-                                                    usePrimaryContext);
+                                                    UsePrimaryContext);
   }
 }
 context::context(cl_context ClContext, async_handler AsyncHandler) {

sycl/source/detail/accessor_impl.cpp

@@ -15,9 +15,8 @@ namespace sycl {
 namespace detail {
 
 AccessorImplHost::~AccessorImplHost() {
-  if (MBlockedCmd) {
+  if (MBlockedCmd)
     detail::Scheduler::getInstance().releaseHostAccessor(this);
-  }
 }
 
 void addHostAccessorAndWait(Requirement *Req) {

sycl/source/cg.cpp renamed to sycl/source/detail/cg.cpp

@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "CL/sycl/detail/cg.hpp"
-#include <CL/sycl/detail/scheduler/scheduler.hpp>
-#include <CL/sycl/detail/scheduler/commands.hpp>
 #include <CL/sycl/detail/memory_manager.hpp>
-#include <CL/sycl/detail/queue_impl.hpp>
+#include <detail/queue_impl.hpp>
+#include <detail/scheduler/commands.hpp>
+#include <detail/scheduler/scheduler.hpp>
 
 
 #include <memory>
@@ -34,4 +34,4 @@ cl_mem interop_handler::getMemImpl(detail::Requirement* Req) const {
   }
 
 }  // sycl
-}  // sycl
+}  // cl

sycl/source/detail/scheduler/scheduler.hpp

@@ -86,7 +86,7 @@ class Scheduler {
   // operations with the same memory object that have side effects are blocked
   // until releaseHostAccessor is called. Returns an event which indicates
   // when these nodes are completed and host accessor is ready for using.
-  EventImplPtr addHostAccessor(Requirement *Req, const bool destructor = false);
+  EventImplPtr addHostAccessor(Requirement *Req, const bool Destructor = false);
 
   // Unblocks operations with the memory object.
   void releaseHostAccessor(Requirement *Req);

sycl/source/device_selector.cpp

@@ -38,16 +38,16 @@ int default_selector::operator()(const device &dev) const {
     std::string backend = (SYCL_BE ? SYCL_BE : "");
     // Taking the version information from the platform gives us more useful
     // information than the driver_version of the device.
-    const platform Platform = dev.get_info<info::device::platform>();
-    const std::string PlatformVersion =
-        Platform.get_info<info::platform::version>();;
+    const platform platform = dev.get_info<info::device::platform>();
+    const std::string platformVersion =
+        platform.get_info<info::platform::version>();;
     // If using PI_CUDA, don't accept a non-CUDA device
-    if (PlatformVersion.find("CUDA") == std::string::npos &&
+    if (platformVersion.find("CUDA") == std::string::npos &&
         backend == "PI_CUDA") {
       return -1;
     }
     // If using PI_OPENCL, don't accept a non-OpenCL device
-    if (PlatformVersion.find("OpenCL") == std::string::npos &&
+    if (platformVersion.find("OpenCL") == std::string::npos &&
         backend == "PI_OPENCL") {
       return -1;
     }

sycl/unittests/pi/cuda/CMakeLists.txt

@@ -21,4 +21,5 @@ target_include_directories(
   ${CUDA_INCLUDE_DIRS} 
   ${sycl_detail_inc_dir}
   ${sycl_inc_dir}
+  "${sycl_plugin_dir}/cuda/"
 )