ENH: Reduce compute time for tobytes in non-contiguos paths (numpy#30170)

* Add optimal copy path for non-contiguos arrays in ToString C Impl.

* Add tests for 	obytes new path

* Add imports

* fix comments

* fix memory issues and add benchmarks

* run ruff --fix

* simplify function

* minor fix

* minor typos and move tests

Author: aadya940

benchmarks/benchmarks/bench_core.py

@@ -14,6 +14,7 @@ def setup(self):
         self.l_view = [memoryview(a) for a in self.l]
         self.l10x10 = np.ones((10, 10))
         self.float64_dtype = np.dtype(np.float64)
+        self.arr = np.arange(10000).reshape(100, 100)
 
     def time_array_1(self):
         np.array(1)
@@ -48,6 +49,9 @@ def time_array_l_view(self):
     def time_can_cast(self):
         np.can_cast(self.l10x10, self.float64_dtype)
 
+    def time_tobytes_noncontiguous(self):
+        self.arr.T.tobytes()
+
     def time_can_cast_same_kind(self):
         np.can_cast(self.l10x10, self.float64_dtype, casting="same_kind")
 

numpy/_core/src/multiarray/convert.c

@@ -335,11 +335,7 @@ NPY_NO_EXPORT PyObject *
 PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
 {
     npy_intp numbytes;
-    npy_intp i;
-    char *dptr;
-    int elsize;
     PyObject *ret;
-    PyArrayIterObject *it;
 
     if (order == NPY_ANYORDER)
         order = PyArray_ISFORTRAN(self) ? NPY_FORTRANORDER : NPY_CORDER;
@@ -354,41 +350,65 @@ PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
     numbytes = PyArray_NBYTES(self);
     if ((PyArray_IS_C_CONTIGUOUS(self) && (order == NPY_CORDER))
         || (PyArray_IS_F_CONTIGUOUS(self) && (order == NPY_FORTRANORDER))) {
-        ret = PyBytes_FromStringAndSize(PyArray_DATA(self), (Py_ssize_t) numbytes);
+        return PyBytes_FromStringAndSize(PyArray_DATA(self), (Py_ssize_t) numbytes);
     }
-    else {
-        PyObject *new;
-        if (order == NPY_FORTRANORDER) {
-            /* iterators are always in C-order */
-            new = PyArray_Transpose(self, NULL);
-            if (new == NULL) {
-                return NULL;
-            }
+    
+    /* Avoid Ravel where possible for fewer copies. */
+    if (!PyDataType_REFCHK(PyArray_DESCR(self)) && 
+        ((PyArray_DESCR(self)->flags & NPY_NEEDS_INIT) == 0)) {
+        
+        /* Allocate final Bytes Object */
+        ret = PyBytes_FromStringAndSize(NULL, (Py_ssize_t) numbytes);
+        if (ret == NULL) {
+            return NULL;
         }
-        else {
-            Py_INCREF(self);
-            new = (PyObject *)self;
+        
+        /* Writable Buffer */
+        char* dest = PyBytes_AS_STRING(ret);
+
+        int flags = NPY_ARRAY_WRITEABLE;
+        if (order == NPY_FORTRANORDER) {
+            flags |= NPY_ARRAY_F_CONTIGUOUS;
         }
-        it = (PyArrayIterObject *)PyArray_IterNew(new);
-        Py_DECREF(new);
-        if (it == NULL) {
+
+        Py_INCREF(PyArray_DESCR(self));
+        /* Array view */
+        PyArrayObject *dest_array = (PyArrayObject *)PyArray_NewFromDescr(
+            &PyArray_Type,
+            PyArray_DESCR(self),
+            PyArray_NDIM(self),
+            PyArray_DIMS(self),
+            NULL, // strides
+            dest,
+            flags,
+            NULL
+        );
+
+        if (dest_array == NULL) {
+            Py_DECREF(ret);
             return NULL;
         }
-        ret = PyBytes_FromStringAndSize(NULL, (Py_ssize_t) numbytes);
-        if (ret == NULL) {
-            Py_DECREF(it);
+        
+        /* Copy directly from source to destination with proper ordering */
+        if (PyArray_CopyInto(dest_array, self) < 0) {
+            Py_DECREF(dest_array);
+            Py_DECREF(ret);
             return NULL;
         }
-        dptr = PyBytes_AS_STRING(ret);
-        i = it->size;
-        elsize = PyArray_ITEMSIZE(self);
-        while (i--) {
-            memcpy(dptr, it->dataptr, elsize);
-            dptr += elsize;
-            PyArray_ITER_NEXT(it);
-        }
-        Py_DECREF(it);
+        
+        Py_DECREF(dest_array);
+        return ret;
+
+    }
+
+    /* Non-contiguous, Has References and/or Init Path.  */
+    PyArrayObject *contig = (PyArrayObject *)PyArray_Ravel(self, order);
+    if (contig == NULL) {
+        return NULL;
     }
+    
+    ret = PyBytes_FromStringAndSize(PyArray_DATA(contig), numbytes);
+    Py_DECREF(contig);
     return ret;
 }
 

numpy/_core/tests/test_multiarray.py

@@ -3835,6 +3835,18 @@ class ArraySubclass(np.ndarray):
         assert_(isinstance(a.ravel('A'), ArraySubclass))
         assert_(isinstance(a.ravel('K'), ArraySubclass))
 
+    @pytest.mark.parametrize("shape", [(3, 224, 224), (8, 512, 512)])
+    def test_tobytes_no_copy_fastpath(self, shape):
+        # Test correctness of non-contiguous paths for `tobytes`
+        rng = np.random.default_rng(0)
+        arr = rng.standard_normal(shape, dtype=np.float32)
+        noncontig = arr.transpose(1, 2, 0)
+
+        # correctness
+        expected = np.ascontiguousarray(noncontig).tobytes()
+        got = noncontig.tobytes()
+        assert got == expected
+
     def test_swapaxes(self):
         a = np.arange(1 * 2 * 3 * 4).reshape(1, 2, 3, 4).copy()
         idx = np.indices(a.shape)
@@ -10546,7 +10558,6 @@ def test_getfield():
     pytest.raises(ValueError, a.getfield, 'uint8', 16)
     pytest.raises(ValueError, a.getfield, 'uint64', 0)
 
-
 class TestViewDtype:
     """
     Verify that making a view of a non-contiguous array works as expected.