Merge branch 'sycl' into remove-event-callback

Author: Ruyk

llvm/test/Bindings/Go/go.test

@@ -2,4 +2,3 @@
 
 ; REQUIRES: shell
 ; UNSUPPORTED: asan, ubsan, msan
-; XFAIL: *

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

@@ -133,9 +133,16 @@ typedef enum {
 // make the translation to OpenCL transparent.
 //
 typedef enum : pi_uint64 {
-  PI_DEVICE_TYPE_CPU = CL_DEVICE_TYPE_CPU,
-  PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU,
-  PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR
+  PI_DEVICE_TYPE_DEFAULT =
+      CL_DEVICE_TYPE_DEFAULT, ///< The default device available in the PI
+                              ///< plugin.
+  PI_DEVICE_TYPE_ALL =
+      CL_DEVICE_TYPE_ALL, ///< All devices available in the PI plugin.
+  PI_DEVICE_TYPE_CPU =
+      CL_DEVICE_TYPE_CPU, ///< A PI device that is the host processor.
+  PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU, ///< A PI device that is a GPU.
+  PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR ///< A PI device that is a
+                                                  ///< dedicated accelerator.
 } _pi_device_type;
 
 typedef enum {
@@ -224,6 +231,7 @@ typedef enum {
   PI_DEVICE_INFO_BUILT_IN_KERNELS = CL_DEVICE_BUILT_IN_KERNELS,
   PI_DEVICE_INFO_PLATFORM = CL_DEVICE_PLATFORM,
   PI_DEVICE_INFO_REFERENCE_COUNT = CL_DEVICE_REFERENCE_COUNT,
+  PI_DEVICE_INFO_IL_VERSION = CL_DEVICE_IL_VERSION_KHR,
   PI_DEVICE_INFO_NAME = CL_DEVICE_NAME,
   PI_DEVICE_INFO_VENDOR = CL_DEVICE_VENDOR,
   PI_DEVICE_INFO_DRIVER_VERSION = CL_DRIVER_VERSION,
@@ -241,6 +249,10 @@ typedef enum {
   PI_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN =
       CL_DEVICE_PARTITION_AFFINITY_DOMAIN,
   PI_DEVICE_INFO_PARTITION_TYPE = CL_DEVICE_PARTITION_TYPE,
+  PI_DEVICE_INFO_MAX_NUM_SUB_GROUPS = CL_DEVICE_MAX_NUM_SUB_GROUPS,
+  PI_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS =
+      CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS,
+  PI_DEVICE_INFO_SUB_GROUP_SIZES_INTEL = CL_DEVICE_SUB_GROUP_SIZES_INTEL,
   PI_DEVICE_INFO_USM_HOST_SUPPORT = CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL,
   PI_DEVICE_INFO_USM_DEVICE_SUPPORT = CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL,
   PI_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT =
@@ -299,6 +311,16 @@ typedef enum {
   PI_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE = CL_KERNEL_PRIVATE_MEM_SIZE
 } _pi_kernel_group_info;
 
+typedef enum {
+  PI_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT = CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT,
+  PI_FP_ROUND_TO_NEAREST = CL_FP_ROUND_TO_NEAREST,
+  PI_FP_ROUND_TO_ZERO = CL_FP_ROUND_TO_ZERO,
+  PI_FP_ROUND_TO_INF = CL_FP_ROUND_TO_INF,
+  PI_FP_INF_NAN = CL_FP_INF_NAN,
+  PI_FP_DENORM = CL_FP_DENORM,
+  PI_FP_FMA = CL_FP_FMA
+} _pi_fp_capabilities;
+
 typedef enum {
   PI_IMAGE_INFO_FORMAT = CL_IMAGE_FORMAT,
   PI_IMAGE_INFO_ELEMENT_SIZE = CL_IMAGE_ELEMENT_SIZE,
@@ -512,6 +534,7 @@ using pi_image_info = _pi_image_info;
 using pi_kernel_info = _pi_kernel_info;
 using pi_kernel_group_info = _pi_kernel_group_info;
 using pi_kernel_sub_group_info = _pi_kernel_sub_group_info;
+using pi_fp_capabilities = _pi_fp_capabilities;
 using pi_event_info = _pi_event_info;
 using pi_command_type = _pi_command_type;
 using pi_mem_type = _pi_mem_type;
@@ -678,6 +701,13 @@ struct pi_device_binary_struct {
 };
 using pi_device_binary = pi_device_binary_struct *;
 
+// pi_buffer_region structure repeats cl_buffer_region
+struct pi_buffer_region_struct {
+  size_t origin;
+  size_t size;
+};
+using pi_buffer_region = pi_buffer_region_struct *;
+
 // Offload binaries descriptor version supported by this library.
 static const uint16_t PI_DEVICE_BINARIES_VERSION = 1;
 
@@ -1118,10 +1148,10 @@ __SYCL_EXPORT pi_result piKernelSetExecInfo(pi_kernel kernel,
 //
 __SYCL_EXPORT pi_result piEventCreate(pi_context context, pi_event *ret_event);
 
-__SYCL_EXPORT pi_result piEventGetInfo(
-    pi_event event,
-    cl_event_info param_name, // TODO: untie from OpenCL
-    size_t param_value_size, void *param_value, size_t *param_value_size_ret);
+__SYCL_EXPORT pi_result piEventGetInfo(pi_event event, pi_event_info param_name,
+                                       size_t param_value_size,
+                                       void *param_value,
+                                       size_t *param_value_size_ret);
 
 __SYCL_EXPORT pi_result piEventGetProfilingInfo(pi_event event,
                                                 pi_profiling_info param_name,
@@ -1439,7 +1469,8 @@ __SYCL_EXPORT pi_result piextUSMEnqueuePrefetch(
 // USM memadvise API to govern behavior of automatic migration mechanisms
 __SYCL_EXPORT pi_result piextUSMEnqueueMemAdvise(pi_queue queue,
                                                  const void *ptr, size_t length,
-                                                 int advice, pi_event *event);
+                                                 pi_mem_advice advice,
+                                                 pi_event *event);
 
 /// API to query information about USM allocated pointers
 /// Valid Queries:
@@ -1469,9 +1500,9 @@ struct _pi_plugin {
   // Some choices are:
   // - Use of integers to keep major and minor version.
   // - Keeping char* Versions.
-  const char PiVersion[4] = _PI_H_VERSION_STRING;
+  char PiVersion[4];
   // Plugin edits this.
-  char PluginVersion[4] = _PI_H_VERSION_STRING;
+  char PluginVersion[4];
   char *Targets;
   struct FunctionPointers {
 #define _PI_API(api) decltype(::api) *api;

sycl/include/CL/sycl/info/info_desc.hpp

@@ -117,18 +117,20 @@ enum class device : cl_device_info {
   partition_affinity_domains = CL_DEVICE_PARTITION_AFFINITY_DOMAIN,
   partition_type_affinity_domain = CL_DEVICE_PARTITION_TYPE,
   reference_count = CL_DEVICE_REFERENCE_COUNT,
+  il_version =
+      CL_DEVICE_IL_VERSION_KHR, // Same as CL_DEVICE_IL_VERSION for >=OpenCL 2.1
   max_num_sub_groups = CL_DEVICE_MAX_NUM_SUB_GROUPS,
   sub_group_independent_forward_progress =
       CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS,
   sub_group_sizes = CL_DEVICE_SUB_GROUP_SIZES_INTEL,
   partition_type_property,
   kernel_kernel_pipe_support,
   // USM
-  usm_device_allocations            = PI_USM_DEVICE_SUPPORT,
-  usm_host_allocations              = PI_USM_HOST_SUPPORT,
-  usm_shared_allocations            = PI_USM_SINGLE_SHARED_SUPPORT,
+  usm_device_allocations = PI_USM_DEVICE_SUPPORT,
+  usm_host_allocations = PI_USM_HOST_SUPPORT,
+  usm_shared_allocations = PI_USM_SINGLE_SHARED_SUPPORT,
   usm_restricted_shared_allocations = PI_USM_CROSS_SHARED_SUPPORT,
-  usm_system_allocator              = PI_USM_SYSTEM_SHARED_SUPPORT
+  usm_system_allocator = PI_USM_SYSTEM_SHARED_SUPPORT
 };
 
 enum class device_type : pi_uint64 {

sycl/plugins/cuda/pi_cuda.cpp

@@ -653,15 +653,18 @@ pi_result cuda_piDevicesGet(pi_platform platform, pi_device_type device_type,
                             pi_uint32 *num_devices) {
 
   pi_result err = PI_SUCCESS;
-  const bool askingForGPU = (device_type & PI_DEVICE_TYPE_GPU);
-  size_t numDevices = askingForGPU ? platform->devices_.size() : 0;
+  const bool askingForDefault = device_type == PI_DEVICE_TYPE_DEFAULT;
+  const bool askingForGPU = device_type & PI_DEVICE_TYPE_GPU;
+  const bool returnDevices = askingForDefault || askingForGPU;
+
+  size_t numDevices = returnDevices ? platform->devices_.size() : 0;
 
   try {
     if (num_devices) {
       *num_devices = numDevices;
     }
 
-    if (askingForGPU && devices) {
+    if (returnDevices && devices) {
       for (size_t i = 0; i < std::min(size_t(num_entries), numDevices); ++i) {
         devices[i] = platform->devices_[i].get();
       }
@@ -966,15 +969,15 @@ pi_result cuda_piDeviceGetInfo(pi_device device, pi_device_info param_name,
   }
   case PI_DEVICE_INFO_SINGLE_FP_CONFIG: {
     // TODO: is this config consistent across all NVIDIA GPUs?
-    auto config = CL_FP_DENORM | CL_FP_INF_NAN | CL_FP_ROUND_TO_NEAREST |
-                  CL_FP_ROUND_TO_ZERO | CL_FP_ROUND_TO_INF | CL_FP_FMA |
-                  CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT;
+    auto config = PI_FP_DENORM | PI_FP_INF_NAN | PI_FP_ROUND_TO_NEAREST |
+                  PI_FP_ROUND_TO_ZERO | PI_FP_ROUND_TO_INF | PI_FP_FMA |
+                  PI_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT;
     return getInfo(param_value_size, param_value, param_value_size_ret, config);
   }
   case PI_DEVICE_INFO_DOUBLE_FP_CONFIG: {
     // TODO: is this config consistent across all NVIDIA GPUs?
-    auto config = CL_FP_DENORM | CL_FP_INF_NAN | CL_FP_ROUND_TO_NEAREST |
-                  CL_FP_ROUND_TO_ZERO | CL_FP_ROUND_TO_INF | CL_FP_FMA;
+    auto config = PI_FP_DENORM | PI_FP_INF_NAN | PI_FP_ROUND_TO_NEAREST |
+                  PI_FP_ROUND_TO_ZERO | PI_FP_ROUND_TO_INF | PI_FP_FMA;
     return getInfo(param_value_size, param_value, param_value_size_ret, config);
   }
   case PI_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE: {
@@ -1611,7 +1614,7 @@ pi_result cuda_piMemBufferPartition(pi_mem parent_buffer, pi_mem_flags flags,
   assert(memObj != nullptr);
 
   const auto bufferRegion =
-      *reinterpret_cast<const cl_buffer_region *>(buffer_create_info);
+      *reinterpret_cast<const pi_buffer_region>(buffer_create_info);
   assert((bufferRegion.size != 0u) && "PI_INVALID_BUFFER_SIZE");
 
   assert((bufferRegion.origin <= (bufferRegion.origin + bufferRegion.size)) &&
@@ -3500,7 +3503,7 @@ pi_result cuda_piextUSMEnqueuePrefetch(pi_queue queue, const void *ptr,
 
 /// USM: memadvise API to govern behavior of automatic migration mechanisms
 pi_result cuda_piextUSMEnqueueMemAdvise(pi_queue queue, const void *ptr,
-                                        size_t length, int advice,
+                                        size_t length, pi_mem_advice advice,
                                         pi_event *event) {
   assert(queue != nullptr);
   assert(ptr != nullptr);

sycl/plugins/opencl/pi_opencl.cpp

@@ -939,7 +939,8 @@ pi_result piextUSMEnqueuePrefetch(pi_queue queue, const void *ptr, size_t size,
 /// \param event is the event that represents this operation
 // USM memadvise API to govern behavior of automatic migration mechanisms
 pi_result piextUSMEnqueueMemAdvise(pi_queue queue, const void *ptr,
-                                   size_t length, int advice, pi_event *event) {
+                                   size_t length, pi_mem_advice advice,
+                                   pi_event *event) {
 
   return cast<pi_result>(
       clEnqueueMarkerWithWaitList(cast<cl_command_queue>(queue), 0, nullptr,

sycl/source/detail/memory_manager.cpp

@@ -189,8 +189,7 @@ void *MemoryManager::allocateMemSubBuffer(ContextImplPtr TargetContext,
     SizeInBytes *= Range[I];
 
   RT::PiResult Error = PI_SUCCESS;
-  // TODO replace with pi_buffer_region
-  cl_buffer_region Region{Offset, SizeInBytes};
+  pi_buffer_region_struct Region{Offset, SizeInBytes};
   RT::PiMem NewMem;
   const detail::plugin &Plugin = TargetContext->getPlugin();
   Error = Plugin.call_nocheck<PiApiKind::piMemBufferPartition>(

sycl/source/detail/pi.cpp

@@ -264,7 +264,9 @@ vector_class<plugin> initialize() {
     std::cerr << "SYCL_PI_TRACE[all]: "
               << "No Plugins Found." << std::endl;
 
-  PiPlugin PluginInformation;
+  PiPlugin PluginInformation{_PI_H_VERSION_STRING, _PI_H_VERSION_STRING,
+                             nullptr};
+
   for (unsigned int I = 0; I < PluginNames.size(); I++) {
     void *Library = loadPlugin(PluginNames[I].first);
 

sycl/source/detail/plugin.hpp

@@ -34,6 +34,11 @@ class plugin {
   plugin(RT::PiPlugin Plugin, backend UseBackend)
       : MPlugin(Plugin), MBackend(UseBackend) {}
 
+  plugin &operator=(const plugin &) = default;
+  plugin(const plugin &) = default;
+  plugin &operator=(plugin &&other) noexcept = default;
+  plugin(plugin &&other) noexcept = default;
+
   ~plugin() = default;
 
   const RT::PiPlugin &getPiPlugin() const { return MPlugin; }
@@ -97,7 +102,7 @@ class plugin {
 
 private:
   RT::PiPlugin MPlugin;
-  const backend MBackend;
+  backend MBackend;
 }; // class plugin
 } // namespace detail
 } // namespace sycl

sycl/source/detail/scheduler/graph_builder.cpp

@@ -920,10 +920,7 @@ void Scheduler::GraphBuilder::removeRecordForMemObj(SYCLMemObjI *MemObject) {
 void Scheduler::GraphBuilder::connectDepEvent(Command *const Cmd,
                                               EventImplPtr DepEvent,
                                               const DepDesc &Dep) {
-  const ContextImplPtr &Context = Cmd->getContext();
-  const ContextImplPtr &DepEventContext = DepEvent->getContextImpl();
-
-  assert(Context != DepEventContext);
+  assert(Cmd->getContext() != DepEvent->getContextImpl());
 
   // construct Host Task type command manually and make it depend on DepEvent
   ExecCGCommand *ConnectCmd = nullptr;

sycl/source/detail/scheduler/scheduler.cpp

@@ -66,7 +66,8 @@ EventImplPtr Scheduler::addCG(std::unique_ptr<detail::CG> CommandGroup,
   Command *NewCmd = nullptr;
   const bool IsKernel = CommandGroup->getType() == CG::KERNEL;
   {
-    std::lock_guard<std::shared_timed_mutex> Lock(MGraphLock);
+    std::unique_lock<std::shared_timed_mutex> Lock(MGraphLock, std::defer_lock);
+    lockSharedTimedMutex(Lock);
 
     switch (CommandGroup->getType()) {
     case CG::UPDATE_HOST:
@@ -98,7 +99,8 @@ EventImplPtr Scheduler::addCG(std::unique_ptr<detail::CG> CommandGroup,
 }
 
 EventImplPtr Scheduler::addCopyBack(Requirement *Req) {
-  std::lock_guard<std::shared_timed_mutex> Lock(MGraphLock);
+  std::unique_lock<std::shared_timed_mutex> Lock(MGraphLock, std::defer_lock);
+  lockSharedTimedMutex(Lock);
   Command *NewCmd = MGraphBuilder.addCopyBack(Req);
   // Command was not creted because there were no operations with
   // buffer.
@@ -154,7 +156,8 @@ void Scheduler::cleanupFinishedCommands(EventImplPtr FinishedEvent) {
 }
 
 void Scheduler::removeMemoryObject(detail::SYCLMemObjI *MemObj) {
-  std::lock_guard<std::shared_timed_mutex> Lock(MGraphLock);
+  std::unique_lock<std::shared_timed_mutex> Lock(MGraphLock, std::defer_lock);
+  lockSharedTimedMutex(Lock);
 
   MemObjRecord *Record = MGraphBuilder.getMemObjRecord(MemObj);
   if (!Record)
@@ -169,7 +172,8 @@ void Scheduler::removeMemoryObject(detail::SYCLMemObjI *MemObj) {
 
 EventImplPtr Scheduler::addHostAccessor(Requirement *Req,
                                         const bool destructor) {
-  std::lock_guard<std::shared_timed_mutex> Lock(MGraphLock);
+  std::unique_lock<std::shared_timed_mutex> Lock(MGraphLock, std::defer_lock);
+  lockSharedTimedMutex(Lock);
 
   Command *NewCmd = MGraphBuilder.addHostAccessor(Req, destructor);
 
@@ -216,6 +220,25 @@ Scheduler::Scheduler() {
                      QueueOrder::Ordered, /*PropList=*/{}));
 }
 
+void Scheduler::lockSharedTimedMutex(
+    std::unique_lock<std::shared_timed_mutex> &Lock) {
+#ifdef _WIN32
+  // Avoiding deadlock situation for MSVC. std::shared_timed_mutex specification
+  // does not specify a priority for shared and exclusive accesses. It will be a
+  // deadlock in MSVC's std::shared_timed_mutex implementation, if exclusive
+  // access occurs after shared access.
+  // TODO: after switching to C++17, change std::shared_timed_mutex to
+  // std::shared_mutex and use std::lock_guard here both for Windows and Linux.
+  while (!Lock.owns_lock()) {
+    Lock.try_lock();
+  }
+#else
+  // It is a deadlock on UNIX in implementation of lock and lock_shared, if
+  // try_lock in the loop above will be executed, so using a single lock here
+  Lock.lock();
+#endif // _WIN32
+}
+
 } // namespace detail
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/detail/scheduler/scheduler.hpp

@@ -430,6 +430,13 @@ class Scheduler {
   Scheduler();
   static Scheduler instance;
 
+  /// Provides exclusive access to std::shared_timed_mutex object with deadlock
+  /// avoidance
+  ///
+  /// \param Lock is an instance of std::unique_lock<std::shared_timed_mutex>
+  /// class
+  void lockSharedTimedMutex(std::unique_lock<std::shared_timed_mutex> &Lock);
+
   static void enqueueLeavesOfReqUnlocked(const Requirement *const Req);
 
   /// Graph builder class.
@@ -687,6 +694,8 @@ class Scheduler {
   void waitForRecordToFinish(MemObjRecord *Record);
 
   GraphBuilder MGraphBuilder;
+  // TODO: after switching to C++17, change std::shared_timed_mutex to
+  // std::shared_mutex
   std::shared_timed_mutex MGraphLock;
 
   QueueImplPtr DefaultHostQueue;

sycl/test/host-interop-task/host-task-two-queues.cpp

@@ -55,7 +55,7 @@ void test() {
     });
   };
 
-  static const size_t NTIMES = 100;
+  static const size_t NTIMES = 4;
 
   for (size_t Idx = 0; Idx < NTIMES; ++Idx) {
     Q1.submit(CG1);

sycl/unittests/pi/BackendString.hpp

@@ -0,0 +1,23 @@
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <detail/plugin.hpp>
+
+namespace pi {
+inline const char *GetBackendString(cl::sycl::backend backend) {
+  switch (backend) {
+#define PI_BACKEND_STR(backend_name)                                           \
+  case cl::sycl::backend::backend_name:                                        \
+    return #backend_name
+    PI_BACKEND_STR(cuda);
+    PI_BACKEND_STR(host);
+    PI_BACKEND_STR(opencl);
+#undef PI_BACKEND_STR
+  default:
+    return "Unknown Plugin";
+  }
+}
+} // namespace pi