[SYCL] Add property validation to sycl object ctors

sycl/include/sycl/detail/property_helper.hpp

@@ -88,6 +88,7 @@ class PropertyWithDataBase {
   PropertyWithDataBase(int ID) : MID(ID) {}
   bool isSame(int ID) const { return ID == MID; }
   virtual ~PropertyWithDataBase() = default;
+  int getKind() const { return MID; }
 
 private:
   int MID = -1;
@@ -99,7 +100,7 @@ class PropertyWithDataBase {
 template <int ID> class PropertyWithData : public PropertyWithDataBase {
 public:
   PropertyWithData() : PropertyWithDataBase(ID) {}
-  static int getKind() { return ID; }
+  static constexpr int getKind() { return ID; }
 };
 
 } // namespace detail

sycl/include/sycl/detail/property_list_base.hpp

@@ -126,6 +126,25 @@ class PropertyListBase {
     }
   }
 
+  void checkPropsAndThrow(std::function<bool(int)> FunctionForDataless,
+                          std::function<bool(int)> FunctionForData) const {
+    static const auto ErrorCode = sycl::make_error_code(errc::invalid);
+    static const auto ErrorMessage = "The property list contains property "
+                                     "unsupported for the current object";
+
+    for (int PropertyKind = 0;
+         PropertyKind < static_cast<int>(MDataLessProps.size());
+         PropertyKind++) {
+      if (MDataLessProps[PropertyKind] && !FunctionForDataless(PropertyKind))
+        throw sycl::exception(ErrorCode, ErrorMessage);
+    }
+
+    for (const auto &PropertyItem : MPropsWithData) {
+      if (!FunctionForData(PropertyItem->getKind()))
+        throw sycl::exception(ErrorCode, ErrorMessage);
+    }
+  }
+
   // Stores enabled/disabled for simple properties
   std::bitset<DataLessPropKind::DataLessPropKindSize> MDataLessProps;
   // Stores shared_ptrs to complex properties

sycl/include/sycl/property_list.hpp

@@ -64,6 +64,8 @@ class property_list : protected detail::PropertyListBase {
 
   template <typename... T> operator ext::oneapi::accessor_property_list<T...>();
 
+  using PropertyListBase::checkPropsAndThrow;
+
 private:
   property_list(
       std::bitset<detail::DataLessPropKind::DataLessPropKindSize> DataLessProps,

sycl/source/detail/queue_impl.cpp

@@ -807,6 +807,32 @@ void queue_impl::doUnenqueuedCommandCleanup(
     tryToCleanup(MDefaultGraphDeps);
 }
 
+void queue_impl::verifyProps(const property_list &Props) const {
+  auto CheckDataLessProperties = [](int PropertyKind) {
+#define __SYCL_DATA_LESS_PROP(NS_QUALIFIER, PROP_NAME, ENUM_VAL)               \
+  case NS_QUALIFIER::PROP_NAME::getKind():                                     \
+    return true;
+#define __SYCL_MANUALLY_DEFINED_PROP(NS_QUALIFIER, PROP_NAME)
+    switch (PropertyKind) {
+#include <sycl/properties/queue_properties.def>
+    default:
+      return false;
+    }
+  };
+  auto CheckPropertiesWithData = [](int PropertyKind) {
+#define __SYCL_DATA_LESS_PROP(NS_QUALIFIER, PROP_NAME, ENUM_VAL)
+#define __SYCL_MANUALLY_DEFINED_PROP(NS_QUALIFIER, PROP_NAME)                  \
+  case NS_QUALIFIER::PROP_NAME::getKind():                                     \
+    return true;
+    switch (PropertyKind) {
+#include <sycl/properties/queue_properties.def>
+    default:
+      return false;
+    }
+  };
+  Props.checkPropsAndThrow(CheckDataLessProperties, CheckPropertiesWithData);
+}
+
 } // namespace detail
 } // namespace _V1
 } // namespace sycl

sycl/source/detail/queue_impl.hpp

@@ -114,6 +114,7 @@ class queue_impl {
         MIsProfilingEnabled(has_property<property::queue::enable_profiling>()),
         MQueueID{
             MNextAvailableQueueID.fetch_add(1, std::memory_order_relaxed)} {
+    verifyProps(PropList);
     if (has_property<property::queue::enable_profiling>()) {
       if (has_property<ext::oneapi::property::queue::discard_events>())
         throw sycl::exception(make_error_code(errc::invalid),
@@ -249,6 +250,7 @@ class queue_impl {
         MDiscardEvents(
             has_property<ext::oneapi::property::queue::discard_events>()),
         MIsProfilingEnabled(has_property<property::queue::enable_profiling>()) {
+    verifyProps(PropList);
     queue_impl_interop(UrQueue);
   }
 
@@ -984,6 +986,8 @@ class queue_impl {
   std::mutex MMissedCleanupRequestsMtx;
 
   friend class sycl::ext::oneapi::experimental::detail::node_impl;
+
+  void verifyProps(const property_list &Props) const;
 };
 
 } // namespace detail

sycl/unittests/queue/CMakeLists.txt

@@ -8,4 +8,5 @@ add_sycl_unittest(QueueTests OBJECT
   ShortcutFunctions.cpp
   InOrderQueue.cpp
   InteropRetain.cpp
+  Properties.cpp
 )

sycl/unittests/queue/Properties.cpp

@@ -0,0 +1,90 @@
+//==-------- Properties.cpp --- check properties handling in RT --- --------==//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <gtest/gtest.h>
+#include <helpers/UrMock.hpp>
+#include <sycl/properties/queue_properties.hpp>
+#include <sycl/sycl.hpp>
+
+template <typename PropertyType> void DatalessQueuePropertyCheck() {
+  try {
+    sycl::queue Queue{PropertyType{}};
+    ASSERT_TRUE(Queue.has_property<PropertyType>());
+    Queue.get_property<PropertyType>();
+    // no explicit checks, we expect no exception to be thrown
+  } catch (...) {
+    FAIL();
+  }
+}
+
+TEST(QueueProperties, ValidDatalessProperties) {
+  sycl::unittest::UrMock<> Mock;
+  DatalessQueuePropertyCheck<sycl::property::queue::in_order>();
+  DatalessQueuePropertyCheck<sycl::property::queue::enable_profiling>();
+  DatalessQueuePropertyCheck<
+      sycl::ext::oneapi::property::queue::discard_events>();
+  DatalessQueuePropertyCheck<
+      sycl::ext::oneapi::property::queue::priority_normal>();
+  DatalessQueuePropertyCheck<
+      sycl::ext::oneapi::property::queue::priority_low>();
+  DatalessQueuePropertyCheck<
+      sycl::ext::oneapi::property::queue::priority_high>();
+  DatalessQueuePropertyCheck<
+      sycl::ext::intel::property::queue::no_immediate_command_list>();
+  DatalessQueuePropertyCheck<
+      sycl::ext::intel::property::queue::immediate_command_list>();
+  DatalessQueuePropertyCheck<
+      sycl::ext::oneapi::cuda::property::queue::use_default_stream>();
+}
+
+inline ur_result_t urDeviceGetInfoRedefined(void *pParams) {
+  auto params = reinterpret_cast<ur_device_get_info_params_t *>(pParams);
+  switch (*params->ppropName) {
+  case UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES: {
+    if (*params->ppPropValue)
+      *static_cast<int32_t *>(*params->ppPropValue) = 8;
+    if (*params->ppPropSizeRet)
+      **params->ppPropSizeRet = sizeof(int32_t);
+    return UR_RESULT_SUCCESS;
+  }
+  default:
+    return UR_RESULT_SUCCESS;
+  }
+}
+
+TEST(QueueProperties, ValidPropertyComputeIndex) {
+  sycl::unittest::UrMock<> Mock;
+  mock::getCallbacks().set_after_callback("urDeviceGetInfo",
+                                          &urDeviceGetInfoRedefined);
+  try {
+    sycl::queue Queue{sycl::ext::intel::property::queue::compute_index{1}};
+    ASSERT_TRUE(
+        Queue.has_property<sycl::ext::intel::property::queue::compute_index>());
+    EXPECT_EQ(
+        Queue.get_property<sycl::ext::intel::property::queue::compute_index>()
+            .get_index(),
+        1);
+    // no explicit checks, we expect no exception to be thrown
+  } catch (...) {
+    FAIL();
+  }
+}
+
+TEST(QueueProperties, SetUnsupportedParam) {
+  sycl::unittest::UrMock<> Mock;
+  try {
+    sycl::queue Queue{sycl::property::image::use_host_ptr{}};
+  } catch (sycl::exception &e) {
+    EXPECT_EQ(e.code(), sycl::errc::invalid);
+    EXPECT_STREQ(e.what(), "The property list contains property unsupported "
+                           "for the current object");
+    return;
+  }
+
+  FAIL() << "Test must exit in exception handler. Exception is not thrown.";
+}