change dpctl namespace to dpnp

Author: ndgrigorian

dpnp/backend/extensions/blas/blas_py.cpp

@@ -60,15 +60,15 @@ void init_dispatch_vectors_tables(void)
     blas_ns::init_syrk_dispatch_vector();
 }
 
-static dot_impl_fn_ptr_t dot_dispatch_vector[dpctl_td_ns::num_types];
-static dot_impl_fn_ptr_t dotc_dispatch_vector[dpctl_td_ns::num_types];
-static dot_impl_fn_ptr_t dotu_dispatch_vector[dpctl_td_ns::num_types];
+static dot_impl_fn_ptr_t dot_dispatch_vector[dpnp_td_ns::num_types];
+static dot_impl_fn_ptr_t dotc_dispatch_vector[dpnp_td_ns::num_types];
+static dot_impl_fn_ptr_t dotu_dispatch_vector[dpnp_td_ns::num_types];
 
 PYBIND11_MODULE(_blas_impl, m)
 {
     init_dispatch_vectors_tables();
 
-    using arrayT = dpctl::tensor::usm_ndarray;
+    using arrayT = dpnp::tensor::usm_ndarray;
     using event_vecT = std::vector<sycl::event>;
 
     {

dpnp/backend/extensions/blas/dot.hpp

@@ -35,7 +35,7 @@
 namespace dpnp::extensions::blas
 {
 namespace mkl_blas = oneapi::mkl::blas;
-namespace type_utils = dpctl::tensor::type_utils;
+namespace type_utils = dpnp::tensor::type_utils;
 
 template <typename T>
 static sycl::event dot_impl(sycl::queue &exec_q,

dpnp/backend/extensions/blas/dot_common.hpp

@@ -32,7 +32,7 @@
 
 #include <pybind11/pybind11.h>
 
-// dpctl tensor headers
+// dpnp tensor headers
 #include "utils/memory_overlap.hpp"
 #include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
@@ -51,14 +51,14 @@ typedef sycl::event (*dot_impl_fn_ptr_t)(sycl::queue &,
                                          char *,
                                          const std::vector<sycl::event> &);
 
-namespace dpctl_td_ns = dpctl::tensor::type_dispatch;
+namespace dpnp_td_ns = dpnp::tensor::type_dispatch;
 namespace py = pybind11;
 
 std::pair<sycl::event, sycl::event>
     dot_func(sycl::queue &exec_q,
-             const dpctl::tensor::usm_ndarray &vectorX,
-             const dpctl::tensor::usm_ndarray &vectorY,
-             const dpctl::tensor::usm_ndarray &result,
+             const dpnp::tensor::usm_ndarray &vectorX,
+             const dpnp::tensor::usm_ndarray &vectorY,
+             const dpnp::tensor::usm_ndarray &result,
              const std::vector<sycl::event> &depends,
              const dot_impl_fn_ptr_t *dot_dispatch_vector)
 {
@@ -84,7 +84,7 @@ std::pair<sycl::event, sycl::event>
             ", but a 0-dimensional array is expected.");
     }
 
-    auto const &overlap = dpctl::tensor::overlap::MemoryOverlap();
+    auto const &overlap = dpnp::tensor::overlap::MemoryOverlap();
     if (overlap(vectorX, result)) {
         throw py::value_error(
             "The first input array and output array are overlapping "
@@ -96,17 +96,17 @@ std::pair<sycl::event, sycl::event>
             "segments of memory");
     }
 
-    if (!dpctl::utils::queues_are_compatible(
+    if (!dpnp::utils::queues_are_compatible(
             exec_q,
             {vectorX.get_queue(), vectorY.get_queue(), result.get_queue()})) {
         throw py::value_error(
             "USM allocations are not compatible with the execution queue.");
     }
 
     const int src_nelems = 1;
-    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(result);
-    dpctl::tensor::validation::AmpleMemory::throw_if_not_ample(result,
-                                                               src_nelems);
+    dpnp::tensor::validation::CheckWritable::throw_if_not_writable(result);
+    dpnp::tensor::validation::AmpleMemory::throw_if_not_ample(result,
+                                                              src_nelems);
 
     const py::ssize_t x_size = vectorX.get_size();
     const py::ssize_t y_size = vectorY.get_size();
@@ -125,7 +125,7 @@ std::pair<sycl::event, sycl::event>
         throw py::value_error("Given arrays must be of the same type.");
     }
 
-    auto array_types = dpctl_td_ns::usm_ndarray_types();
+    auto array_types = dpnp_td_ns::usm_ndarray_types();
     const int type_id = array_types.typenum_to_lookup_id(vectorX_typenum);
 
     dot_impl_fn_ptr_t dot_fn = dot_dispatch_vector[type_id];
@@ -163,7 +163,7 @@ std::pair<sycl::event, sycl::event>
     sycl::event dot_ev = dot_fn(exec_q, n, x_typeless_ptr, incx, y_typeless_ptr,
                                 incy, r_typeless_ptr, depends);
 
-    sycl::event args_ev = dpctl::utils::keep_args_alive(
+    sycl::event args_ev = dpnp::utils::keep_args_alive(
         exec_q, {vectorX, vectorY, result}, {dot_ev});
 
     return std::make_pair(args_ev, dot_ev);

dpnp/backend/extensions/blas/dotc.hpp

@@ -35,7 +35,7 @@
 namespace dpnp::extensions::blas
 {
 namespace mkl_blas = oneapi::mkl::blas;
-namespace type_utils = dpctl::tensor::type_utils;
+namespace type_utils = dpnp::tensor::type_utils;
 
 template <typename T>
 static sycl::event dotc_impl(sycl::queue &exec_q,

dpnp/backend/extensions/blas/dotu.hpp

@@ -35,7 +35,7 @@
 namespace dpnp::extensions::blas
 {
 namespace mkl_blas = oneapi::mkl::blas;
-namespace type_utils = dpctl::tensor::type_utils;
+namespace type_utils = dpnp::tensor::type_utils;
 
 template <typename T>
 static sycl::event dotu_impl(sycl::queue &exec_q,

dpnp/backend/extensions/blas/gemm.cpp

@@ -33,7 +33,7 @@
 // utils extension header
 #include "ext/common.hpp"
 
-// dpctl tensor headers
+// dpnp tensor headers
 #include "utils/memory_overlap.hpp"
 #include "utils/output_validation.hpp"
 #include "utils/type_utils.hpp"
@@ -45,7 +45,7 @@ namespace dpnp::extensions::blas
 {
 namespace mkl_blas = oneapi::mkl::blas;
 namespace py = pybind11;
-namespace type_utils = dpctl::tensor::type_utils;
+namespace type_utils = dpnp::tensor::type_utils;
 
 using ext::common::init_dispatch_table;
 
@@ -64,8 +64,8 @@ typedef sycl::event (*gemm_impl_fn_ptr_t)(sycl::queue &,
                                           const bool,
                                           const std::vector<sycl::event> &);
 
-static gemm_impl_fn_ptr_t gemm_dispatch_table[dpctl_td_ns::num_types]
-                                             [dpctl_td_ns::num_types];
+static gemm_impl_fn_ptr_t gemm_dispatch_table[dpnp_td_ns::num_types]
+                                             [dpnp_td_ns::num_types];
 
 template <typename Tab, typename Tc>
 static sycl::event gemm_impl(sycl::queue &exec_q,
@@ -153,9 +153,9 @@ static sycl::event gemm_impl(sycl::queue &exec_q,
 
 std::tuple<sycl::event, sycl::event, bool>
     gemm(sycl::queue &exec_q,
-         const dpctl::tensor::usm_ndarray &matrixA,
-         const dpctl::tensor::usm_ndarray &matrixB,
-         const dpctl::tensor::usm_ndarray &resultC,
+         const dpnp::tensor::usm_ndarray &matrixA,
+         const dpnp::tensor::usm_ndarray &matrixB,
+         const dpnp::tensor::usm_ndarray &resultC,
          const std::vector<sycl::event> &depends)
 {
     const int matrixA_nd = matrixA.get_ndim();
@@ -167,7 +167,7 @@ std::tuple<sycl::event, sycl::event, bool>
             "Input and output matrices must be two-dimensional.");
     }
 
-    auto const &overlap = dpctl::tensor::overlap::MemoryOverlap();
+    auto const &overlap = dpnp::tensor::overlap::MemoryOverlap();
     if (overlap(matrixA, resultC)) {
         throw py::value_error(
             "The first input array and output array are overlapping "
@@ -179,7 +179,7 @@ std::tuple<sycl::event, sycl::event, bool>
             "segments of memory");
     }
 
-    if (!dpctl::utils::queues_are_compatible(
+    if (!dpnp::utils::queues_are_compatible(
             exec_q,
             {matrixA.get_queue(), matrixB.get_queue(), resultC.get_queue()})) {
         throw py::value_error(
@@ -206,9 +206,9 @@ std::tuple<sycl::event, sycl::event, bool>
     }
 
     const std::size_t src_nelems = m * n;
-    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(resultC);
-    dpctl::tensor::validation::AmpleMemory::throw_if_not_ample(resultC,
-                                                               src_nelems);
+    dpnp::tensor::validation::CheckWritable::throw_if_not_writable(resultC);
+    dpnp::tensor::validation::AmpleMemory::throw_if_not_ample(resultC,
+                                                              src_nelems);
 
     const bool is_matrixA_f_contig = matrixA.is_f_contiguous();
     const bool is_matrixB_f_contig = matrixB.is_f_contiguous();
@@ -300,7 +300,7 @@ std::tuple<sycl::event, sycl::event, bool>
         throw py::value_error("matrixA and matrixB must be of the same type.");
     }
 
-    auto array_types = dpctl_td_ns::usm_ndarray_types();
+    auto array_types = dpnp_td_ns::usm_ndarray_types();
     const int matrixAB_type_id =
         array_types.typenum_to_lookup_id(matrixA_typenum);
     const int resultC_type_id =
@@ -322,7 +322,7 @@ std::tuple<sycl::event, sycl::event, bool>
                                   a_typeless_ptr, lda, b_typeless_ptr, ldb,
                                   r_typeless_ptr, ldc, is_row_major, depends);
 
-    sycl::event args_ev = dpctl::utils::keep_args_alive(
+    sycl::event args_ev = dpnp::utils::keep_args_alive(
         exec_q, {matrixA, matrixB, resultC}, {gemm_ev});
 
     return std::make_tuple(args_ev, gemm_ev, is_row_major);

dpnp/backend/extensions/blas/gemm.hpp

@@ -37,16 +37,16 @@ namespace dpnp::extensions::blas
 {
 extern std::tuple<sycl::event, sycl::event, bool>
     gemm(sycl::queue &exec_q,
-         const dpctl::tensor::usm_ndarray &matrixA,
-         const dpctl::tensor::usm_ndarray &matrixB,
-         const dpctl::tensor::usm_ndarray &resultC,
+         const dpnp::tensor::usm_ndarray &matrixA,
+         const dpnp::tensor::usm_ndarray &matrixB,
+         const dpnp::tensor::usm_ndarray &resultC,
          const std::vector<sycl::event> &depends);
 
 extern std::tuple<sycl::event, sycl::event, bool>
     gemm_batch(sycl::queue &exec_q,
-               const dpctl::tensor::usm_ndarray &matrixA,
-               const dpctl::tensor::usm_ndarray &matrixB,
-               const dpctl::tensor::usm_ndarray &resultC,
+               const dpnp::tensor::usm_ndarray &matrixA,
+               const dpnp::tensor::usm_ndarray &matrixB,
+               const dpnp::tensor::usm_ndarray &resultC,
                const std::vector<sycl::event> &depends);
 
 extern void init_gemm_dispatch_table(void);

dpnp/backend/extensions/blas/gemm_batch.cpp

@@ -33,7 +33,7 @@
 // utils extension header
 #include "ext/common.hpp"
 
-// dpctl tensor headers
+// dpnp tensor headers
 #include "utils/memory_overlap.hpp"
 #include "utils/output_validation.hpp"
 #include "utils/type_utils.hpp"
@@ -45,7 +45,7 @@ namespace dpnp::extensions::blas
 {
 namespace mkl_blas = oneapi::mkl::blas;
 namespace py = pybind11;
-namespace type_utils = dpctl::tensor::type_utils;
+namespace type_utils = dpnp::tensor::type_utils;
 
 using ext::common::init_dispatch_table;
 
@@ -70,7 +70,7 @@ typedef sycl::event (*gemm_batch_impl_fn_ptr_t)(
     const std::vector<sycl::event> &);
 
 static gemm_batch_impl_fn_ptr_t
-    gemm_batch_dispatch_table[dpctl_td_ns::num_types][dpctl_td_ns::num_types];
+    gemm_batch_dispatch_table[dpnp_td_ns::num_types][dpnp_td_ns::num_types];
 
 template <typename Tab, typename Tc>
 static sycl::event gemm_batch_impl(sycl::queue &exec_q,
@@ -212,9 +212,9 @@ void standardize_strides_to_zero(std::vector<py::ssize_t> &strides,
 
 std::tuple<sycl::event, sycl::event, bool>
     gemm_batch(sycl::queue &exec_q,
-               const dpctl::tensor::usm_ndarray &matrixA,
-               const dpctl::tensor::usm_ndarray &matrixB,
-               const dpctl::tensor::usm_ndarray &resultC,
+               const dpnp::tensor::usm_ndarray &matrixA,
+               const dpnp::tensor::usm_ndarray &matrixB,
+               const dpnp::tensor::usm_ndarray &resultC,
                const std::vector<sycl::event> &depends = {})
 {
     const int matrixA_nd = matrixA.get_ndim();
@@ -225,7 +225,7 @@ std::tuple<sycl::event, sycl::event, bool>
         throw py::value_error("The given arrays have incorrect dimensions.");
     }
 
-    auto const &overlap = dpctl::tensor::overlap::MemoryOverlap();
+    auto const &overlap = dpnp::tensor::overlap::MemoryOverlap();
     if (overlap(matrixA, resultC)) {
         throw py::value_error("Input array 1 and output array are overlapping "
                               "segments of memory");
@@ -235,7 +235,7 @@ std::tuple<sycl::event, sycl::event, bool>
                               "segments of memory");
     }
 
-    if (!dpctl::utils::queues_are_compatible(
+    if (!dpnp::utils::queues_are_compatible(
             exec_q,
             {matrixA.get_queue(), matrixB.get_queue(), resultC.get_queue()})) {
         throw py::value_error(
@@ -262,9 +262,9 @@ std::tuple<sycl::event, sycl::event, bool>
                               "the number of columns in result array.");
     }
     const std::int64_t src_nelems = batch_size * m * n;
-    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(resultC);
-    dpctl::tensor::validation::AmpleMemory::throw_if_not_ample(resultC,
-                                                               src_nelems);
+    dpnp::tensor::validation::CheckWritable::throw_if_not_writable(resultC);
+    dpnp::tensor::validation::AmpleMemory::throw_if_not_ample(resultC,
+                                                              src_nelems);
 
     std::vector<py::ssize_t> a_stride = matrixA.get_strides_vector();
     std::vector<py::ssize_t> b_stride = matrixB.get_strides_vector();
@@ -374,7 +374,7 @@ std::tuple<sycl::event, sycl::event, bool>
         throw py::value_error("matrixA and matrixB must be of the same type.");
     }
 
-    auto array_types = dpctl_td_ns::usm_ndarray_types();
+    auto array_types = dpnp_td_ns::usm_ndarray_types();
     const int matrixAB_type_id =
         array_types.typenum_to_lookup_id(matrixA_typenum);
     const int resultC_type_id =
@@ -397,7 +397,7 @@ std::tuple<sycl::event, sycl::event, bool>
                       strideb, stridec, transA, transB, a_typeless_ptr,
                       b_typeless_ptr, r_typeless_ptr, is_row_major, depends);
 
-    sycl::event args_ev = dpctl::utils::keep_args_alive(
+    sycl::event args_ev = dpnp::utils::keep_args_alive(
         exec_q, {matrixA, matrixB, resultC}, {gemm_batch_ev});
 
     return std::make_tuple(args_ev, gemm_batch_ev, is_row_major);