Remove make_owner, instroduce smart_malloc_device, etc.

The smart_malloc_device<T>(count, q) makes USM allocation
and returns a unique_ptr<T, USMDeleter> which owns the
allocation. The function throws an exception (std::runtime_error)
if USM allocation is not successful.

The usage is as follows:

```
  auto alloc_owner = smart_malloc_device<T>(count, q);
  T *data = alloc_owner.get();

  [..SNIP..]

  <submit host task to deallocate memory>
  // release ownership of USM memory from smart pointer
  // since it is now managed by the host task which was
  // successfully submitted.
  alloc_owner.release();

  [...SNIP...]
```

Author: oleksandr-pavlyk

dpctl/tensor/libtensor/include/kernels/sorting/radix_sort.hpp

@@ -30,7 +30,6 @@
 #include <array>
 #include <cstdint>
 #include <limits>
-#include <memory>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
@@ -1589,15 +1588,12 @@ sycl::event parallel_radix_sort_impl(sycl::queue &exec_q,
         using CountT = std::uint32_t;
 
         // memory for storing count and offset values
-        CountT *count_ptr =
-            sycl::malloc_device<CountT>(n_iters * n_counts, exec_q);
+        auto count_owner =
+            dpctl::tensor::alloc_utils::smart_malloc_device<CountT>(
+                n_iters * n_counts, exec_q);
 
-        if (nullptr == count_ptr) {
-            throw std::runtime_error("Could not allocate USM-device memory");
-        }
+        CountT *count_ptr = count_owner.get();
 
-        auto count_owner =
-            dpctl::tensor::alloc_utils::make_owner(count_ptr, exec_q);
         constexpr std::uint32_t zero_radix_iter{0};
 
         if constexpr (std::is_same_v<KeyT, bool>) {
@@ -1621,14 +1617,11 @@ sycl::event parallel_radix_sort_impl(sycl::queue &exec_q,
             return sort_ev;
         }
 
-        ValueT *tmp_arr =
-            sycl::malloc_device<ValueT>(n_iters * n_to_sort, exec_q);
-        if (nullptr == tmp_arr) {
-            throw std::runtime_error("Could not allocate USM-device memory");
-        }
-
         auto tmp_arr_owner =
-            dpctl::tensor::alloc_utils::make_owner(tmp_arr, exec_q);
+            dpctl::tensor::alloc_utils::smart_malloc_device<ValueT>(
+                n_iters * n_to_sort, exec_q);
+
+        ValueT *tmp_arr = tmp_arr_owner.get();
 
         // iterations per each bucket
         assert("Number of iterations must be even" && radix_iters % 2 == 0);
@@ -1776,13 +1769,12 @@ radix_argsort_axis1_contig_impl(sycl::queue &exec_q,
         reinterpret_cast<IndexTy *>(res_cp) + iter_res_offset + sort_res_offset;
 
     const std::size_t total_nelems = iter_nelems * sort_nelems;
-    IndexTy *workspace = sycl::malloc_device<IndexTy>(total_nelems, exec_q);
-
-    if (nullptr == workspace) {
-        throw std::runtime_error("Could not allocate workspace on device");
-    }
     auto workspace_owner =
-        dpctl::tensor::alloc_utils::make_owner(workspace, exec_q);
+        dpctl::tensor::alloc_utils::smart_malloc_device<IndexTy>(total_nelems,
+                                                                 exec_q);
+
+    // get raw USM pointer
+    IndexTy *workspace = workspace_owner.get();
 
     using IdentityProjT = radix_sort_details::IdentityProj;
     using IndexedProjT =

dpctl/tensor/libtensor/include/kernels/sorting/topk.hpp

@@ -29,7 +29,6 @@
 #include <cstdint>
 #include <iterator>
 #include <limits>
-#include <memory>
 #include <stdexcept>
 #include <vector>
 
@@ -92,13 +91,11 @@ topk_full_merge_sort_impl(sycl::queue &exec_q,
                           const CompT &comp,
                           const std::vector<sycl::event> &depends)
 {
-    IndexTy *index_data =
-        sycl::malloc_device<IndexTy>(iter_nelems * axis_nelems, exec_q);
-    if (index_data == nullptr) {
-        throw std::runtime_error("Unable to allocate device_memory");
-    }
     auto index_data_owner =
-        dpctl::tensor::alloc_utils::make_owner(index_data, exec_q);
+        dpctl::tensor::alloc_utils::smart_malloc_device<IndexTy>(
+            iter_nelems * axis_nelems, exec_q);
+    // extract USM pointer
+    IndexTy *index_data = index_data_owner.get();
 
     using IotaKernelName = topk_populate_index_data_krn<argTy, IndexTy, CompT>;
 
@@ -288,13 +285,11 @@ sycl::event topk_merge_impl(
                                              index_comp, depends);
         }
 
-        IndexTy *index_data =
-            sycl::malloc_device<IndexTy>(iter_nelems * alloc_len, exec_q);
-        if (index_data == nullptr) {
-            throw std::runtime_error("Unable to allocate device_memory");
-        }
         auto index_data_owner =
-            dpctl::tensor::alloc_utils::make_owner(index_data, exec_q);
+            dpctl::tensor::alloc_utils::smart_malloc_device<IndexTy>(
+                iter_nelems * alloc_len, exec_q);
+        // get raw USM pointer
+        IndexTy *index_data = index_data_owner.get();
 
         // no need to populate index data: SLM will be populated with default
         // values
@@ -482,16 +477,12 @@ sycl::event topk_radix_impl(sycl::queue &exec_q,
 
     const std::size_t total_nelems = iter_nelems * axis_nelems;
     const std::size_t padded_total_nelems = ((total_nelems + 63) / 64) * 64;
-    IndexTy *workspace = sycl::malloc_device<IndexTy>(
-        padded_total_nelems + total_nelems, exec_q);
-
-    if (nullptr == workspace) {
-        throw std::runtime_error(
-            "Not enough device memory for radix sort topk");
-    }
     auto workspace_owner =
-        dpctl::tensor::alloc_utils::make_owner(workspace, exec_q);
+        dpctl::tensor::alloc_utils::smart_malloc_device<IndexTy>(
+            padded_total_nelems + total_nelems, exec_q);
 
+    // get raw USM pointer
+    IndexTy *workspace = workspace_owner.get();
     IndexTy *tmp_tp = workspace + padded_total_nelems;
 
     using IdentityProjT = radix_sort_details::IdentityProj;

dpctl/tensor/libtensor/include/utils/sycl_alloc_utils.hpp

@@ -29,6 +29,7 @@
 #include <exception>
 #include <iostream>
 #include <memory>
+#include <stdexcept>
 
 #include "sycl/sycl.hpp"
 
@@ -95,12 +96,48 @@ class USMDeleter
 };
 
 template <typename T>
-std::unique_ptr<T, USMDeleter> make_owner(T *ptr, const sycl::queue &q)
+std::unique_ptr<T, USMDeleter>
+smart_malloc(std::size_t count,
+             const sycl::queue &q,
+             sycl::usm::alloc kind,
+             const sycl::property_list &propList = {})
 {
+    T *ptr = sycl::malloc<T>(count, q, kind, propList);
+    if (nullptr == ptr) {
+        throw std::runtime_error("Unable to allocate device_memory");
+    }
+
     auto usm_deleter = USMDeleter(q);
     return std::unique_ptr<T, USMDeleter>(ptr, usm_deleter);
 }
 
+template <typename T>
+std::unique_ptr<T, USMDeleter>
+smart_malloc_device(std::size_t count,
+                    const sycl::queue &q,
+                    const sycl::property_list &propList = {})
+{
+    return smart_malloc<T>(count, q, sycl::usm::alloc::device, propList);
+}
+
+template <typename T>
+std::unique_ptr<T, USMDeleter>
+smart_malloc_shared(std::size_t count,
+                    const sycl::queue &q,
+                    const sycl::property_list &propList = {})
+{
+    return smart_malloc<T>(count, q, sycl::usm::alloc::shared, propList);
+}
+
+template <typename T>
+std::unique_ptr<T, USMDeleter>
+smart_malloc_jost(std::size_t count,
+                  const sycl::queue &q,
+                  const sycl::property_list &propList = {})
+{
+    return smart_malloc<T>(count, q, sycl::usm::alloc::host, propList);
+}
+
 } // end of namespace alloc_utils
 } // end of namespace tensor
 } // end of namespace dpctl