Performance impact of passing around reshaped memory views of the same underlying array

[Adam Li]

Hi all,

I am wondering if there are any issues (performance, design flaws, etc.) with the following setup I am thinking of.

The extension type class I have wants to take in a 2D array of shape (n_samples, n_features), where each row is a separate sample. The sample is comprised of a vectorized 1D array. However, I want to perform operations on a reshaped version of the vectorized array because it's easier to reason and code.

For example, I have a vectorized array of shape (12,), and I want to then do operations on a reshaped memory view that views that array as (4, 3). In terms of Cython code, I was thinking of something like:

```

cdef class A:

    def __cinit__(self, double [:, ::1] X):

           self.X = X

   cdef inline double compute_something(self):

           cdef double[:, :, ::1] reshaped_X = self.X.reshape(-1, 4, 3)

           # compute something using the reshaped array - only requires read-access 

           cdef double result = 0

           for idx in range(n_samples):

                  result += reshaped_X[idx, 2, 2]

           return result

```

Now, my understanding of memory views is that this is not a copy of the underlying array (instantiated in Python via numpy). And when you reshape the array, you are only changing the strides, so you are also not making a copy of the underlying data.

1. Does the design I posed work, or do I have to do something special to initialize the `reshaped_X` memory view as a "reshaped view" into X?

2. Does the design with `reshaped_X` make a copy of X? It should only change the strides and make a new "view" into the underlying data of X right?

3. Would the design I posed be fine performance-wise, or is there anything I need to consider?

Thanks!

[da-woods]

Hi Adam,

It basically works as you expect - doesn't make a copy, should be fairly fast (although reshape is a Python call).

--

---
You received this message because you are subscribed to the Google Groups "cython-users" group.
To unsubscribe from this group and stop receiving emails from it, send an email to cython-users...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/cython-users/db7c1ae6-c15e-4337-a9f8-ae5bb1ad1a85n%40googlegroups.com.

[Chris Barker]

hmm -- shouldn't you be able to do this without the reshape call at all?

e.g. just look at the data as a 3-D array, something like:

cdef double[:, :, ::1] reshaped_X = self.X

if it complains at run-time, maybe you'll need a cast, or point the memoryview at the underlying pointer (can't remember the syntax right now, but maybe:

cdef double[:, :, ::1] reshaped_X = self.X[0]

That being said, unless these are tiny arrays, no reason to make the code more error prone.

-CHB

To view this discussion on the web visit https://groups.google.com/d/msgid/cython-users/6d4e968a-4998-46e6-9670-9d37252a3d3e%40d-woods.co.uk.

--

Christopher Barker, Ph.D.
Oceanographer

Emergency Response Division
NOAA/NOS/OR&R            (206) 526-6959   voice
7600 Sand Point Way NE   (206) 526-6329   fax
Seattle, WA  98115       (206) 526-6317   main reception

Chris....@noaa.gov

[Salih Ahmed]

Dear Adam Li,

Please accept my apologies for the delayed response — I was away for a while and couldn’t reply sooner. Thank you for your patience.

Regarding your question: your overall design is reasonable, but there are a few important points about reshaping typed memoryviews in Cython:

1. Cython memoryviews do not support .reshape() the way NumPy arrays do, so

1. reshaped_X = self.X.reshape(-1, 4, 3)
   

1. will not work.

2. Reshaping a memoryview never makes a copy, simply because memoryviews cannot be reshaped. If you reshape the array on the NumPy side, NumPy will only create a view if the data is C-contiguous; otherwise, it will copy.

3. Performance-wise, your approach is fine as long as the reshaping is done in NumPy before passing the array to your extension class, or through a safe manual cast when you’re certain about the memory layout.

In short: reshape the NumPy array first, then pass it as a memoryview to Cython for efficient, zero-copy access.

If you’d like, I can provide a corrected Cython snippet as well.