Merge from 'sycl' to 'sycl-web' (3 commits)

iclsrc · iclsrc · commit 920a536143c2 · 2022-11-03T08:32:26.000-07:00
diff --git a/sycl/include/sycl/detail/util.hpp b/sycl/include/sycl/detail/util.hpp
@@ -32,6 +32,18 @@ class Sync {
   std::mutex GlobalLock;
 };
 
+// TempAssignGuard is the class for a guard object that will assign some OTHER
+// variable to a temporary value but restore it when the guard itself goes out
+// of scope.
+template <typename T> struct TempAssignGuard {
+  T &field;
+  T restoreValue;
+  TempAssignGuard(T &fld, T tempVal) : field(fld), restoreValue(fld) {
+    field = tempVal;
+  }
+  ~TempAssignGuard() { field = restoreValue; }
+};
+
 // const char* key hash for STL maps
 struct HashCStr {
   size_t operator()(const char *S) const {
diff --git a/sycl/include/sycl/exception_list.hpp b/sycl/include/sycl/exception_list.hpp
@@ -12,6 +12,7 @@
 
 #include <sycl/detail/defines.hpp>
 #include <sycl/detail/export.hpp>
+#include <sycl/detail/iostream_proxy.hpp>
 #include <sycl/stl.hpp>
 
 #include <cstddef>
@@ -52,5 +53,23 @@ class __SYCL_EXPORT exception_list {
 
 using async_handler = std::function<void(sycl::exception_list)>;
 
+namespace detail {
+// Default implementation of async_handler used by queue and context when no
+// user-defined async_handler is specified.
+inline void defaultAsyncHandler(exception_list Exceptions) {
+  std::cerr << "Default async_handler caught exceptions:";
+  for (auto &EIt : Exceptions) {
+    try {
+      if (EIt) {
+        std::rethrow_exception(EIt);
+      }
+    } catch (const std::exception &E) {
+      std::cerr << "\n\t" << E.what();
+    }
+  }
+  std::cerr << std::endl;
+  std::terminate();
+}
+} // namespace detail
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl
diff --git a/sycl/include/sycl/queue.hpp b/sycl/include/sycl/queue.hpp
@@ -90,7 +90,7 @@ class __SYCL_EXPORT queue {
   ///
   /// \param PropList is a list of properties for queue construction.
   explicit queue(const property_list &PropList = {})
-      : queue(default_selector(), async_handler{}, PropList) {}
+      : queue(default_selector(), detail::defaultAsyncHandler, PropList) {}
 
   /// Constructs a SYCL queue instance with an async_handler using the device
   /// returned by an instance of default_selector.
@@ -125,8 +125,8 @@ class __SYCL_EXPORT queue {
                 detail::EnableIfSYCL2020DeviceSelectorInvocable<DeviceSelector>>
   explicit queue(const DeviceSelector &deviceSelector,
                  const property_list &PropList = {})
-      : queue(detail::select_device(deviceSelector), async_handler{},
-              PropList) {}
+      : queue(detail::select_device(deviceSelector),
+              detail::defaultAsyncHandler, PropList) {}
 
   /// Constructs a SYCL queue instance using the device identified by the
   /// device selector provided.
@@ -171,7 +171,8 @@ class __SYCL_EXPORT queue {
                         "use SYCL 2020 device selectors instead.")
   queue(const device_selector &DeviceSelector,
         const property_list &PropList = {})
-      : queue(DeviceSelector.select_device(), async_handler{}, PropList) {}
+      : queue(DeviceSelector.select_device(), detail::defaultAsyncHandler,
+              PropList) {}
 
   /// Constructs a SYCL queue instance with an async_handler using the device
   /// returned by the DeviceSelector provided.
@@ -190,7 +191,7 @@ class __SYCL_EXPORT queue {
   /// \param SyclDevice is an instance of SYCL device.
   /// \param PropList is a list of properties for queue construction.
   explicit queue(const device &SyclDevice, const property_list &PropList = {})
-      : queue(SyclDevice, async_handler{}, PropList) {}
+      : queue(SyclDevice, detail::defaultAsyncHandler, PropList) {}
 
   /// Constructs a SYCL queue instance with an async_handler using the device
   /// provided.
diff --git a/sycl/source/backend/level_zero.cpp b/sycl/source/backend/level_zero.cpp
@@ -57,8 +57,8 @@ __SYCL_EXPORT context make_context(const std::vector<device> &DeviceList,
       NativeHandle, DeviceHandles.size(), DeviceHandles.data(), !KeepOwnership,
       &PiContext);
   // Construct the SYCL context from PI context.
-  return detail::createSyclObjFromImpl<context>(
-      std::make_shared<context_impl>(PiContext, async_handler{}, Plugin));
+  return detail::createSyclObjFromImpl<context>(std::make_shared<context_impl>(
+      PiContext, detail::defaultAsyncHandler, Plugin));
 }
 
 //----------------------------------------------------------------------------
diff --git a/sycl/source/backend/opencl.cpp b/sycl/source/backend/opencl.cpp
@@ -36,7 +36,8 @@ __SYCL_EXPORT device make_device(pi_native_handle NativeHandle) {
 //----------------------------------------------------------------------------
 // Implementation of opencl::make<context>
 __SYCL_EXPORT context make_context(pi_native_handle NativeHandle) {
-  return detail::make_context(NativeHandle, async_handler{}, backend::opencl);
+  return detail::make_context(NativeHandle, detail::defaultAsyncHandler,
+                              backend::opencl);
 }
 
 //----------------------------------------------------------------------------
diff --git a/sycl/source/context.cpp b/sycl/source/context.cpp
@@ -26,6 +26,7 @@
 
 namespace sycl {
 __SYCL_INLINE_VER_NAMESPACE(_V1) {
+
 context::context(const property_list &PropList)
     : context(default_selector().select_device(), PropList) {}
 
@@ -49,7 +50,7 @@ context::context(const platform &Platform, async_handler AsyncHandler,
 
 context::context(const std::vector<device> &DeviceList,
                  const property_list &PropList)
-    : context(DeviceList, async_handler{}, PropList) {}
+    : context(DeviceList, detail::defaultAsyncHandler, PropList) {}
 
 context::context(const std::vector<device> &DeviceList,
                  async_handler AsyncHandler, const property_list &PropList) {
diff --git a/sycl/source/detail/device_impl.cpp b/sycl/source/detail/device_impl.cpp
@@ -53,10 +53,13 @@ device_impl::device_impl(pi_native_handle InteropDeviceHandle,
   Plugin.call<PiApiKind::piDeviceGetInfo>(
       MDevice, PI_DEVICE_INFO_TYPE, sizeof(RT::PiDeviceType), &MType, nullptr);
 
-  // TODO catch an exception and put it to list of asynchronous exceptions
-  Plugin.call<PiApiKind::piDeviceGetInfo>(MDevice, PI_DEVICE_INFO_PARENT_DEVICE,
-                                          sizeof(RT::PiDevice), &MRootDevice,
-                                          nullptr);
+  // No need to set MRootDevice when MAlwaysRootDevice is true
+  if ((Platform == nullptr) || !Platform->MAlwaysRootDevice) {
+    // TODO catch an exception and put it to list of asynchronous exceptions
+    Plugin.call<PiApiKind::piDeviceGetInfo>(
+        MDevice, PI_DEVICE_INFO_PARENT_DEVICE, sizeof(RT::PiDevice),
+        &MRootDevice, nullptr);
+  }
 
   if (!InteroperabilityConstructor) {
     // TODO catch an exception and put it to list of asynchronous exceptions
diff --git a/sycl/source/detail/platform_impl.cpp b/sycl/source/detail/platform_impl.cpp
@@ -14,6 +14,7 @@
 #include <detail/platform_impl.hpp>
 #include <detail/platform_info.hpp>
 #include <sycl/detail/iostream_proxy.hpp>
+#include <sycl/detail/util.hpp>
 #include <sycl/device.hpp>
 
 #include <algorithm>
@@ -253,13 +254,17 @@ static bool supportsPartitionProperty(const device &dev,
 
 static std::vector<device> amendDeviceAndSubDevices(
     backend PlatformBackend, std::vector<device> &DeviceList,
-    ods_target_list *OdsTargetList, int PlatformDeviceIndex) {
+    ods_target_list *OdsTargetList, int PlatformDeviceIndex,
+    PlatformImplPtr PlatformImpl) {
   constexpr info::partition_property partitionProperty =
       info::partition_property::partition_by_affinity_domain;
   constexpr info::partition_affinity_domain affinityDomain =
       info::partition_affinity_domain::next_partitionable;
 
   std::vector<device> FinalResult;
+  // (Only) when amending sub-devices for ONEAPI_DEVICE_SELECTOR, all
+  // sub-devices are treated as root.
+  TempAssignGuard<bool> TAG(PlatformImpl->MAlwaysRootDevice, true);
 
   for (unsigned i = 0; i < DeviceList.size(); i++) {
     // device has already been screened. The question is whether it should be a
@@ -311,9 +316,8 @@ static std::vector<device> amendDeviceAndSubDevices(
             // -- Add sub sub device.
             if (wantSubSubDevice) {
 
-              auto subDevicesToPartition = dev.create_sub_devices<
-                  info::partition_property::partition_by_affinity_domain>(
-                  affinityDomain);
+              auto subDevicesToPartition =
+                  dev.create_sub_devices<partitionProperty>(affinityDomain);
               if (target.SubDeviceNum) {
                 if (subDevicesToPartition.size() >
                     target.SubDeviceNum.value()) {
@@ -341,9 +345,9 @@ static std::vector<device> amendDeviceAndSubDevices(
                   continue;
                 }
                 // Allright, lets get them sub-sub-devices.
-                auto subSubDevices = subDev.create_sub_devices<
-                    info::partition_property::partition_by_affinity_domain>(
-                    affinityDomain);
+                auto subSubDevices =
+                    subDev.create_sub_devices<partitionProperty>(
+                        affinityDomain);
                 if (target.HasSubSubDeviceWildCard) {
                   FinalResult.insert(FinalResult.end(), subSubDevices.begin(),
                                      subSubDevices.end());
@@ -476,7 +480,7 @@ platform_impl::get_devices(info::device_type DeviceType) const {
   // Otherwise, our last step is to revisit the devices, possibly replacing
   // them with subdevices (which have been ignored until now)
   return amendDeviceAndSubDevices(Backend, Res, OdsTargetList,
-                                  PlatformDeviceIndex);
+                                  PlatformDeviceIndex, PlatformImpl);
 }
 
 bool platform_impl::has_extension(const std::string &ExtensionName) const {
diff --git a/sycl/source/detail/platform_impl.hpp b/sycl/source/detail/platform_impl.hpp
@@ -188,6 +188,10 @@ class platform_impl {
   static std::shared_ptr<platform_impl>
   getPlatformFromPiDevice(RT::PiDevice PiDevice, const plugin &Plugin);
 
+  // when getting sub-devices for ONEAPI_DEVICE_SELECTOR we may temporarily
+  // ensure every device is a root one.
+  bool MAlwaysRootDevice = false;
+
 private:
   std::shared_ptr<device_impl> getDeviceImplHelper(RT::PiDevice PiDevice);
 
diff --git a/sycl/source/detail/queue_impl.hpp b/sycl/source/detail/queue_impl.hpp
@@ -230,10 +230,6 @@ class queue_impl {
     try {
       return submit_impl(CGF, Self, Self, SecondQueue, Loc, PostProcess);
     } catch (...) {
-      {
-        std::lock_guard<std::mutex> Lock(MMutex);
-        MExceptions.PushBack(std::current_exception());
-      }
       return SecondQueue->submit_impl(CGF, SecondQueue, Self, SecondQueue, Loc,
                                       PostProcess);
     }
diff --git a/sycl/source/device.cpp b/sycl/source/device.cpp
@@ -142,6 +142,19 @@ device::get_info() const {
   return impl->template get_info<Param>();
 }
 
+template <> device device::get_info<info::device::parent_device>() const {
+  // With ONEAPI_DEVICE_SELECTOR the impl.MRootDevice is preset and may be
+  // overridden (ie it may be nullptr on a sub-device) The PI of the sub-devices
+  // have parents, but we don't want to return them. They must pretend to be
+  // parentless root devices.
+  if (impl->isRootDevice())
+    throw invalid_object_error(
+        "No parent for device because it is not a subdevice",
+        PI_ERROR_INVALID_DEVICE);
+  else
+    return impl->template get_info<info::device::parent_device>();
+}
+
 #define __SYCL_PARAM_TRAITS_SPEC(DescType, Desc, ReturnT, PiCode)              \
   template __SYCL_EXPORT ReturnT device::get_info<info::device::Desc>() const;
 
diff --git a/sycl/test/basic_tests/temp-assign-guard.cpp b/sycl/test/basic_tests/temp-assign-guard.cpp
@@ -0,0 +1,69 @@
+// RUN: %clangxx -fsycl %s -o %t.out
+// RUN: %t.out
+
+#include <sycl/detail/util.hpp>
+#include <sycl/sycl.hpp>
+using namespace sycl;
+
+struct someStruct {
+  int firstValue;
+  bool secondValue;
+};
+
+int main() {
+  someStruct myStruct;
+  myStruct.firstValue = 2;
+  myStruct.secondValue = false;
+  someStruct moarStruct;
+  moarStruct.firstValue = 3;
+  moarStruct.secondValue = false;
+  someStruct *moarPtr = &moarStruct;
+  int anotherValue = 4;
+
+  { // Scope to limit lifetime of TempAssignGuards.
+
+    sycl::detail::TempAssignGuard myTAG_1(myStruct.firstValue, -20);
+    sycl::detail::TempAssignGuard myTAG_2(myStruct.secondValue, true);
+    sycl::detail::TempAssignGuard moarTAG_1(moarPtr->firstValue, -30);
+    sycl::detail::TempAssignGuard moarTAG_2(moarPtr->secondValue, true);
+    sycl::detail::TempAssignGuard anotherTAG(anotherValue, -40);
+
+    // Ensure values have been temporarily assigned.
+    assert(myStruct.firstValue == -20);
+    assert(myStruct.secondValue == true);
+    assert(moarStruct.firstValue == -30);
+    assert(moarStruct.secondValue == true);
+    assert(anotherValue == -40);
+  }
+
+  // Ensure values have been restored.
+  assert(myStruct.firstValue == 2);
+  assert(myStruct.secondValue == false);
+  assert(moarStruct.firstValue == 3);
+  assert(moarStruct.secondValue == false);
+  assert(anotherValue == 4);
+
+  // Test exceptions
+  int exceptionalValue = 5;
+  try {
+    sycl::detail::TempAssignGuard exceptionalTAG(exceptionalValue, -50);
+    assert(exceptionalValue == -50);
+    throw 7; // Baby needs a new pair of shoes.
+  } catch (...) {
+    assert(exceptionalValue == 5);
+  }
+  assert(exceptionalValue == 5);
+
+  // Test premature exit
+  int prematureValue = 6;
+  {
+    sycl::detail::TempAssignGuard prematureTAG(prematureValue, -60);
+    assert(prematureValue == -60);
+    goto dragons;
+    assert(true == false);
+  }
+dragons:
+  assert(prematureValue == 6);
+
+  return 0;
+}
diff --git a/sycl/test/extensions/properties/properties_kernel_work_group_size_hint.cpp b/sycl/test/extensions/properties/properties_kernel_work_group_size_hint.cpp
@@ -1,5 +1,5 @@
 // RUN: %clangxx -fsycl-device-only -S -Xclang -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK-IR
-// RUN: %clangxx -fsycl -Xclang -verify %s
+// RUN: %clangxx -fsycl -fsyntax-only -Xclang -verify %s
 // expected-no-diagnostics
 
 #include <sycl/sycl.hpp>

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,8 @@ __SYCL_EXPORT device make_device(pi_native_handle NativeHandle) {`
`36`	`36`	`//----------------------------------------------------------------------------`
`37`	`37`	`// Implementation of opencl::make<context>`
`38`	`38`	`__SYCL_EXPORT context make_context(pi_native_handle NativeHandle) {`
`39`		`- return detail::make_context(NativeHandle, async_handler{}, backend::opencl);`
	`39`	`+ return detail::make_context(NativeHandle, detail::defaultAsyncHandler,`
	`40`	`+ backend::opencl);`
`40`	`41`	`}`
`41`	`42`
`42`	`43`	`//----------------------------------------------------------------------------`