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

  CONFLICT (content): Merge conflict in sycl/source/detail/sycl_mem_obj_t.hpp

Author: wwXing0

sycl/doc/extensions/proposed/sycl_ext_oneapi_graph.asciidoc

@@ -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_arg.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/annotated_ptr.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/include/sycl/ext/oneapi/annotated_arg/properties.hpp

@@ -1176,7 +1176,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
   // We can't cast between ur_native_handle_t and CUdevice, so memcpy the bits
   // instead
   CUdevice CuDevice = 0;
-  memcpy(&CuDevice, hNativeDevice, sizeof(CUdevice));
+  memcpy(&CuDevice, &hNativeDevice, sizeof(CUdevice));
 
   auto IsDevice = [=](std::unique_ptr<ur_device_handle_t_> &Dev) {
     return Dev->get() == CuDevice;

sycl/plugins/unified_runtime/ur/adapters/cuda/device.cpp

@@ -131,8 +131,7 @@ cudaToUrImageChannelFormat(CUarray_format cuda_format,
   }
 }
 
-ur_result_t urTextureCreate(ur_context_handle_t hContext,
-                            ur_sampler_handle_t hSampler,
+ur_result_t urTextureCreate(ur_sampler_handle_t hSampler,
                             const ur_image_desc_t *pImageDesc,
                             CUDA_RESOURCE_DESC ResourceDesc,
                             ur_exp_image_handle_t *phRetImage) {
@@ -147,7 +146,7 @@ ur_result_t urTextureCreate(ur_context_handle_t hContext,
     /// |       1        | filter mode
     /// |       0        | normalize coords
     CUDA_TEXTURE_DESC ImageTexDesc = {};
-    CUaddress_mode AddrMode;
+    CUaddress_mode AddrMode = {};
     ur_sampler_addressing_mode_t AddrModeProp = hSampler->getAddressingMode();
     if (AddrModeProp == (UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE -
                          UR_SAMPLER_ADDRESSING_MODE_NONE)) {
@@ -465,8 +464,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp(
       return UR_RESULT_ERROR_INVALID_VALUE;
     }
 
-    UR_CHECK_ERROR(urTextureCreate(hContext, hSampler, pImageDesc,
-                                   image_res_desc, phImage));
+    UR_CHECK_ERROR(
+        urTextureCreate(hSampler, pImageDesc, image_res_desc, phImage));
 
     auto urMemObj = std::unique_ptr<ur_mem_handle_t_>(new ur_mem_handle_t_{
         hContext, (CUarray)hImageMem, (CUtexObject)*phImage, hSampler,

sycl/plugins/unified_runtime/ur/adapters/cuda/image.cpp

@@ -185,7 +185,8 @@ class __SYCL_EXPORT SYCLMemObjT : public SYCLMemObjI {
         F(HostPtr);
       });
     }
-    if(HostPtr){
+
+    if (HostPtr) {
       if (canReuseHostPtr(HostPtr, RequiredAlign)) {
         MUserPtr = HostPtr;
       } else {

sycl/source/detail/sycl_mem_obj_t.hpp

@@ -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