is_device_copyable specialization for const properties and associated tests

Signed-off-by: Steffen Larsen <[email protected]>

Author: steffenlarsen

sycl/include/CL/sycl/types.hpp

@@ -2399,12 +2399,6 @@ struct is_device_copyable<
     T, std::enable_if_t<std::is_trivially_copyable<T>::value>>
     : std::true_type {};
 
-// Specializations of device copyable should propagate onto constants.
-template <typename T>
-struct is_device_copyable<
-    const T, std::enable_if_t<!std::is_trivially_copyable<const T>::value>>
-    : is_device_copyable<T> {};
-
 #if __cplusplus >= 201703L
 template <typename T>
 inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;

sycl/include/sycl/ext/oneapi/properties/properties.hpp

@@ -213,6 +213,12 @@ struct is_device_copyable<
     std::enable_if_t<!std::is_trivially_copyable<
         ext::oneapi::experimental::properties<PropertiesT>>::value>>
     : is_device_copyable<PropertiesT> {};
+template <typename PropertiesT>
+struct is_device_copyable<
+    const ext::oneapi::experimental::properties<PropertiesT>,
+    std::enable_if_t<!std::is_trivially_copyable<
+        const ext::oneapi::experimental::properties<PropertiesT>>::value>>
+    : is_device_copyable<PropertiesT> {};
 
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/test/extensions/properties/mock_compile_time_properties.hpp

@@ -56,18 +56,36 @@ inline bool operator==(const foz &lhs, const foz &rhs) {
 }
 inline bool operator!=(const foz &lhs, const foz &rhs) { return !(lhs == rhs); }
 
+struct fir {
+  fir(float v1, bool v2) : value1(v1), value2(v2) {}
+  // Define copy constructor to make foz non-trivially copyable
+  fir(const foz &f) {
+    value1 = f.value1;
+    value2 = f.value2;
+  }
+  float value1;
+  bool value2;
+};
+
+inline bool operator==(const fir &lhs, const fir &rhs) {
+  return lhs.value1 == rhs.value1 && lhs.value2 == rhs.value2;
+}
+inline bool operator!=(const fir &lhs, const fir &rhs) { return !(lhs == rhs); }
+
 inline constexpr bar_key::value_t bar;
 template <int K> inline constexpr baz_key::value_t<K> baz;
 template <typename... Ts> inline constexpr boo_key::value_t<Ts...> boo;
 
 using foo_key = foo;
 using foz_key = foz;
+using fir_key = fir;
 
 template <> struct is_property_key<bar_key> : std::true_type {};
 template <> struct is_property_key<baz_key> : std::true_type {};
 template <> struct is_property_key<boo_key> : std::true_type {};
 template <> struct is_property_key<foo_key> : std::true_type {};
 template <> struct is_property_key<foz_key> : std::true_type {};
+template <> struct is_property_key<fir_key> : std::true_type {};
 
 template <typename syclObjectT>
 struct is_property_key_of<bar_key, syclObjectT> : std::true_type {};
@@ -79,6 +97,8 @@ template <typename syclObjectT>
 struct is_property_key_of<foo_key, syclObjectT> : std::true_type {};
 template <typename syclObjectT>
 struct is_property_key_of<foz_key, syclObjectT> : std::true_type {};
+template <typename syclObjectT>
+struct is_property_key_of<fir_key, syclObjectT> : std::true_type {};
 
 namespace detail {
 template <> struct PropertyToKind<bar_key> {
@@ -101,13 +121,18 @@ template <> struct PropertyToKind<foz_key> {
   static constexpr PropKind Kind =
       static_cast<enum PropKind>(PropKind::PropKindSize + 4);
 };
+template <> struct PropertyToKind<fir_key> {
+  static constexpr PropKind Kind =
+      static_cast<enum PropKind>(PropKind::PropKindSize + 4);
+};
 
 template <> struct IsCompileTimeProperty<bar_key> : std::true_type {};
 template <> struct IsCompileTimeProperty<baz_key> : std::true_type {};
 template <> struct IsCompileTimeProperty<boo_key> : std::true_type {};
 
 template <> struct IsRuntimeProperty<foo_key> : std::true_type {};
 template <> struct IsRuntimeProperty<foz_key> : std::true_type {};
+template <> struct IsRuntimeProperty<fir_key> : std::true_type {};
 } // namespace detail
 } // namespace experimental
 } // namespace oneapi

sycl/test/extensions/properties/properties_device_copyable.cpp

@@ -8,13 +8,23 @@
 class TestClass1 {};
 class TestClass2 {};
 
+namespace sycl {
+// Explicitly mark fir property as device-copyable
+template <>
+struct is_device_copyable<sycl::ext::oneapi::experimental::fir>
+    : std::true_type {};
+template <>
+struct is_device_copyable<const sycl::ext::oneapi::experimental::fir>
+    : std::true_type {};
+}
+
 int main() {
   // Check only compile-time properties are device-copyable
   using P1 = decltype(sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::baz<1>,
       sycl::ext::oneapi::experimental::boo<TestClass1, TestClass2>,
       sycl::ext::oneapi::experimental::bar));
-
+  using CP1 = const P1;
   static_assert(sycl::is_device_copyable_v<
                 sycl::ext::oneapi::experimental::baz_key::value_t<1>>);
   static_assert(
@@ -23,28 +33,44 @@ int main() {
   static_assert(sycl::is_device_copyable_v<
                 sycl::ext::oneapi::experimental::bar_key::value_t>);
   static_assert(sycl::is_device_copyable_v<P1>);
+  static_assert(sycl::is_device_copyable_v<CP1>);
 
   // Check property list with non-device-copyable property
   using P2 = decltype(sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::bar,
       sycl::ext::oneapi::experimental::foz{42.42, false}));
+  using CP2 = const P2;
   static_assert(
       !sycl::is_device_copyable_v<sycl::ext::oneapi::experimental::foz>);
   static_assert(!sycl::is_device_copyable_v<P2>);
+  static_assert(!sycl::is_device_copyable_v<CP2>);
+
+  // Check property list with explicit device-copyable property
+  using P3 = decltype(sycl::ext::oneapi::experimental::properties(
+      sycl::ext::oneapi::experimental::bar,
+      sycl::ext::oneapi::experimental::fir{42.42, false}));
+  using CP3 = const P3;
+  static_assert(
+      sycl::is_device_copyable_v<sycl::ext::oneapi::experimental::fir>);
+  static_assert(sycl::is_device_copyable_v<P3>);
+  static_assert(sycl::is_device_copyable_v<CP3>);
 
   // Check property list with device-copyable compile-time and runtime
   // properties
-  using P3 = decltype(sycl::ext::oneapi::experimental::properties(
+  using P4 = decltype(sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::baz<1>,
       sycl::ext::oneapi::experimental::foo{1234}));
+  using CP4 = const P4;
   static_assert(
       sycl::is_device_copyable_v<sycl::ext::oneapi::experimental::foo>);
-  static_assert(sycl::is_device_copyable_v<P3>);
+  static_assert(sycl::is_device_copyable_v<P4>);
+  static_assert(sycl::is_device_copyable_v<CP4>);
 
   // Check that device-copyable property list can indeed be used in a kernel
   const auto PropertyList = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::baz<1>,
-      sycl::ext::oneapi::experimental::foo{0});
+      sycl::ext::oneapi::experimental::foo{0},
+      sycl::ext::oneapi::experimental::fir{12.34, true});
 
   sycl::queue Q;
   Q.submit([&](sycl::handler &CGH) {
@@ -53,8 +79,11 @@ int main() {
           sycl::ext::oneapi::experimental::baz_key>();
       decltype(PropertyList)::has_property<
           sycl::ext::oneapi::experimental::foo_key>();
+      decltype(PropertyList)::has_property<
+          sycl::ext::oneapi::experimental::fir_key>();
       PropertyList.get_property<sycl::ext::oneapi::experimental::baz_key>();
       PropertyList.get_property<sycl::ext::oneapi::experimental::foo_key>();
+      PropertyList.get_property<sycl::ext::oneapi::experimental::fir_key>();
     });
   });
   return 0;