Adds writable flag checks throughout Python bindings

These checks are implemented through a new CheckWritable struct, which has a static method throw_if_not_writable, which throws if an array is read-only

Author: ndgrigorian

dpctl/apis/include/dpctl4pybind11.hpp

@@ -1072,7 +1072,7 @@ bool queues_are_compatible(const sycl::queue &exec_q,
     return true;
 }
 
-/*! @brief Check if all allocation queues of  usm_ndarays are the same as
+/*! @brief Check if all allocation queues of usm_ndarays are the same as
     the execution queue */
 template <std::size_t num>
 bool queues_are_compatible(const sycl::queue &exec_q,

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

@@ -0,0 +1,57 @@
+//===- output_validation.hpp - Utilities for output array validation
+//-*-C++-*===//
+//
+//                      Data Parallel Control (dpctl)
+//
+// Copyright 2020-2022 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines utilities for determining if an array is a valid output
+/// array.
+//===----------------------------------------------------------------------===//
+
+#pragma once
+#include "dpctl4pybind11.hpp"
+#include <pybind11/pybind11.h>
+
+namespace dpctl
+{
+
+namespace tensor
+{
+
+namespace validation
+{
+
+/*! @brief Raises a value error if a function would attempt to write
+    to an array which is read-only.
+
+    This should always be called on an array before it will be written to.*/
+struct CheckWritable
+{
+    static void throw_if_not_writable(const dpctl::tensor::usm_ndarray &arr)
+    {
+        if (!arr.is_writable()) {
+            throw py::value_error("output array is read-only.");
+        }
+        return;
+    }
+};
+
+} // namespace validation
+} // namespace tensor
+} // namespace dpctl

dpctl/tensor/libtensor/source/accumulators.cpp

@@ -35,6 +35,7 @@
 #include "simplify_iteration_space.hpp"
 #include "utils/memory_overlap.hpp"
 #include "utils/offset_utils.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 
 namespace dpctl
@@ -102,6 +103,8 @@ size_t py_mask_positions(const dpctl::tensor::usm_ndarray &mask,
                          sycl::queue &exec_q,
                          const std::vector<sycl::event> &depends)
 {
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(cumsum);
+
     // cumsum is 1D
     if (cumsum.get_ndim() != 1) {
         throw py::value_error("Result array must be one-dimensional.");
@@ -274,6 +277,8 @@ size_t py_cumsum_1d(const dpctl::tensor::usm_ndarray &src,
             "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(cumsum);
+
     if (src_size == 0) {
         return 0;
     }

dpctl/tensor/libtensor/source/boolean_advanced_indexing.cpp

@@ -37,6 +37,7 @@
 #include "simplify_iteration_space.hpp"
 #include "utils/memory_overlap.hpp"
 #include "utils/offset_utils.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 
 namespace dpctl
@@ -118,6 +119,8 @@ py_extract(const dpctl::tensor::usm_ndarray &src,
            sycl::queue &exec_q,
            const std::vector<sycl::event> &depends)
 {
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     int src_nd = src.get_ndim();
     if ((axis_start < 0 || axis_end > src_nd || axis_start >= axis_end)) {
         throw py::value_error("Specified axes_start and axes_end are invalid.");
@@ -452,6 +455,8 @@ py_place(const dpctl::tensor::usm_ndarray &dst,
          sycl::queue &exec_q,
          const std::vector<sycl::event> &depends)
 {
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     int dst_nd = dst.get_ndim();
     if ((axis_start < 0 || axis_end > dst_nd || axis_start >= axis_end)) {
         throw py::value_error("Specified axes_start and axes_end are invalid.");
@@ -726,6 +731,8 @@ py_nonzero(const dpctl::tensor::usm_ndarray
             "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(indexes);
+
     int cumsum_nd = cumsum.get_ndim();
     if (cumsum_nd != 1 || !cumsum.is_c_contiguous()) {
         throw py::value_error("Cumsum array must be a C-contiguous vector");

dpctl/tensor/libtensor/source/clip.cpp

@@ -37,6 +37,7 @@
 #include "simplify_iteration_space.hpp"
 #include "utils/memory_overlap.hpp"
 #include "utils/offset_utils.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 
 namespace dpctl
@@ -87,6 +88,8 @@ py_clip(const dpctl::tensor::usm_ndarray &src,
             "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     int nd = src.get_ndim();
     int min_nd = min.get_ndim();
     int max_nd = max.get_ndim();

dpctl/tensor/libtensor/source/copy_and_cast_usm_to_usm.cpp

@@ -37,6 +37,7 @@
 #include "dpctl4pybind11.hpp"
 #include "kernels/copy_and_cast.hpp"
 #include "utils/memory_overlap.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 #include "utils/type_utils.hpp"
 
@@ -118,6 +119,8 @@ copy_usm_ndarray_into_usm_ndarray(const dpctl::tensor::usm_ndarray &src,
             "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     int src_typenum = src.get_typenum();
     int dst_typenum = dst.get_typenum();
 

dpctl/tensor/libtensor/source/copy_for_reshape.cpp

@@ -29,6 +29,7 @@
 #include "copy_for_reshape.hpp"
 #include "dpctl4pybind11.hpp"
 #include "kernels/copy_and_cast.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 #include <pybind11/pybind11.h>
 
@@ -105,6 +106,8 @@ copy_usm_ndarray_for_reshape(const dpctl::tensor::usm_ndarray &src,
             "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     if (src_nelems == 1) {
         // handle special case of 1-element array
         int src_elemsize = src.get_elemsize();

dpctl/tensor/libtensor/source/copy_for_roll.cpp

@@ -29,6 +29,7 @@
 #include "copy_for_roll.hpp"
 #include "dpctl4pybind11.hpp"
 #include "kernels/copy_and_cast.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 #include <pybind11/pybind11.h>
 
@@ -128,6 +129,8 @@ copy_usm_ndarray_for_roll_1d(const dpctl::tensor::usm_ndarray &src,
             "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     if (src_nelems == 1) {
         // handle special case of 1-element array
         int src_elemsize = src.get_elemsize();

dpctl/tensor/libtensor/source/copy_numpy_ndarray_into_usm_ndarray.cpp

@@ -31,6 +31,7 @@
 #include <pybind11/pybind11.h>
 
 #include "kernels/copy_and_cast.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 
 #include "copy_numpy_ndarray_into_usm_ndarray.hpp"
@@ -106,6 +107,8 @@ void copy_numpy_ndarray_into_usm_ndarray(
                               "allocation queue");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     // here we assume that NumPy's type numbers agree with ours for types
     // supported in both
     int src_typenum =

dpctl/tensor/libtensor/source/elementwise_functions/elementwise_functions.hpp

@@ -38,6 +38,7 @@
 #include "simplify_iteration_space.hpp"
 #include "utils/memory_overlap.hpp"
 #include "utils/offset_utils.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 
 namespace py = pybind11;
@@ -69,10 +70,6 @@ py_unary_ufunc(const dpctl::tensor::usm_ndarray &src,
                const contig_dispatchT &contig_dispatch_vector,
                const strided_dispatchT &strided_dispatch_vector)
 {
-    if (!dst.is_writable()) {
-        throw py::value_error("Output array is read-only.");
-    }
-
     int src_typenum = src.get_typenum();
     int dst_typenum = dst.get_typenum();
 
@@ -94,6 +91,8 @@ py_unary_ufunc(const dpctl::tensor::usm_ndarray &src,
             "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     // check that dimensions are the same
     int src_nd = src.get_ndim();
     if (src_nd != dst.get_ndim()) {
@@ -324,9 +323,6 @@ std::pair<sycl::event, sycl::event> py_binary_ufunc(
     const contig_row_matrix_dispatchT
         &contig_row_matrix_broadcast_dispatch_table)
 {
-    if (!dst.is_writable()) {
-        throw py::value_error("Output array is read-only.");
-    }
     // check type_nums
     int src1_typenum = src1.get_typenum();
     int src2_typenum = src2.get_typenum();
@@ -350,6 +346,8 @@ std::pair<sycl::event, sycl::event> py_binary_ufunc(
             "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     // check shapes, broadcasting is assumed done by caller
     // check that dimensions are the same
     int dst_nd = dst.get_ndim();
@@ -655,9 +653,7 @@ py_binary_inplace_ufunc(const dpctl::tensor::usm_ndarray &lhs,
                         const contig_row_matrix_dispatchT
                             &contig_row_matrix_broadcast_dispatch_table)
 {
-    if (!lhs.is_writable()) {
-        throw py::value_error("Output array is read-only.");
-    }
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(lhs);
 
     // check type_nums
     int rhs_typenum = rhs.get_typenum();

dpctl/tensor/libtensor/source/eye_ctor.cpp

@@ -31,6 +31,7 @@
 
 #include "eye_ctor.hpp"
 #include "kernels/constructors.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 
 namespace py = pybind11;
@@ -66,6 +67,8 @@ usm_ndarray_eye(py::ssize_t k,
                               "allocation queue");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     auto array_types = td_ns::usm_ndarray_types();
     int dst_typenum = dst.get_typenum();
     int dst_typeid = array_types.typenum_to_lookup_id(dst_typenum);

dpctl/tensor/libtensor/source/full_ctor.cpp

@@ -31,6 +31,7 @@
 #include <vector>
 
 #include "kernels/constructors.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 #include "utils/type_utils.hpp"
 
@@ -126,6 +127,8 @@ usm_ndarray_full(const py::object &py_value,
             "Execution queue is not compatible with the allocation queue");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     auto array_types = td_ns::usm_ndarray_types();
     int dst_typenum = dst.get_typenum();
     int dst_typeid = array_types.typenum_to_lookup_id(dst_typenum);

dpctl/tensor/libtensor/source/integer_advanced_indexing.cpp

@@ -35,6 +35,7 @@
 #include "dpctl4pybind11.hpp"
 #include "kernels/integer_advanced_indexing.hpp"
 #include "utils/memory_overlap.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 #include "utils/type_utils.hpp"
 
@@ -259,6 +260,8 @@ usm_ndarray_take(const dpctl::tensor::usm_ndarray &src,
         throw py::value_error("Mode must be 0 or 1.");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     const dpctl::tensor::usm_ndarray ind_rep = ind[0];
 
     int src_nd = src.get_ndim();
@@ -570,9 +573,7 @@ usm_ndarray_put(const dpctl::tensor::usm_ndarray &dst,
         throw py::value_error("Mode must be 0 or 1.");
     }
 
-    if (!dst.is_writable()) {
-        throw py::value_error("Output array is read-only.");
-    }
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
 
     const dpctl::tensor::usm_ndarray ind_rep = ind[0];
 

dpctl/tensor/libtensor/source/linalg_functions/dot.cpp

@@ -17,6 +17,7 @@
 #include "simplify_iteration_space.hpp"
 #include "utils/memory_overlap.hpp"
 #include "utils/offset_utils.hpp"
+#include "utils/output_validation.hpp"
 
 namespace dpctl
 {
@@ -175,20 +176,17 @@ py_dot(const dpctl::tensor::usm_ndarray &x1,
        sycl::queue &exec_q,
        const std::vector<sycl::event> &depends)
 {
-
-    if (!dst.is_writable()) {
-        throw py::value_error("Output array is read-only.");
+    if (!dpctl::utils::queues_are_compatible(exec_q, {x1, x2, dst})) {
+        throw py::value_error(
+            "Execution queue is not compatible with allocation queues");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     if (inner_dims == 0) {
         throw py::value_error("No inner dimension for dot");
     }
 
-    if (!dpctl::utils::queues_are_compatible(exec_q, {x1, x2, dst})) {
-        throw py::value_error(
-            "Execution queue is not compatible with allocation queues");
-    }
-
     int x1_nd = x1.get_ndim();
     int x2_nd = x2.get_ndim();
     if (x1_nd != (batch_dims + x1_outer_dims + inner_dims) ||

dpctl/tensor/libtensor/source/linear_sequences.cpp

@@ -31,6 +31,7 @@
 #include <vector>
 
 #include "kernels/constructors.hpp"
+#include "utils/output_validation.hpp"
 #include "utils/type_dispatch.hpp"
 #include "utils/type_utils.hpp"
 
@@ -191,6 +192,8 @@ usm_ndarray_linear_sequence_step(const py::object &start,
             "Execution queue is not compatible with the allocation queue");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     auto array_types = td_ns::usm_ndarray_types();
     int dst_typenum = dst.get_typenum();
     int dst_typeid = array_types.typenum_to_lookup_id(dst_typenum);
@@ -239,6 +242,8 @@ usm_ndarray_linear_sequence_affine(const py::object &start,
             "Execution queue context is not the same as allocation context");
     }
 
+    dpctl::tensor::validation::CheckWritable::throw_if_not_writable(dst);
+
     auto array_types = td_ns::usm_ndarray_types();
     int dst_typenum = dst.get_typenum();
     int dst_typeid = array_types.typenum_to_lookup_id(dst_typenum);