Resolve an issue with .data.ptr ignoring USM offset on array views (#2812)

The `create_data()` function had an early return when `usm_data` was
already a dpnp memory class instance, which skipped setting the `ptr`
attribute. This caused all array views to report the same base pointer,
making `arr[0].data.ptr == arr[1].data.ptr` even though they point to
different memory locations.

The PR proposes a fix ensuring `ptr` is always set to `x._pointer`,
which points to the start of the array's data (including any offset for
views), rather than `usm_data._pointer` which points to the base buffer.

Additionally, always create a new memory wrapper instance to avoid
shared state when the same `usm_data` is used for multiple views.

This PR closes #2781.

- [x] Have you provided a meaningful PR description?
- [x] Have you added a test, reproducer or referred to an issue with a
reproducer?
- [x] Have you tested your changes locally for CPU and GPU devices?
- [x] Have you made sure that new changes do not introduce compiler
warnings?
- [ ] Have you checked performance impact of proposed changes?
- [ ] Have you added documentation for your changes, if necessary?
- [x] Have you added your changes to the changelog?

Author: antonwolfy

CHANGELOG.md

@@ -76,6 +76,7 @@ Also, that release drops support for Python 3.9, making Python 3.10 the minimum
 * Resolved an issue causing `dpnp.linspace` to return an incorrect output shape when inputs were passed as arrays [#2712](https://github.com/IntelPython/dpnp/pull/2712)
 * Resolved an issue where `dpnp` always returns the base allocation pointer, when the view start is expected [#2651](https://github.com/IntelPython/dpnp/pull/2651)
 * Fixed an issue causing an exception in `dpnp.geomspace` and `dpnp.logspace` when called with explicit `device` keyword but any input array is allocated on another device [#2723](https://github.com/IntelPython/dpnp/pull/2723)
+* Fixed `.data.ptr` property on array views to correctly return the pointer to the view's data location instead of the base allocation pointer [#2812](https://github.com/IntelPython/dpnp/pull/2812)
 
 ### Security
 

dpnp/memory/_memory.py

@@ -98,13 +98,18 @@ def create_data(x):
     usm_data = x.usm_data
 
     if isinstance(usm_data, tuple(dispatch.values())):
-        return usm_data
-
-    cls = dispatch.get(type(usm_data), None)
-    if cls:
-        data = cls(usm_data)
-        # `ptr` is expecting to point at the start of the array's data,
-        # while `usm_data._pointer` is a pointer at the start of memory buffer
-        data.ptr = x._pointer
-        return data
-    raise TypeError(f"Expected USM memory, but got {type(usm_data)}")
+        # usm_data is already an instance of MemoryUSM<type> class
+        cls = usm_data.__class__
+    elif (cls := dispatch.get(type(usm_data))) is not None:
+        pass  # cls is set
+    else:
+        raise TypeError(f"Expected USM memory, but got {type(usm_data)}")
+
+    # create a new instance each time since usm_data might be a view
+    # of another array
+    data = cls(usm_data)
+
+    # `ptr` is expecting to point at the start of the array's data,
+    # while `usm_data._pointer` is a pointer at the start of memory buffer
+    data.ptr = x._pointer
+    return data

dpnp/tests/test_memory.py

@@ -27,6 +27,41 @@ def test_wrong_usm_data(self):
         with pytest.raises(TypeError):
             dpm.create_data(d)
 
+    def test_dpctl_view(self):
+        a = dpt.arange(10)
+        view = a[3:]
+
+        data = dpm.create_data(view)
+        assert data.ptr == view._pointer
+
+    def test_dpctl_different_views(self):
+        a = dpt.reshape(dpt.arange(12), (3, 4))
+
+        data0 = dpm.create_data(a[0])
+        data1 = dpm.create_data(a[1])
+
+        # Verify independent wrapper objects
+        assert data0 is not data1
+
+        # Verify correct pointers
+        assert data0.ptr == a[0]._pointer
+        assert data1.ptr == a[1]._pointer
+        assert data0.ptr != data1.ptr
+
+    def test_repeated_calls(self):
+        a = dpt.arange(20)
+        view = a[5:15]
+
+        # Multiple calls should return independent objects with same ptr
+        data1 = dpm.create_data(view)
+        data2 = dpm.create_data(view)
+
+        assert data1 is not data2, "Should create independent wrapper objects"
+        assert data1.ptr == data2.ptr, "Both should point to same location"
+        assert data1.ptr == view._pointer
+
+
+class TestNdarray:
     def test_ndarray_from_data(self):
         a = dpnp.empty(5)
         b = dpnp.ndarray(a.shape, buffer=a.data)
@@ -42,3 +77,62 @@ def test_view_non_zero_offset(self):
         pl = dpnp.ndarray((n, m), dtype=a.dtype, buffer=sl)
         assert pl.data.ptr == sl.data.ptr
         assert a.data.ptr != sl.data.ptr
+
+    def test_slices_2d(self):
+        # Create 2D array and verify slices have different pointers
+        a = dpnp.arange(12, dtype=dpnp.float32).reshape(3, 4)
+
+        # Each row should have a different pointer
+        row0_ptr = a[0].data.ptr
+        row1_ptr = a[1].data.ptr
+        row2_ptr = a[2].data.ptr
+
+        assert (
+            row0_ptr != row1_ptr
+        ), "a[0] and a[1] should have different pointers"
+        assert (
+            row1_ptr != row2_ptr
+        ), "a[1] and a[2] should have different pointers"
+
+        # Check byte offsets match expected stride
+        stride = a.strides[0]  # stride between rows in bytes
+        assert row1_ptr - row0_ptr == stride
+        assert row2_ptr - row1_ptr == stride
+
+    def test_slices_multidimensional(self):
+        # 3D array
+        a = dpnp.zeros((5, 10, 20), dtype=dpnp.int32)
+
+        # Different slices along first axis should have different pointers
+        slice0_ptr = a[0].data.ptr
+        slice1_ptr = a[1].data.ptr
+
+        assert slice0_ptr != slice1_ptr
+        assert slice1_ptr - slice0_ptr == a.strides[0]
+
+    def test_repeated_access(self):
+        a = dpnp.arange(20).reshape(4, 5)
+
+        # Multiple accesses to same slice should give same ptr value
+        ptr1 = a[2].data.ptr
+        ptr2 = a[2].data.ptr
+
+        assert ptr1 == ptr2, "Same slice should have consistent ptr value"
+
+        # But different slices should have different ptrs
+        assert a[0].data.ptr != a[2].data.ptr
+
+    def test_array_on_view_with_slicing(self):
+        # Original array
+        a = dpnp.arange(24, dtype=dpnp.float32).reshape(6, 4)
+
+        # Create view using slicing
+        view = a[2:5]
+
+        # Construct new array from view
+        new_arr = dpnp.ndarray(view.shape, dtype=view.dtype, buffer=view)
+
+        # Pointers should match
+        assert new_arr.data.ptr == view.data.ptr
+        # And should be different from base array
+        assert new_arr.data.ptr != a.data.ptr