[SYCL] Remove is_property_value/is_property_value_of

The only non-test use was in `syclcompat/traits.hpp` and we can use
`detail::AllPropertyValues` that doesn't require each property to
specialize the trait.

Author: aelovikov-intel

sycl/doc/extensions/experimental/sycl_ext_oneapi_properties.asciidoc

@@ -200,11 +200,10 @@ inline constexpr boo_key::value_t<Ts...> boo;
 === Property traits
 
 All runtime and compile-time-constant properties must have a specialization of 
-`is_property_key` and `is_property_value` that inherits from
-`std::true_type`, and they must have a specialization of `is_property_key_of`
-and `is_property_value_of`
-that inherits from `std::true_type` for each SYCL runtime class that the
-property can be applied to. All have a base case which inherits from `std::false_type`.
+`is_property_key` that inherits from `std::true_type`, and they must have a
+specialization of `is_property_key_of` that inherits from `std::true_type` for
+each SYCL runtime class that the property can be applied to. All have a base
+case which inherits from `std::false_type`.
 
 ```c++
 namespace sycl::ext::oneapi::experimental {
@@ -221,18 +220,6 @@ struct is_property_key_of<foo_key, SyclObjectT> : std::true_type {};
 template<typename SyclObjectT>
 struct is_property_key_of<bar_key, SyclObjectT> : std::true_type {};
 
-// is_property_value and is_property_value_of based on is_property_key(_of)
-template<typename V, typename=void> struct is_property_value;
-template<typename V, typename O, typename=void> struct is_property_value_of;
-// Specialization for runtime properties
-template<typename V> struct is_property_value<V, std::enable_if_t<(sizeof(V)>0)>> : is_property_key<V> {};
-template<typename V, typename O> struct is_property_value_of<V, O, std::enable_if_t<(sizeof(V)>0)>> : is_property_key_of<V,O> {};
-// Specialization for compile-time-constant properties
-template<typename V> struct is_property_value<V, std::void_t<typename V::key_t>> :
-  is_property_key<typename V::key_t> {};
-template<typename V, typename O> struct is_property_value_of<V, O, std::void_t<typename V::key_t>> :
-  is_property_key_of<typename V::key_t, O> {};
-
 } // namespace experimental::oneapi::ext::sycl
 ```
 

sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp

@@ -47,28 +47,6 @@ struct is_property_key_of<cuda::cluster_size_key<2>, T> : std::true_type {};
 template <typename T>
 struct is_property_key_of<cuda::cluster_size_key<3>, T> : std::true_type {};
 
-template <>
-struct is_property_value<cuda::cluster_size_key<1>>
-    : is_property_key<cuda::cluster_size_key<1>> {};
-template <>
-struct is_property_value<cuda::cluster_size_key<2>>
-    : is_property_key<cuda::cluster_size_key<2>> {};
-template <>
-struct is_property_value<cuda::cluster_size_key<3>>
-    : is_property_key<cuda::cluster_size_key<3>> {};
-
-template <typename O>
-struct is_property_value_of<cuda::cluster_size_key<1>, O>
-    : is_property_key_of<cuda::cluster_size_key<1>, O> {};
-
-template <typename O>
-struct is_property_value_of<cuda::cluster_size_key<2>, O>
-    : is_property_key_of<cuda::cluster_size_key<2>, O> {};
-
-template <typename O>
-struct is_property_value_of<cuda::cluster_size_key<3>, O>
-    : is_property_key_of<cuda::cluster_size_key<3>, O> {};
-
 namespace detail {
 template <typename PropertiesT> constexpr std::size_t getClusterDim() {
   if constexpr (PropertiesT::template has_property<

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

@@ -57,22 +57,6 @@ operator!=(const property_value<PropertyT, A...> &,
   return (!std::is_same<A, B>::value || ...);
 }
 
-template <typename V, typename = void> struct is_property_value {
-  static constexpr bool value =
-      detail::IsRuntimeProperty<V>::value && is_property_key<V>::value;
-};
-template <typename V, typename O, typename = void> struct is_property_value_of {
-  static constexpr bool value =
-      detail::IsRuntimeProperty<V>::value && is_property_key_of<V, O>::value;
-};
-// Specialization for compile-time-constant properties
-template <typename V>
-struct is_property_value<V, std::void_t<typename V::key_t>>
-    : is_property_key<typename V::key_t> {};
-template <typename V, typename O>
-struct is_property_value_of<V, O, std::void_t<typename V::key_t>>
-    : is_property_key_of<typename V::key_t, O> {};
-
 namespace detail {
 
 // Specialization of PropertyID for propagating IDs through property_value.

sycl/include/syclcompat/traits.hpp

@@ -249,8 +249,9 @@ inline constexpr bool is_launch_policy_v = is_launch_policy<T>::value;
 
 // Trait to detect if all args are sycl_exp property types
 template <typename... Args>
-using are_all_props = std::conjunction<
-    sycl::ext::oneapi::experimental::is_property_value<Args>...>;
+using are_all_props =
+    sycl::ext::oneapi::experimental::detail::AllPropertyValues<
+        std::tuple<Args...>>;
 
 } // namespace experimental::detail
 

sycl/test/extensions/annotated_arg/annotated_arg_properties.cpp

@@ -18,7 +18,7 @@ static annotated_arg<int *, decltype(properties(buffer_location<1>,
 
 struct A {};
 
-// Checks is_property_key_of and is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<register_map_key, T>::value);
   static_assert(is_property_key_of<conduit_key, T>::value);
@@ -31,19 +31,6 @@ template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<read_write_mode_key, T>::value);
   static_assert(is_property_key_of<maxburst_key, T>::value);
   static_assert(is_property_key_of<wait_request_key, T>::value);
-
-  static_assert(is_property_value_of<decltype(register_map), T>::value);
-  static_assert(is_property_value_of<decltype(conduit), T>::value);
-  static_assert(is_property_value_of<decltype(stable), T>::value);
-
-  static_assert(is_property_value_of<decltype(buffer_location<1>), T>::value);
-  static_assert(is_property_value_of<decltype(awidth<2>), T>::value);
-  static_assert(is_property_value_of<decltype(dwidth<8>), T>::value);
-  static_assert(is_property_value_of<decltype(latency<0>), T>::value);
-  static_assert(is_property_value_of<decltype(read_write_mode_read), T>::value);
-  static_assert(is_property_value_of<decltype(maxburst<1>), T>::value);
-  static_assert(
-      is_property_value_of<decltype(wait_request_requested), T>::value);
 }
 
 int main() {

sycl/test/extensions/annotated_ptr/annotated_ptr_properties.cpp

@@ -16,7 +16,7 @@ static annotated_ptr<int, decltype(properties(buffer_location<1>,
 
 struct A {};
 
-// Checks is_property_key_of and is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<register_map_key, T>::value);
   static_assert(is_property_key_of<conduit_key, T>::value);
@@ -29,23 +29,9 @@ template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<read_write_mode_key, T>::value);
   static_assert(is_property_key_of<maxburst_key, T>::value);
   static_assert(is_property_key_of<wait_request_key, T>::value);
-
-  static_assert(is_property_value_of<decltype(register_map), T>::value);
-  static_assert(is_property_value_of<decltype(conduit), T>::value);
-  static_assert(is_property_value_of<decltype(stable), T>::value);
-
-  static_assert(is_property_value_of<decltype(buffer_location<1>), T>::value);
-  static_assert(is_property_value_of<decltype(awidth<2>), T>::value);
-  static_assert(is_property_value_of<decltype(dwidth<8>), T>::value);
-  static_assert(is_property_value_of<decltype(latency<0>), T>::value);
-  static_assert(is_property_value_of<decltype(read_write_mode_read), T>::value);
-  static_assert(is_property_value_of<decltype(maxburst<1>), T>::value);
-  static_assert(
-      is_property_value_of<decltype(wait_request_requested), T>::value);
 }
 
-// Checks is_property_key_of and is_property_value_of are false for non-pointer
-// type T.
+// Checks is_property_key_of is false for non-pointer type T.
 template <typename T> void checkIsValidPropertyOfNonPtr() {
   static_assert(
       is_valid_property<T, decltype(wait_request_not_requested)>::value ==

sycl/test/extensions/device_global/device_global_properties.cpp

@@ -25,23 +25,12 @@ static device_global<int, decltype(properties(
                               device_image_scope, init_mode_reprogram))>
     DeviceGlobal5;
 
-// Checks is_property_key_of and is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<device_image_scope_key, T>::value);
   static_assert(is_property_key_of<host_access_key, T>::value);
   static_assert(is_property_key_of<init_mode_key, T>::value);
   static_assert(is_property_key_of<implement_in_csr_key, T>::value);
-
-  static_assert(is_property_value_of<decltype(device_image_scope), T>::value);
-  static_assert(is_property_value_of<decltype(host_access_read), T>::value);
-  static_assert(is_property_value_of<decltype(host_access_write), T>::value);
-  static_assert(
-      is_property_value_of<decltype(host_access_read_write), T>::value);
-  static_assert(is_property_value_of<decltype(host_access_none), T>::value);
-  static_assert(is_property_value_of<decltype(init_mode_reset), T>::value);
-  static_assert(is_property_value_of<decltype(init_mode_reprogram), T>::value);
-  static_assert(is_property_value_of<decltype(implement_in_csr_on), T>::value);
-  static_assert(is_property_value_of<decltype(implement_in_csr_off), T>::value);
 }
 
 int main() {
@@ -50,16 +39,6 @@ int main() {
   static_assert(is_property_key<init_mode_key>::value);
   static_assert(is_property_key<implement_in_csr_key>::value);
 
-  static_assert(is_property_value<decltype(device_image_scope)>::value);
-  static_assert(is_property_value<decltype(host_access_read)>::value);
-  static_assert(is_property_value<decltype(host_access_write)>::value);
-  static_assert(is_property_value<decltype(host_access_read_write)>::value);
-  static_assert(is_property_value<decltype(host_access_none)>::value);
-  static_assert(is_property_value<decltype(init_mode_reset)>::value);
-  static_assert(is_property_value<decltype(init_mode_reprogram)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr_on)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr_off)>::value);
-
   checkIsPropertyOf<decltype(DeviceGlobal1)>();
   static_assert(DeviceGlobal1.has_property<device_image_scope_key>());
   static_assert(!DeviceGlobal1.has_property<host_access_key>());

sycl/test/extensions/fpga_mem/fpga_mem_properties.cpp

@@ -22,7 +22,7 @@ static intel::fpga_mem<int, decltype(oneapi::properties(
                                 intel::bi_directional_ports_true))>
     mem_multi;
 
-// Checks is_property_key_of and oneapi::is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(oneapi::is_property_key_of<intel::resource_key, T>::value);
   static_assert(oneapi::is_property_key_of<intel::num_banks_key, T>::value);
@@ -51,34 +51,6 @@ int main() {
   static_assert(oneapi::is_property_key<intel::max_private_copies_key>::value);
   static_assert(oneapi::is_property_key<intel::num_replicates_key>::value);
 
-  // Are all common values usable
-  static_assert(
-      oneapi::is_property_value<decltype(intel::resource_mlab)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::resource_block_ram)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::num_banks<8>)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::stride_size<8>)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::word_size<32>)>::value);
-  static_assert(oneapi::is_property_value<
-                decltype(intel::bi_directional_ports_false)>::value);
-  static_assert(oneapi::is_property_value<
-                decltype(intel::bi_directional_ports_true)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::clock_2x_false)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::clock_2x_true)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::ram_stitching_min_ram)>::value);
-  static_assert(oneapi::is_property_value<
-                decltype(intel::ram_stitching_max_fmax)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::max_private_copies<8>)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::num_replicates<8>)>::value);
-
   // Check that only the property that are expected are associated with obj
   checkIsPropertyOf<decltype(mem_num)>();
   static_assert(mem_num.has_property<intel::num_banks_key>());

sycl/test/extensions/properties/properties_device_global.cpp

@@ -17,20 +17,6 @@ int main() {
   static_assert(is_property_key<init_mode_key>::value);
   static_assert(is_property_key<implement_in_csr_key>::value);
 
-  // Check that is_property_value is correctly specialized.
-  static_assert(is_property_value<decltype(device_image_scope)>::value);
-  static_assert(is_property_value<decltype(host_access<TestAccess>)>::value);
-  static_assert(is_property_value<decltype(host_access_read)>::value);
-  static_assert(is_property_value<decltype(host_access_write)>::value);
-  static_assert(is_property_value<decltype(host_access_read_write)>::value);
-  static_assert(is_property_value<decltype(host_access_none)>::value);
-  static_assert(is_property_value<decltype(init_mode<TestTrigger>)>::value);
-  static_assert(is_property_value<decltype(init_mode_reprogram)>::value);
-  static_assert(is_property_value<decltype(init_mode_reset)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr<true>)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr_on)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr_off)>::value);
-
   // Checks that fully specialized properties are the same as the templated
   // variants.
   static_assert(std::is_same_v<decltype(host_access_read),