cunumpy 0.6.0__tar.gz → 0.6.1__tar.gz

{cunumpy-0.6.0 → cunumpy-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.6.0
+Version: 0.6.1
 Summary: Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
 Author: Max
 Project-URL: Source, https://github.com/max-models/cunumpy
@@ -434,7 +434,7 @@ kernel(particles.args_markers, dt)  # host or CUDA kernel
 Kernels ported from pyccel index arrays like `markers[ip, j]`, which needs
 shapes and strides rather than bare pointers. The shipped header
 `cunumpy/array_view.cuh` (found by every `CudaKernel`) provides the strided
-views `Array1D<T>` to `Array4D<T>`; a parameter or struct field of that type
+views `Array1D<T>` to `Array16D<T>`; a parameter or struct field of that type
 takes a CuPy array, contiguous or not, and indexes `a(i, j)`. The struct can be
 generated from the annotations of the pyccel argument class, so the Python
 class is the one definition, and written to a header that a test keeps in sync:
@@ -444,7 +444,9 @@ class MarkerArguments:
     def __init__(self, markers: "float[:, :]", n_markers: int, valid: "bool[:]"): ...
 
 
-MarkerArgs = xp.arguments.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
+MarkerArgs = xp.arguments.CudaStruct.from_signature(
+    MarkerArguments.__init__, "MarkerArgs"
+)
 MarkerArgs.to_header(
     "marker_args.cuh"
 )  # Array2D<double> markers; long long n_markers; ...

{cunumpy-0.6.0 → cunumpy-0.6.1}/README.md

@@ -394,7 +394,7 @@ kernel(particles.args_markers, dt)  # host or CUDA kernel
 Kernels ported from pyccel index arrays like `markers[ip, j]`, which needs
 shapes and strides rather than bare pointers. The shipped header
 `cunumpy/array_view.cuh` (found by every `CudaKernel`) provides the strided
-views `Array1D<T>` to `Array4D<T>`; a parameter or struct field of that type
+views `Array1D<T>` to `Array16D<T>`; a parameter or struct field of that type
 takes a CuPy array, contiguous or not, and indexes `a(i, j)`. The struct can be
 generated from the annotations of the pyccel argument class, so the Python
 class is the one definition, and written to a header that a test keeps in sync:
@@ -404,7 +404,9 @@ class MarkerArguments:
     def __init__(self, markers: "float[:, :]", n_markers: int, valid: "bool[:]"): ...
 
 
-MarkerArgs = xp.arguments.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
+MarkerArgs = xp.arguments.CudaStruct.from_signature(
+    MarkerArguments.__init__, "MarkerArgs"
+)
 MarkerArgs.to_header(
     "marker_args.cuh"
 )  # Array2D<double> markers; long long n_markers; ...

{cunumpy-0.6.0 → cunumpy-0.6.1}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "cunumpy"
-version = "0.6.0"
+version = "0.6.1"
 description = "Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`."
 readme = "README.md"
 keywords = [ "python" ]

{cunumpy-0.6.0 → cunumpy-0.6.1}/src/cunumpy/LLM_GUIDE.md

@@ -96,7 +96,7 @@ https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
 | PETSc solve on device arrays without copies | `xp.petsc.petsc_vec(array)` (CUDA/HIP petsc4py for CuPy arrays); `xp.synchronize()` around PETSc calls |
 | reduction inside a CUDA kernel (energy, max velocity) | `<cunumpy/reduce.cuh>`: `cunumpy_block_sum_to(out, v)`, `cunumpy_block_min/max`, `cunumpy_warp_sum` |
 | kernel writes into a host buffer owned by another library | `xp.memory.DeviceMirror(host_array)` + `<cunumpy/atomic.cuh>` |
-| N-D indexing in CUDA, non-contiguous arrays | `Array1D<T>`..`Array4D<T>` params from `<cunumpy/array_view.cuh>` |
+| N-D indexing in CUDA, non-contiguous arrays | `Array1D<T>`..`Array16D<T>` params from `<cunumpy/array_view.cuh>` |
 | one MPI rank per GPU | `bind_local_device()` → `from mpi4py import MPI` → `require_cuda_aware_mpi()` → `synchronize_for_mpi(...)` before each call |
 | timing GPU code | `with xp.profiling.timed_region("name") as t:` → `t.elapsed` |
 | profiler markers | `xp.profiling.nvtx_range("name")` (context manager or decorator) |
@@ -307,7 +307,7 @@ Shipped CUDA headers (always on the include path):
 
 ```c
 #include <cunumpy/index.cuh>       // CUNUMPY_THREAD_1D(i, n) /_2D/_3D, CUNUMPY_GRID_STRIDE_1D(i, n) {...}
-#include <cunumpy/array_view.cuh>  // Array1D<T>..Array4D<T>: data, shape[], strides[] (elements), a(i, j), size()
+#include <cunumpy/array_view.cuh>  // Array1D<T>..Array16D<T>: data, shape[], strides[] (elements), a(i, j), size()
 #include <cunumpy/atomic.cuh>      // cunumpy_atomic_add(double*|float*, v), _2d(data, n1, i, j, v), _3d(...)
 ```
 

{cunumpy-0.6.0 → cunumpy-0.6.1}/src/cunumpy/_cuda_kernel.py

@@ -123,7 +123,7 @@ def cuda_include_dir() -> str:
 
     :class:`CudaKernel` adds it to the include path automatically, so kernels
     can ``#include "cunumpy/array_view.cuh"`` (strided ``Array1D<T>``
-    to ``Array4D<T>`` views passed by value) and
+    to ``Array16D<T>`` views passed by value) and
     ``#include "cunumpy/index.cuh"`` (thread-index and grid-stride macros such
     as ``CUNUMPY_THREAD_1D(i, n)``), ``#include "cunumpy/atomic.cuh"`` (atomic
     adds) and ``#include "cunumpy/reduce.cuh"`` (warp and block reductions).
@@ -188,7 +188,7 @@ class CudaParameter(NamedTuple):
         The struct type, for a struct passed by value.
     view_ndim : int | None
         The number of dimensions, for an array view (``Array1D<T>`` to
-        ``Array4D<T>`` or ``CArray1D<T>`` to ``CArray4D<T>``, see
+        ``Array16D<T>`` or ``CArray1D<T>`` to ``CArray16D<T>``, see
         :func:`cuda_include_dir`) passed by value.
     contiguous : bool
         Whether the array view is C-contiguous (``CArray2D<T>``): packed
@@ -265,11 +265,11 @@ _CTYPE_OF = {
 _QUALIFIERS = {"const", "volatile", "__restrict__", "__restrict", "restrict"}
 
 _COMPLEX = re.compile(r"(?:(?:thrust|cuda::std)::)?complex\s*<\s*(float|double)\s*>")
-# Array1D<T> to Array4D<T> and CArray1D<T> to CArray4D<T> (cunumpy/array_view.cuh),
+# Array1D<T> to Array16D<T> and CArray1D<T> to CArray16D<T> (cunumpy/array_view.cuh),
 # T a scalar type of _CTYPES
-_VIEW = re.compile(r"\b(C?)Array([1234])D\s*<((?:[^<>]|complex<[^<>]*>)+?)>")
+_VIEW = re.compile(r"\b(C?)Array([1-9]|1[0-6])D\s*<((?:[^<>]|complex<[^<>]*>)+?)>")
 _TOKEN = re.compile(
-    r"C?Array[1234]D<[^<>]*(?:<[^<>]*>[^<>]*)?>|complex<(?:float|double)>"
+    r"C?Array(?:[1-9]|1[0-6])D<[^<>]*(?:<[^<>]*>[^<>]*)?>|complex<(?:float|double)>"
     r"|[A-Za-z_]\w*|\*|\[\s*\]",
 )
 
@@ -905,8 +905,8 @@ def _pyccel_ctype(annotation: Any, scalars: Mapping[str, str], what: str) -> str
     ctype = scalars[scalar]
     if ndim == 0:
         return ctype
-    if ndim > 4:
-        raise ValueError(f"{what}: arrays have at most 4 dimensions, got {ndim}")
+    if ndim > 16:
+        raise ValueError(f"{what}: arrays have at most 16 dimensions, got {ndim}")
     return f"Array{ndim}D<{ctype}>"
 
 
@@ -1075,7 +1075,7 @@ class CudaStruct:
         ``(field name, C type)`` pairs, in order, e.g. ``("x", "double*")`` or
         ``("n", "int")``. Scalar fields, pointers to the scalar types of
         :func:`ctype_of` (or ``void*``), and array views ``Array1D<T>`` to
-        ``Array4D<T>`` of those scalar types (from ``cunumpy/array_view.cuh``,
+        ``Array16D<T>`` of those scalar types (from ``cunumpy/array_view.cuh``,
         packed as pointer, shape and strides in elements) are supported.
 
     Examples
@@ -1848,7 +1848,7 @@ class CudaKernel:
         The headers shipped with cunumpy (:func:`cuda_include_dir`) are always
         found at compile time (see :meth:`compile_options`):
         ``#include "cunumpy/array_view.cuh"`` gives the ``Array1D<T>`` to
-        ``Array4D<T>`` views, ``#include "cunumpy/index.cuh"`` the thread-index
+        ``Array16D<T>`` views, ``#include "cunumpy/index.cuh"`` the thread-index
         macros, ``#include "cunumpy/atomic.cuh"`` atomic adds,
         ``#include "cunumpy/reduce.cuh"`` warp and block reductions.
     source_dir : str | Path | None

{cunumpy-0.6.0 → cunumpy-0.6.1}/src/cunumpy/_emulation.py

@@ -16,7 +16,7 @@ so the call looks like a launch::
     np.testing.assert_allclose(y, 2.0 * x)
 
 Arguments follow the kernel signature: NumPy arrays for pointer and array view
-parameters (``Array1D<T>`` to ``Array4D<T>``; any strides, they are passed as
+parameters (``Array1D<T>`` to ``Array16D<T>``; any strides, they are passed as
 contiguous copies), Python or NumPy scalars for scalar parameters (cast and
 checked like in a launch). Arrays are written back into the given arrays.
 
@@ -354,7 +354,7 @@ def emulate_cuda_kernel(
                 buffer.tofile(path)
                 ctype = param.ctype if param.dtype is not None else "unsigned char"
                 element = (
-                    re.match(r"C?Array\dD<(.*)>", ctype).group(1)
+                    re.match(r"C?Array\d+D<(.*)>", ctype).group(1)
                     if param.view_ndim is not None
                     else ctype
                 )

{cunumpy-0.6.0 → cunumpy-0.6.1}/src/cunumpy/cuda/include/cunumpy/array_view.cuh

@@ -1,6 +1,6 @@
 // Array views for CUDA kernels, passed by value from Python.
 //
-// Array1D<T> to Array4D<T> describe a (possibly non-contiguous)
+// Array1D<T> to Array16D<T> describe a (possibly non-contiguous)
 // device array the way NumPy/CuPy do: a data pointer, a shape and strides.
 // Strides are in ELEMENTS, not bytes, so that `a(i, j)` is
 // `data[i * strides[0] + j * strides[1]]`. Elements are accessed with
@@ -9,7 +9,7 @@
 //
 // The views are created on the Python side by cunumpy (a kernel parameter or a
 // CudaStruct field of type `Array2D<double>` takes a CuPy array). They are
-// passed by value, so the memory layout must be exactly, for ndim = 1 to 4:
+// passed by value, so the memory layout must be exactly, for ndim = 1 to 16:
 //
 //     T* data;                  // 8 bytes
 //     long long shape[ndim];    // ndim * 8 bytes
@@ -20,12 +20,12 @@
 // the end of this file check the size. Member functions do not change the
 // layout.
 //
-// CArray1D<T> to CArray4D<T> are C-contiguous (row-major) views: a data
+// CArray1D<T> to CArray16D<T> are C-contiguous (row-major) views: a data
 // pointer and a shape, no strides. `a(i, j)` is `data[i * shape[1] + j]`, so
 // the last index is always the fast one and the compiler knows it has unit
 // stride. A parameter or field of these types only takes C-contiguous arrays;
 // cunumpy raises for a non-contiguous view instead of copying it (a copy would
-// silently drop what the kernel writes). Their layout, for ndim = 1 to 4:
+// silently drop what the kernel writes). Their layout, for ndim = 1 to 16:
 //
 //     T* data;                  // 8 bytes
 //     long long shape[ndim];    // ndim * 8 bytes
@@ -223,6 +223,101 @@ struct CArray4D {
     }
 };
 
+// Higher-dimensional views share an implementation; aliases keep the named
+// types used by kernel signatures and Python's argument packer.
+namespace cunumpy_detail {
+template <typename T, int N>
+struct ArrayView {
+    T* data;
+    long long shape[N];
+    long long strides[N];
+
+    template <typename... Indices>
+    __device__ __forceinline__ T& operator()(Indices... indices) const {
+        static_assert(sizeof...(Indices) == N, "wrong number of array indices");
+        const long long index[N] = {static_cast<long long>(indices)...};
+        long long offset = 0;
+        #pragma unroll
+        for (int axis = 0; axis < N; ++axis) {
+            CUNUMPY_CHECK_INDEX(index[axis], axis, shape[axis]);
+            offset += index[axis] * strides[axis];
+        }
+        return data[offset];
+    }
+
+    __device__ __forceinline__ long long size() const {
+        long long result = 1;
+        #pragma unroll
+        for (int axis = 0; axis < N; ++axis) result *= shape[axis];
+        return result;
+    }
+};
+
+template <typename T, int N>
+struct CArrayView {
+    T* data;
+    long long shape[N];
+
+    template <typename... Indices>
+    __device__ __forceinline__ T& operator()(Indices... indices) const {
+        static_assert(sizeof...(Indices) == N, "wrong number of array indices");
+        const long long index[N] = {static_cast<long long>(indices)...};
+        long long offset = 0;
+        #pragma unroll
+        for (int axis = 0; axis < N; ++axis) {
+            CUNUMPY_CHECK_INDEX(index[axis], axis, shape[axis]);
+            offset = offset * shape[axis] + index[axis];
+        }
+        return data[offset];
+    }
+
+    __device__ __forceinline__ long long size() const {
+        long long result = 1;
+        #pragma unroll
+        for (int axis = 0; axis < N; ++axis) result *= shape[axis];
+        return result;
+    }
+
+    __host__ __device__ operator ArrayView<T, N>() const {
+        ArrayView<T, N> result{};
+        result.data = data;
+        long long stride = 1;
+        #pragma unroll
+        for (int axis = N - 1; axis >= 0; --axis) {
+            result.shape[axis] = shape[axis];
+            result.strides[axis] = stride;
+            stride *= shape[axis];
+        }
+        return result;
+    }
+};
+}  // namespace cunumpy_detail
+
+template <typename T> using Array5D = cunumpy_detail::ArrayView<T, 5>;
+template <typename T> using CArray5D = cunumpy_detail::CArrayView<T, 5>;
+template <typename T> using Array6D = cunumpy_detail::ArrayView<T, 6>;
+template <typename T> using CArray6D = cunumpy_detail::CArrayView<T, 6>;
+template <typename T> using Array7D = cunumpy_detail::ArrayView<T, 7>;
+template <typename T> using CArray7D = cunumpy_detail::CArrayView<T, 7>;
+template <typename T> using Array8D = cunumpy_detail::ArrayView<T, 8>;
+template <typename T> using CArray8D = cunumpy_detail::CArrayView<T, 8>;
+template <typename T> using Array9D = cunumpy_detail::ArrayView<T, 9>;
+template <typename T> using CArray9D = cunumpy_detail::CArrayView<T, 9>;
+template <typename T> using Array10D = cunumpy_detail::ArrayView<T, 10>;
+template <typename T> using CArray10D = cunumpy_detail::CArrayView<T, 10>;
+template <typename T> using Array11D = cunumpy_detail::ArrayView<T, 11>;
+template <typename T> using CArray11D = cunumpy_detail::CArrayView<T, 11>;
+template <typename T> using Array12D = cunumpy_detail::ArrayView<T, 12>;
+template <typename T> using CArray12D = cunumpy_detail::CArrayView<T, 12>;
+template <typename T> using Array13D = cunumpy_detail::ArrayView<T, 13>;
+template <typename T> using CArray13D = cunumpy_detail::CArrayView<T, 13>;
+template <typename T> using Array14D = cunumpy_detail::ArrayView<T, 14>;
+template <typename T> using CArray14D = cunumpy_detail::CArrayView<T, 14>;
+template <typename T> using Array15D = cunumpy_detail::ArrayView<T, 15>;
+template <typename T> using CArray15D = cunumpy_detail::CArrayView<T, 15>;
+template <typename T> using Array16D = cunumpy_detail::ArrayView<T, 16>;
+template <typename T> using CArray16D = cunumpy_detail::CArrayView<T, 16>;
+
 // The layouts the Python side packs: pointer, shape (and strides), 8-byte
 // aligned.
 static_assert(sizeof(Array1D<double>) == 24, "unexpected Array1D layout");
@@ -237,4 +332,53 @@ static_assert(sizeof(CArray3D<double>) == 32, "unexpected CArray3D layout");
 static_assert(sizeof(CArray4D<double>) == 40, "unexpected CArray4D layout");
 static_assert(alignof(CArray2D<float>) == 8, "unexpected CArray2D alignment");
 
+static_assert(sizeof(Array5D<double>) == 88, "unexpected Array5D layout");
+static_assert(alignof(Array5D<float>) == 8, "unexpected Array5D alignment");
+static_assert(sizeof(CArray5D<double>) == 48, "unexpected CArray5D layout");
+static_assert(alignof(CArray5D<float>) == 8, "unexpected CArray5D alignment");
+static_assert(sizeof(Array6D<double>) == 104, "unexpected Array6D layout");
+static_assert(alignof(Array6D<float>) == 8, "unexpected Array6D alignment");
+static_assert(sizeof(CArray6D<double>) == 56, "unexpected CArray6D layout");
+static_assert(alignof(CArray6D<float>) == 8, "unexpected CArray6D alignment");
+static_assert(sizeof(Array7D<double>) == 120, "unexpected Array7D layout");
+static_assert(alignof(Array7D<float>) == 8, "unexpected Array7D alignment");
+static_assert(sizeof(CArray7D<double>) == 64, "unexpected CArray7D layout");
+static_assert(alignof(CArray7D<float>) == 8, "unexpected CArray7D alignment");
+static_assert(sizeof(Array8D<double>) == 136, "unexpected Array8D layout");
+static_assert(alignof(Array8D<float>) == 8, "unexpected Array8D alignment");
+static_assert(sizeof(CArray8D<double>) == 72, "unexpected CArray8D layout");
+static_assert(alignof(CArray8D<float>) == 8, "unexpected CArray8D alignment");
+static_assert(sizeof(Array9D<double>) == 152, "unexpected Array9D layout");
+static_assert(alignof(Array9D<float>) == 8, "unexpected Array9D alignment");
+static_assert(sizeof(CArray9D<double>) == 80, "unexpected CArray9D layout");
+static_assert(alignof(CArray9D<float>) == 8, "unexpected CArray9D alignment");
+static_assert(sizeof(Array10D<double>) == 168, "unexpected Array10D layout");
+static_assert(alignof(Array10D<float>) == 8, "unexpected Array10D alignment");
+static_assert(sizeof(CArray10D<double>) == 88, "unexpected CArray10D layout");
+static_assert(alignof(CArray10D<float>) == 8, "unexpected CArray10D alignment");
+static_assert(sizeof(Array11D<double>) == 184, "unexpected Array11D layout");
+static_assert(alignof(Array11D<float>) == 8, "unexpected Array11D alignment");
+static_assert(sizeof(CArray11D<double>) == 96, "unexpected CArray11D layout");
+static_assert(alignof(CArray11D<float>) == 8, "unexpected CArray11D alignment");
+static_assert(sizeof(Array12D<double>) == 200, "unexpected Array12D layout");
+static_assert(alignof(Array12D<float>) == 8, "unexpected Array12D alignment");
+static_assert(sizeof(CArray12D<double>) == 104, "unexpected CArray12D layout");
+static_assert(alignof(CArray12D<float>) == 8, "unexpected CArray12D alignment");
+static_assert(sizeof(Array13D<double>) == 216, "unexpected Array13D layout");
+static_assert(alignof(Array13D<float>) == 8, "unexpected Array13D alignment");
+static_assert(sizeof(CArray13D<double>) == 112, "unexpected CArray13D layout");
+static_assert(alignof(CArray13D<float>) == 8, "unexpected CArray13D alignment");
+static_assert(sizeof(Array14D<double>) == 232, "unexpected Array14D layout");
+static_assert(alignof(Array14D<float>) == 8, "unexpected Array14D alignment");
+static_assert(sizeof(CArray14D<double>) == 120, "unexpected CArray14D layout");
+static_assert(alignof(CArray14D<float>) == 8, "unexpected CArray14D alignment");
+static_assert(sizeof(Array15D<double>) == 248, "unexpected Array15D layout");
+static_assert(alignof(Array15D<float>) == 8, "unexpected Array15D alignment");
+static_assert(sizeof(CArray15D<double>) == 128, "unexpected CArray15D layout");
+static_assert(alignof(CArray15D<float>) == 8, "unexpected CArray15D alignment");
+static_assert(sizeof(Array16D<double>) == 264, "unexpected Array16D layout");
+static_assert(alignof(Array16D<float>) == 8, "unexpected Array16D alignment");
+static_assert(sizeof(CArray16D<double>) == 136, "unexpected CArray16D layout");
+static_assert(alignof(CArray16D<float>) == 8, "unexpected CArray16D alignment");
+
 #endif  // CUNUMPY_ARRAY_VIEW_CUH

{cunumpy-0.6.0 → cunumpy-0.6.1}/src/cunumpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.6.0
+Version: 0.6.1
 Summary: Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
 Author: Max
 Project-URL: Source, https://github.com/max-models/cunumpy
@@ -434,7 +434,7 @@ kernel(particles.args_markers, dt)  # host or CUDA kernel
 Kernels ported from pyccel index arrays like `markers[ip, j]`, which needs
 shapes and strides rather than bare pointers. The shipped header
 `cunumpy/array_view.cuh` (found by every `CudaKernel`) provides the strided
-views `Array1D<T>` to `Array4D<T>`; a parameter or struct field of that type
+views `Array1D<T>` to `Array16D<T>`; a parameter or struct field of that type
 takes a CuPy array, contiguous or not, and indexes `a(i, j)`. The struct can be
 generated from the annotations of the pyccel argument class, so the Python
 class is the one definition, and written to a header that a test keeps in sync:
@@ -444,7 +444,9 @@ class MarkerArguments:
     def __init__(self, markers: "float[:, :]", n_markers: int, valid: "bool[:]"): ...
 
 
-MarkerArgs = xp.arguments.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
+MarkerArgs = xp.arguments.CudaStruct.from_signature(
+    MarkerArguments.__init__, "MarkerArgs"
+)
 MarkerArgs.to_header(
     "marker_args.cuh"
 )  # Array2D<double> markers; long long n_markers; ...