[SYCL] Property list check for FPGA mmhost interface (#10405)

For annotated_arg/ptr feature. error out when user are using bad FPGA
properties.

For FPGA properties, the interface configuration cannot be set alone.
The interface configurations have to be set with buffer location
altogether.

Author: Brox Chen

sycl/include/sycl/ext/oneapi/annotated_arg/annotated_arg.hpp

@@ -180,6 +180,10 @@ __SYCL_TYPE(annotated_arg) annotated_arg<T, detail::properties_t<Props...>> {
                 "Property list is invalid.");
   static_assert(check_property_list<T, Props...>::value,
                 "The property list contains invalid property.");
+  // check the set if FPGA specificed properties are used
+  static_assert(detail::checkValidFPGAPropertySet<Props...>::value,
+                "FPGA Interface properties (i.e. awidth, dwidth, etc.)"
+                "can only be set with BufferLocation together.");
 
   annotated_arg() noexcept = default;
   annotated_arg(const annotated_arg &) = default;

sycl/include/sycl/ext/oneapi/annotated_arg/annotated_ptr.hpp

@@ -121,6 +121,12 @@ __SYCL_TYPE(annotated_ptr) annotated_ptr<T, detail::properties_t<Props...>> {
 public:
   static_assert(is_property_list<property_list_t>::value,
                 "Property list is invalid.");
+  static_assert(check_property_list<T *, Props...>::value,
+                "The property list contains invalid property.");
+  // check the set if FPGA specificed properties are used
+  static_assert(detail::checkValidFPGAPropertySet<Props...>::value,
+                "FPGA Interface properties (i.e. awidth, dwidth, etc.)"
+                "can only be set with BufferLocation together.");
 
   annotated_ptr() noexcept = default;
   annotated_ptr(const annotated_ptr &) = default;

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

@@ -348,6 +348,10 @@ struct alignment_key {
 
 template <int K> inline constexpr alignment_key::value_t<K> alignment;
 
+template <typename T, int W>
+struct is_valid_property<T, alignment_key::value_t<W>>
+    : std::bool_constant<std::is_pointer<T>::value> {};
+
 template <> struct is_property_key<alignment_key> : std::true_type {};
 
 template <typename T, typename PropertyListT>
@@ -385,6 +389,23 @@ template <typename... Args>
 struct DeducedProperties<detail::properties_t<Args...>> {
   using type = detail::properties_t<Args...>;
 };
+
+template <typename... Args> struct checkValidFPGAPropertySet {
+  using list = std::tuple<Args...>;
+  static constexpr bool has_BufferLocation =
+      ContainsProperty<buffer_location_key, list>::value;
+
+  static constexpr bool has_InterfaceConfig =
+      ContainsProperty<awidth_key, list>::value &&
+      ContainsProperty<dwidth_key, list>::value &&
+      ContainsProperty<latency_key, list>::value &&
+      ContainsProperty<read_write_mode_key, list>::value &&
+      ContainsProperty<maxburst_key, list>::value &&
+      ContainsProperty<wait_request_key, list>::value &&
+      ContainsProperty<alignment_key, list>::value;
+
+  static constexpr bool value = !(!has_BufferLocation && has_InterfaceConfig);
+};
 } // namespace detail
 
 } // namespace experimental

sycl/test/extensions/annotated_arg/annotated_ptr.cpp

@@ -12,16 +12,20 @@ using namespace sycl;
 using namespace ext::oneapi::experimental;
 
 using annotated_ptr_t1 =
-    annotated_ptr<int, decltype(properties(awidth<32>, dwidth<32>))>;
+    annotated_ptr<int, decltype(properties(buffer_location<0>, awidth<32>,
+                                           dwidth<32>))>;
 
 using annotated_ptr_t2 =
-    annotated_ptr<int,
-                  decltype(properties(conduit, register_map, alignment<8>))>;
+    annotated_ptr<int, decltype(properties(buffer_location<0>, conduit,
+                                           register_map, alignment<8>))>;
 
-using annotated_ptr_t3 = annotated_ptr<int, decltype(properties(awidth<32>))>;
+using annotated_ptr_t3 =
+    annotated_ptr<int, decltype(properties(buffer_location<0>, awidth<32>))>;
 
 struct MyIP {
-  annotated_ptr<int, decltype(properties(awidth<32>, dwidth<32>))> a;
+  annotated_ptr<int, decltype(properties(buffer_location<0>, awidth<32>,
+                                         dwidth<32>))>
+      a;
 
   int b;
 
@@ -38,7 +42,7 @@ struct MyIP {
 
 template <typename T> T foo() {
   auto raw = new int;
-  return annotated_ptr(raw, awidth<32>);
+  return annotated_ptr(raw, buffer_location<0>, awidth<32>);
 }
 
 void TestVectorAddWithAnnotatedMMHosts() {
@@ -60,33 +64,40 @@ void TestVectorAddWithAnnotatedMMHosts() {
   // Construct from raw pointers
   auto tmp11 = annotated_ptr(raw); // empty property list
   // Construct from raw pointers and a property list
-  auto tmp12 = annotated_ptr<int, decltype(properties{awidth<32>})>(
-      raw, properties{awidth<32>});
-  auto tmp14 = annotated_ptr(raw, properties{awidth<32>}); // deduction guide
+  auto tmp12 =
+      annotated_ptr<int, decltype(properties{buffer_location<0>, awidth<32>})>(
+          raw, properties{buffer_location<0>, awidth<32>});
+  auto tmp14 = annotated_ptr(
+      raw, properties{buffer_location<0>, awidth<32>}); // deduction guide
   static_assert(std::is_same<decltype(tmp14), annotated_ptr_t3>::value,
                 "deduction guide failed 1");
   // Construct from raw pointers and variadic properties
-  auto tmp13 = annotated_ptr(raw, dwidth<32>, awidth<32>); // deduction guide
+  auto tmp13 = annotated_ptr(raw, buffer_location<0>, dwidth<32>,
+                             awidth<32>); // deduction guide
   static_assert(std::is_same<decltype(tmp13), annotated_ptr_t1>::value,
                 "deduction guide failed 2");
-  auto tmp15 = annotated_ptr(raw, awidth<32>);
+  auto tmp15 = annotated_ptr(raw, buffer_location<0>, awidth<32>);
   static_assert(std::is_same<decltype(tmp15), annotated_ptr_t3>::value,
                 "deduction guide failed 1");
 
   // Construct from another annotated_ptr
   // templated copy constructor
-  annotated_ptr<int, decltype(properties{awidth<32>, dwidth<32>})> arg11(tmp11);
+  annotated_ptr<int, decltype(properties{buffer_location<0>, awidth<32>,
+                                         dwidth<32>})>
+      arg11(tmp11);
   auto arg12 =
-      annotated_ptr<int, decltype(properties{dwidth<32>, awidth<32>})>(tmp11);
+      annotated_ptr<int, decltype(properties{buffer_location<0>, dwidth<32>,
+                                             awidth<32>})>(tmp11);
 
   // default copy constructor
   auto arg13 = annotated_ptr(tmp12);
   static_assert(std::is_same<decltype(arg13), annotated_ptr_t3>::value,
                 "deduction guide failed 3");
 
   // Construct from another annotated_ptr and a property list
-  annotated_ptr<int, decltype(properties{awidth<32>, dwidth<32>})> arg22(
-      tmp12, properties{dwidth<32>});
+  annotated_ptr<int, decltype(properties{buffer_location<0>, awidth<32>,
+                                         dwidth<32>})>
+      arg22(tmp12, properties{dwidth<32>});
   auto arg23 = annotated_ptr(tmp12, properties{dwidth<32>}); // deduction guide
   static_assert(std::is_same<decltype(arg22), annotated_ptr_t1>::value,
                 "deduction guide failed 4");
@@ -99,7 +110,7 @@ void TestVectorAddWithAnnotatedMMHosts() {
   // properties{dwidth<32>});   // ERR
 
   // Property merge
-  auto arg31 = annotated_ptr_t3(raw, awidth<32>);                         // OK
+  auto arg31 = annotated_ptr_t3(raw, buffer_location<0>, awidth<32>);     // OK
   auto arg32 = annotated_ptr(arg31, properties{dwidth<32>});              // OK
   auto arg33 = annotated_ptr(arg32, properties{dwidth<32>, awidth<32>});  // OK
   auto arg34 = annotated_ptr(arg32, properties{awidth<32>, latency<22>}); // OK