Align with spec changes

Author: omarahmed1111

sycl/include/sycl/ext/oneapi/experimental/async_alloc/memory_pool.hpp

@@ -25,34 +25,6 @@ class memory_pool_impl;
 /// Memory pool
 class __SYCL_EXPORT memory_pool {
 public:
-  // Type to store pool properties values.
-  // Every property is represented by a pair that represent
-  // (is_property_assigned, property_value)
-  struct pool_properties {
-    std::pair<bool, size_t> initial_threshold;
-    std::pair<bool, size_t> maximum_size;
-    std::pair<bool, bool> read_only;
-    std::pair<bool, bool> zero_init;
-  };
-
-  // NOT SUPPORTED: Host side pools unsupported.
-  template <typename Properties = empty_properties_t,
-            typename = std::enable_if_t<
-                detail::all_are_properties_of_v<memory_pool, Properties>>>
-  memory_pool(const sycl::context &, sycl::usm::alloc kind, Properties = {}) {
-    if (kind == sycl::usm::alloc::device || kind == sycl::usm::alloc::shared)
-      throw sycl::exception(sycl::make_error_code(sycl::errc::invalid),
-                            "Device and shared allocation kinds are disallowed "
-                            "without specifying a device!");
-    if (kind == sycl::usm::alloc::unknown)
-      throw sycl::exception(sycl::make_error_code(sycl::errc::invalid),
-                            "Unknown allocation kinds are disallowed!");
-
-    throw sycl::exception(
-        sycl::make_error_code(sycl::errc::feature_not_supported),
-        "Host allocated pools are unsupported!");
-  }
-
   template <typename Properties = empty_properties_t,
             typename = std::enable_if_t<
                 detail::all_are_properties_of_v<memory_pool, Properties>>>
@@ -67,16 +39,6 @@ class __SYCL_EXPORT memory_pool {
               Properties props = {})
       : memory_pool(q.get_context(), q.get_device(), kind, props) {}
 
-  // NOT SUPPORTED: Creating a pool from an existing allocation is unsupported.
-  template <typename Properties = empty_properties_t,
-            typename = std::enable_if_t<
-                detail::all_are_properties_of_v<memory_pool, Properties>>>
-  memory_pool(const sycl::context &, void *, size_t, Properties = {}) {
-    throw sycl::exception(
-        sycl::make_error_code(sycl::errc::feature_not_supported),
-        "Creating a pool from an existing allocation is unsupported!");
-  }
-
   ~memory_pool() = default;
 
   // Copy constructible/assignable, move constructible/assignable.
@@ -99,50 +61,20 @@ class __SYCL_EXPORT memory_pool {
 
   void increase_threshold_to(size_t newThreshold);
 
-  // Property getters.
-  template <typename PropertyT> bool has_property() const noexcept {
-    const auto props = getProps();
-    if constexpr (std::is_same_v<PropertyT, initial_threshold>) {
-      return props.initial_threshold.first;
-    }
-    if constexpr (std::is_same_v<PropertyT, maximum_size>) {
-      return props.maximum_size.first;
-    }
-    if constexpr (std::is_same_v<PropertyT, read_only>) {
-      return props.read_only.first;
-    }
-    if constexpr (std::is_same_v<PropertyT, zero_init>) {
-      return props.zero_init.first;
-    }
-    return false;
-  }
-
-  template <typename PropertyT> PropertyT get_property() const {
-    if (!has_property<PropertyT>())
-      throw sycl::exception(make_error_code(errc::invalid),
-                            "The property is not found");
-    const auto props = getProps();
-    if constexpr (std::is_same_v<PropertyT, initial_threshold>) {
-      return initial_threshold(props.initial_threshold.second);
-    }
-    if constexpr (std::is_same_v<PropertyT, maximum_size>) {
-      return maximum_size(props.maximum_size.second);
-    }
-    if constexpr (std::is_same_v<PropertyT, read_only>) {
-      return read_only();
-    }
-    if constexpr (std::is_same_v<PropertyT, zero_init>) {
-      return zero_init();
-    }
-  }
-
 protected:
+  struct pool_properties {
+    std::pair<bool, size_t> initial_threshold;
+    std::pair<bool, size_t> maximum_size;
+    std::pair<bool, bool> zero_init;
+  };
+
   std::shared_ptr<detail::memory_pool_impl> impl;
 
   memory_pool(std::shared_ptr<detail::memory_pool_impl> Impl) : impl(Impl) {}
 
   memory_pool(const sycl::context &ctx, const sycl::device &dev,
-              const sycl::usm::alloc kind, const pool_properties &props);
+              sycl::usm::alloc kind, pool_properties props);
+
   template <class Obj>
   friend const decltype(Obj::impl) &
   sycl::detail::getSyclObjImpl(const Obj &SyclObject);
@@ -154,31 +86,22 @@ class __SYCL_EXPORT memory_pool {
   friend T sycl::detail::createSyclObjFromImpl(
       std::add_lvalue_reference_t<const decltype(T::impl)> ImplObj);
 
-  const pool_properties &getProps() const;
-
-  template <typename Properties = empty_properties_t>
-  pool_properties stripProps(Properties props) {
-    pool_properties PoolProps{};
-
-    if constexpr (decltype(props)::template has_property<
-                      initial_threshold_key>()) {
-      PoolProps.initial_threshold = {
+  template <typename Properties> pool_properties stripProps(Properties props) {
+    pool_properties poolProps{};
+    if constexpr (decltype(props)::template has_property<initial_threshold>()) {
+      poolProps.initial_threshold = {
           true, props.template get_property<initial_threshold>().value};
     }
 
-    if constexpr (decltype(props)::template has_property<maximum_size_key>()) {
-      PoolProps.maximum_size = {
+    if constexpr (decltype(props)::template has_property<maximum_size>()) {
+      poolProps.maximum_size = {
           true, props.template get_property<maximum_size>().value};
     }
 
-    if constexpr (decltype(props)::template has_property<read_only_key>()) {
-      PoolProps.read_only = {true, true};
-    }
-
-    if constexpr (decltype(props)::template has_property<zero_init_key>()) {
-      PoolProps.zero_init = {true, true};
+    if constexpr (decltype(props)::template has_property<zero_init>()) {
+      poolProps.zero_init = {true, true};
     }
-    return PoolProps;
+    return poolProps;
   }
 };
 

sycl/include/sycl/ext/oneapi/experimental/async_alloc/memory_pool_properties.hpp

@@ -50,32 +50,12 @@ inline bool operator!=(const maximum_size &lhs, const maximum_size &rhs) {
   return !(lhs == rhs);
 }
 
-// Property that provides a performance hint that all allocations from this pool
-// will only be read from within SYCL kernel functions.
-// enum class read_only_enum { none, read_only };
-struct read_only
-    : detail::run_time_property_key<read_only, detail::PropKind::ReadOnly> {
-  // read_only(read_only_enum mode) : value(mode) {}
-  read_only() {};
-
-  // read_only_enum value;
-};
-
-using read_only_key = read_only;
-inline bool operator==(const read_only &, const read_only &) { return true; }
-inline bool operator!=(const read_only &lhs, const read_only &rhs) {
-  return !(lhs == rhs);
-}
-
 // Property that initial allocations to a pool (not subsequent allocations from
 // prior frees) are iniitialised to zero.
 // enum class zero_init_enum { none, zero_init };
 struct zero_init
     : detail::run_time_property_key<zero_init, detail::PropKind::ZeroInit> {
-  // zero_init(zero_init_enum mode) : value(mode) {}
   zero_init() {};
-
-  // zero_init_enum value;
 };
 
 using zero_init_key = zero_init;
@@ -85,16 +65,14 @@ inline bool operator!=(const zero_init &lhs, const zero_init &rhs) {
 }
 
 template <>
-struct is_property_key_of<initial_threshold, memory_pool> : std::true_type {};
-
-template <>
-struct is_property_key_of<maximum_size, memory_pool> : std::true_type {};
+struct is_property_key_of<initial_threshold_key, memory_pool> : std::true_type {
+};
 
 template <>
-struct is_property_key_of<read_only, memory_pool> : std::true_type {};
+struct is_property_key_of<maximum_size_key, memory_pool> : std::true_type {};
 
 template <>
-struct is_property_key_of<zero_init, memory_pool> : std::true_type {};
+struct is_property_key_of<zero_init_key, memory_pool> : std::true_type {};
 
 } // namespace ext::oneapi::experimental
 } // namespace _V1

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

@@ -227,7 +227,6 @@ enum PropKind : uint32_t {
   NativeLocalBlockIO = 82,
   InitialThreshold = 83,
   MaximumSize = 84,
-  ReadOnly = 85,
   ZeroInit = 86,
   // PropKindSize must always be the last value.
   PropKindSize = 87,

sycl/source/detail/context_impl.cpp

@@ -9,6 +9,7 @@
 #include <detail/context_impl.hpp>
 #include <detail/context_info.hpp>
 #include <detail/event_info.hpp>
+#include <detail/memory_pool_impl.hpp>
 #include <detail/platform_impl.hpp>
 #include <detail/queue_impl.hpp>
 #include <sycl/detail/common.hpp>
@@ -601,9 +602,7 @@ context_impl::get_default_memory_pool(const context &Context,
   auto MemPoolImplPtr = std::make_shared<
       sycl::ext::oneapi::experimental::detail::memory_pool_impl>(
       Context, Device, sycl::usm::alloc::device, PoolHandle,
-      true /*Default pool*/,
-      ext::oneapi::experimental::memory_pool::
-          pool_properties{} /*Empty Properties*/);
+      true /*Default pool*/);
 
   // Hold onto a weak_ptr of the memory_pool_impl. Prevents circular
   // dependencies between the context_impl and memory_pool_impl.

sycl/source/detail/graph_memory_pool.cpp

@@ -37,9 +37,6 @@ graph_mem_pool::malloc(size_t Size, usm::alloc AllocType,
     if (Props.zero_init.second) {
       AllocInfo.ZeroInit = true;
     }
-    if (Props.read_only.second) {
-      AllocInfo.ReadOnly = true;
-    }
   }
 
   switch (AllocType) {

sycl/source/detail/memory_pool.cpp

@@ -27,10 +27,6 @@ __SYCL_EXPORT size_t memory_pool::get_threshold() const {
   return impl->get_threshold();
 }
 
-const memory_pool::pool_properties &memory_pool::getProps() const {
-  return impl->getProps();
-}
-
 __SYCL_EXPORT size_t memory_pool::get_reserved_size_current() const {
   return impl->get_reserved_size_current();
 }
@@ -45,11 +41,9 @@ __SYCL_EXPORT void memory_pool::increase_threshold_to(size_t newThreshold) {
     impl->set_new_threshold(newThreshold);
 }
 
-__SYCL_EXPORT memory_pool::memory_pool(const sycl::context &ctx,
-                                       const sycl::device &dev,
-                                       sycl::usm::alloc kind,
-                                       const pool_properties &props) {
-
+memory_pool::memory_pool(const sycl::context &ctx, const sycl::device &dev,
+                         sycl::usm::alloc kind,
+                         memory_pool::pool_properties props) {
   if (kind == sycl::usm::alloc::host)
     throw sycl::exception(
         sycl::make_error_code(sycl::errc::invalid),
@@ -60,7 +54,11 @@ __SYCL_EXPORT memory_pool::memory_pool(const sycl::context &ctx,
         sycl::make_error_code(sycl::errc::feature_not_supported),
         "Only device allocated memory pools are supported!");
 
-  impl = std::make_shared<detail::memory_pool_impl>(ctx, dev, kind, props);
+  detail::pool_properties poolProps{
+      {props.initial_threshold.first, props.initial_threshold.second},
+      {props.maximum_size.first, props.maximum_size.second},
+      {props.zero_init.first, props.zero_init.second}};
+  impl = std::make_shared<detail::memory_pool_impl>(ctx, dev, kind, poolProps);
 }
 
 } // namespace ext::oneapi::experimental

sycl/source/detail/memory_pool_impl.cpp

@@ -20,18 +20,17 @@ namespace detail {
 
 // <--- Helpers --->
 namespace {
-ur_usm_pool_handle_t
-create_memory_pool_device(const sycl::context &ctx, const sycl::device &dev,
-                          const size_t threshold, const size_t maxSize,
-                          const bool readOnly, const bool zeroInit) {
+ur_usm_pool_handle_t create_memory_pool_device(const sycl::context &ctx,
+                                               const sycl::device &dev,
+                                               const size_t threshold,
+                                               const size_t maxSize,
+                                               const bool zeroInit) {
   auto [urDevice, urCtx, Adapter] = get_ur_handles(dev, ctx);
 
   ur_usm_pool_limits_desc_t LimitsDesc{UR_STRUCTURE_TYPE_USM_POOL_LIMITS_DESC,
                                        nullptr, maxSize, threshold};
 
   ur_usm_pool_flags_t Flags = {UR_USM_POOL_FLAG_USE_NATIVE_MEMORY_POOL_EXP};
-  if (readOnly)
-    Flags += UR_USM_POOL_FLAG_READ_ONLY_EXP;
   if (zeroInit)
     Flags += UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK;
 
@@ -61,14 +60,14 @@ void destroy_memory_pool(const sycl::context &ctx, const sycl::device &dev,
 memory_pool_impl::memory_pool_impl(const sycl::context &ctx,
                                    const sycl::device &dev,
                                    const sycl::usm::alloc kind,
-                                   const memory_pool::pool_properties &props)
+                                   const pool_properties props)
     : MContextImplPtr(sycl::detail::getSyclObjImpl(ctx)), MDevice(dev),
       MKind(kind), MProps(props) {
 
   if (kind == sycl::usm::alloc::device)
     MPoolHandle = create_memory_pool_device(
         ctx, dev, MProps.initial_threshold.second, MProps.maximum_size.second,
-        MProps.read_only.second, MProps.zero_init.second);
+        MProps.zero_init.second);
   else
     throw sycl::exception(
         sycl::make_error_code(sycl::errc::feature_not_supported),
@@ -80,13 +79,12 @@ memory_pool_impl::memory_pool_impl(const sycl::context &ctx,
                                    const sycl::usm::alloc kind,
                                    ur_usm_pool_handle_t poolHandle,
                                    const bool isDefaultPool,
-                                   const memory_pool::pool_properties &props)
+                                   const pool_properties props)
     : MContextImplPtr(sycl::detail::getSyclObjImpl(ctx)), MDevice(dev),
       MKind(kind), MPoolHandle(poolHandle), MIsDefaultPool(isDefaultPool),
       MProps(props) {}
 
 memory_pool_impl::~memory_pool_impl() {
-
   // Default memory pools cannot be destroyed.
   if (MIsDefaultPool)
     return;

sycl/source/detail/memory_pool_impl.hpp

@@ -18,15 +18,23 @@ inline namespace _V1 {
 namespace ext::oneapi::experimental {
 namespace detail {
 
+// Type to store pool properties values.
+// Every property is represented by a pair that represent
+// (is_property_assigned, property_value)
+struct pool_properties {
+  std::pair<bool, size_t> initial_threshold;
+  std::pair<bool, size_t> maximum_size;
+  std::pair<bool, bool> zero_init;
+};
+
 class memory_pool_impl {
 public:
   memory_pool_impl(const sycl::context &ctx, const sycl::device &dev,
                    const sycl::usm::alloc kind,
-                   const memory_pool::pool_properties &props);
+                   const pool_properties props = {});
   memory_pool_impl(const sycl::context &ctx, const sycl::device &dev,
                    const sycl::usm::alloc kind, ur_usm_pool_handle_t poolHandle,
-                   const bool isDefaultPool,
-                   const memory_pool::pool_properties &props);
+                   const bool isDefaultPool, const pool_properties props = {});
 
   ~memory_pool_impl();
 
@@ -39,7 +47,7 @@ class memory_pool_impl {
     return sycl::detail::createSyclObjFromImpl<sycl::context>(MContextImplPtr);
   }
   sycl::usm::alloc get_alloc_kind() const { return MKind; }
-  const memory_pool::pool_properties &getProps() const { return MProps; }
+  const pool_properties &getProps() const { return MProps; }
 
   // Returns backend specific values.
   size_t get_allocation_chunk_size() const;
@@ -59,7 +67,7 @@ class memory_pool_impl {
   sycl::usm::alloc MKind;
   ur_usm_pool_handle_t MPoolHandle{0};
   bool MIsDefaultPool = false;
-  memory_pool::pool_properties MProps;
+  pool_properties MProps;
 };
 
 } // namespace detail