warp-lang 1.3.2__py3-none-win_amd64.whl → 1.4.0__py3-none-win_amd64.whl

warp/native/mesh.cu

@@ -290,3 +290,54 @@ void mesh_refit_device(uint64_t id)
     }
 }
 
+void mesh_set_points_device(uint64_t id, wp::array_t<wp::vec3> points)
+{
+    wp::Mesh m;
+    if (mesh_get_descriptor(id, m))
+    {
+        if (points.ndim != 1 || points.shape[0] != m.points.shape[0])
+        {
+            fprintf(stderr, "The new points input for mesh_set_points_device does not match the shape of the original points!\n");
+            return;
+        }
+
+        m.points = points;
+
+        wp::Mesh* mesh_device = (wp::Mesh*)id;
+        memcpy_h2d(WP_CURRENT_CONTEXT, mesh_device, &m, sizeof(wp::Mesh));
+
+        // update the cpu copy as well
+        mesh_set_descriptor(id, m);
+
+        mesh_refit_device(id);
+    }
+    else 
+    {
+        fprintf(stderr, "The mesh id provided to mesh_set_points_device is not valid!\n");
+        return;
+    }
+}
+
+void mesh_set_velocities_device(uint64_t id, wp::array_t<wp::vec3> velocities)
+{
+    wp::Mesh m;
+    if (mesh_get_descriptor(id, m))
+    {
+        if (velocities.ndim != 1 || velocities.shape[0] != m.velocities.shape[0])
+        {
+            fprintf(stderr, "The new velocities input for mesh_set_velocities_device does not match the shape of the original velocities\n");
+            return;
+        }
+
+        m.velocities = velocities;
+
+        wp::Mesh* mesh_device = (wp::Mesh*)id;
+        memcpy_h2d(WP_CURRENT_CONTEXT, mesh_device, &m, sizeof(wp::Mesh));
+        mesh_set_descriptor(id, m);
+    }
+    else 
+    {
+        fprintf(stderr, "The mesh id provided to mesh_set_velocities_device is not valid!\n");
+        return;
+    }
+}

warp/native/mesh.h

@@ -1881,6 +1881,7 @@ CUDA_CALLABLE inline void adj_mesh_get_index(uint64_t id, int index,
 }
 
 CUDA_CALLABLE bool mesh_get_descriptor(uint64_t id, Mesh& mesh);
+CUDA_CALLABLE bool mesh_set_descriptor(uint64_t id, const Mesh& mesh);
 CUDA_CALLABLE void mesh_add_descriptor(uint64_t id, const Mesh& mesh);
 CUDA_CALLABLE void mesh_rem_descriptor(uint64_t id);
 

warp/native/quat.h

@@ -29,6 +29,14 @@ struct quat_t
         w = static_cast<Type>(other.w);
     }
 
+    inline CUDA_CALLABLE quat_t(const initializer_array<4, Type> &l)
+    {
+        x = l[0];
+        y = l[1];
+        z = l[2];
+        w = l[3];
+    }
+
     // imaginary part
     Type x;
     Type y;
@@ -479,6 +487,41 @@ inline CUDA_CALLABLE void adj_indexref(quat_t<Type>* q, int idx,
     // nop
 }
 
+template<typename Type>
+inline CUDA_CALLABLE quat_t<Type> assign(quat_t<Type>& q, int idx, Type value)
+{
+#ifndef NDEBUG
+    if (idx < 0 || idx > 3)
+    {
+        printf("quat index %d out of bounds at %s %d\n", idx, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    quat_t<Type> ret(q);
+    ret[idx] = value;
+    return ret;
+}
+
+template<typename Type>
+inline CUDA_CALLABLE void adj_assign(quat_t<Type>& q, int idx, Type value, quat_t<Type>& adj_q, int& adj_idx, Type& adj_value, const quat_t<Type>& adj_ret)
+{
+#ifndef NDEBUG
+    if (idx < 0 || idx > 3)
+    {
+        printf("quat index %d out of bounds at %s %d\n", idx, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    adj_value += adj_ret[idx];
+    for(unsigned i=0; i < 4; ++i)
+    {
+        if(i != idx)
+            adj_q[i] += adj_ret[i];
+    }
+}
+
 template<typename Type>
 CUDA_CALLABLE inline quat_t<Type> lerp(const quat_t<Type>& a, const quat_t<Type>& b, Type t)
 {

warp/native/spatial.h

@@ -127,6 +127,12 @@ struct transform_t
     CUDA_CALLABLE inline transform_t(vec_t<3,Type> p=vec_t<3,Type>(), quat_t<Type> q=quat_t<Type>()) : p(p), q(q) {}
     CUDA_CALLABLE inline transform_t(Type)  {}  // helps uniform initialization
 
+    CUDA_CALLABLE inline transform_t(const initializer_array<7, Type> &l)
+    {
+        p = vec_t<3,Type>(l[0], l[1], l[2]);
+        q = quat_t<Type>(l[3], l[4], l[5], l[6]);
+    }
+
     CUDA_CALLABLE inline Type operator[](int index) const
     {
         assert(index < 7);

warp/native/vec.h

@@ -381,6 +381,31 @@ inline CUDA_CALLABLE vec_t<3, Type> sub(vec_t<3, Type> a, vec_t<3, Type> b)
     return vec_t<3, Type>( a.c[0] - b.c[0], a.c[1] - b.c[1], a.c[2] - b.c[2]);
 }
 
+// modulo
+template<unsigned Length, typename Type>
+inline CUDA_CALLABLE vec_t<Length, Type> mod(vec_t<Length, Type> a, vec_t<Length, Type> b)
+{
+    vec_t<Length, Type> ret;
+    for (unsigned i=0; i < Length; ++i)
+    {
+        ret[i] = mod(a[i], b[i]);
+    }
+
+    return ret;
+}
+
+template<typename Type>
+inline CUDA_CALLABLE vec_t<2, Type> mod(vec_t<2, Type> a, vec_t<2, Type> b)
+{
+    return vec_t<2, Type>(mod(a.c[0], b.c[0]), mod(a.c[1], b.c[1]));
+}
+
+template<typename Type>
+inline CUDA_CALLABLE vec_t<3, Type> mod(vec_t<3, Type> a, vec_t<3, Type> b)
+{
+    return vec_t<3, Type>(mod(a.c[0], b.c[0]), mod(a.c[1], b.c[1]), mod(a.c[2], b.c[2]));
+}
+
 // dot product:
 template<unsigned Length, typename Type>
 inline CUDA_CALLABLE Type dot(vec_t<Length, Type> a, vec_t<Length, Type> b)
@@ -470,6 +495,40 @@ inline CUDA_CALLABLE void adj_indexref(vec_t<Length, Type>* v, int idx,
     // nop
 }
 
+template<unsigned Length, typename Type>
+inline CUDA_CALLABLE vec_t<Length, Type> assign(vec_t<Length, Type>& v, int idx, Type value)
+{
+#ifndef NDEBUG
+    if (idx < 0 || idx >= Length)
+    {
+        printf("vec index %d out of bounds at %s %d\n", idx, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    vec_t<Length, Type> ret(v);
+    ret[idx] = value;
+    return ret;
+}
+
+template<unsigned Length, typename Type>
+inline CUDA_CALLABLE void adj_assign(vec_t<Length, Type>& v, int idx, Type value, vec_t<Length, Type>& adj_v, int& adj_idx, Type& adj_value, const vec_t<Length, Type>& adj_ret)
+{
+#ifndef NDEBUG
+    if (idx < 0 || idx >= Length)
+    {
+        printf("vec index %d out of bounds at %s %d\n", idx, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    adj_value += adj_ret[idx];
+    for(unsigned i=0; i < Length; ++i)
+    {
+        if (i != idx)
+            adj_v[i] += adj_ret[i];
+    }
+}
 
 template<unsigned Length, typename Type>
 inline CUDA_CALLABLE Type length(vec_t<Length, Type> a)
@@ -896,6 +955,21 @@ inline CUDA_CALLABLE void adj_sub(vec_t<3, Type> a, vec_t<3, Type> b, vec_t<3, T
     adj_b.c[2] -= adj_ret.c[2];
 }
 
+template<unsigned Length, typename Type>
+inline CUDA_CALLABLE void adj_mod(vec_t<Length, Type> a, vec_t<Length, Type> b, vec_t<Length, Type>& adj_a, vec_t<Length, Type>& adj_b, const vec_t<Length, Type>& adj_ret)
+{
+}
+
+template<typename Type>
+inline CUDA_CALLABLE void adj_mod(vec_t<2, Type> a, vec_t<2, Type> b, vec_t<2, Type>& adj_a, vec_t<2, Type>& adj_b, const vec_t<2, Type>& adj_ret)
+{
+}
+
+template<typename Type>
+inline CUDA_CALLABLE void adj_mod(vec_t<3, Type> a, vec_t<3, Type> b, vec_t<3, Type>& adj_a, vec_t<3, Type>& adj_b, const vec_t<3, Type>& adj_ret)
+{
+}
+
 template<unsigned Length, typename Type>
 inline CUDA_CALLABLE void adj_dot(vec_t<Length, Type> a, vec_t<Length, Type> b, vec_t<Length, Type>& adj_a, vec_t<Length, Type>& adj_b, const Type adj_ret)
 {

warp/native/warp.cpp

@@ -1010,7 +1010,7 @@ WP_API int cuda_set_peer_access_enabled(void* target_context, void* peer_context
 WP_API int cuda_is_mempool_access_enabled(int target_ordinal, int peer_ordinal) { return 0; }
 WP_API int cuda_set_mempool_access_enabled(int target_ordinal, int peer_ordinal, int enable) { return 0; }
 
-WP_API void* cuda_stream_create(void* context) { return NULL; }
+WP_API void* cuda_stream_create(void* context, int priority) { return NULL; }
 WP_API void cuda_stream_destroy(void* context, void* stream) {}
 WP_API void cuda_stream_register(void* context, void* stream) {}
 WP_API void cuda_stream_unregister(void* context, void* stream) {}
@@ -1020,6 +1020,7 @@ WP_API void cuda_stream_wait_event(void* stream, void* event) {}
 WP_API void cuda_stream_wait_stream(void* stream, void* other_stream, void* event) {}
 WP_API int cuda_stream_is_capturing(void* stream) { return 0; }
 WP_API uint64_t cuda_stream_get_capture_id(void* stream) { return 0; }
+WP_API int cuda_stream_get_priority(void* stream) { return 0; }
 
 WP_API void* cuda_event_create(void* context, unsigned flags) { return NULL; }
 WP_API void cuda_event_destroy(void* event) {}

warp/native/warp.cu

@@ -1963,7 +1963,6 @@ void cuda_context_set_stream(void* context, void* stream, int sync)
     }
 }
 
-
 int cuda_is_peer_access_supported(int target_ordinal, int peer_ordinal)
 {
     int num_devices = int(g_devices.size());
@@ -2174,12 +2173,12 @@ int cuda_set_mempool_access_enabled(int target_ordinal, int peer_ordinal, int en
 }
 
 
-void* cuda_stream_create(void* context)
+void* cuda_stream_create(void* context, int priority)
 {
     ContextGuard guard(context, true);
 
     CUstream stream;
-    if (check_cu(cuStreamCreate_f(&stream, CU_STREAM_DEFAULT)))
+    if (check_cu(cuStreamCreateWithPriority_f(&stream, CU_STREAM_DEFAULT, priority)))
     {
         cuda_stream_register(WP_CURRENT_CONTEXT, stream);
         return stream;
@@ -2268,6 +2267,14 @@ uint64_t cuda_stream_get_capture_id(void* stream)
     return get_capture_id(static_cast<CUstream>(stream));
 }
 
+int cuda_stream_get_priority(void* stream)
+{
+    int priority = 0;
+    check_cuda(cuStreamGetPriority_f(static_cast<CUstream>(stream), &priority));
+
+    return priority;
+}
+
 void* cuda_event_create(void* context, unsigned flags)
 {
     ContextGuard guard(context, true);

warp/native/warp.h

@@ -83,6 +83,12 @@ extern "C"
 	WP_API void mesh_destroy_device(uint64_t id);
     WP_API void mesh_refit_device(uint64_t id);
 
+    WP_API void mesh_set_points_host(uint64_t id, wp::array_t<wp::vec3> points);
+    WP_API void mesh_set_points_device(uint64_t id, wp::array_t<wp::vec3> points);
+
+    WP_API void mesh_set_velocities_host(uint64_t id, wp::array_t<wp::vec3> velocities);
+    WP_API void mesh_set_velocities_device(uint64_t id, wp::array_t<wp::vec3> velocities);
+
     WP_API uint64_t hash_grid_create_host(int dim_x, int dim_y, int dim_z);
     WP_API void hash_grid_reserve_host(uint64_t id, int num_points);
     WP_API void hash_grid_destroy_host(uint64_t id);
@@ -286,7 +292,7 @@ extern "C"
     WP_API int cuda_is_mempool_access_enabled(int target_ordinal, int peer_ordinal);
     WP_API int cuda_set_mempool_access_enabled(int target_ordinal, int peer_ordinal, int enable);
 
-    WP_API void* cuda_stream_create(void* context);
+    WP_API void* cuda_stream_create(void* context, int priority);
     WP_API void cuda_stream_destroy(void* context, void* stream);
     WP_API void cuda_stream_register(void* context, void* stream);
     WP_API void cuda_stream_unregister(void* context, void* stream);
@@ -296,6 +302,7 @@ extern "C"
     WP_API void cuda_stream_wait_stream(void* stream, void* other_stream, void* event);
     WP_API int cuda_stream_is_capturing(void* stream);
     WP_API uint64_t cuda_stream_get_capture_id(void* stream);
+    WP_API int cuda_stream_get_priority(void* stream);
 
     WP_API void* cuda_event_create(void* context, unsigned flags);
     WP_API void cuda_event_destroy(void* event);

warp/paddle.py

@@ -0,0 +1,382 @@
+# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+from __future__ import annotations
+
+import ctypes
+from typing import TYPE_CHECKING, Optional, Union
+
+import numpy
+
+import warp
+import warp.context
+
+if TYPE_CHECKING:
+    import paddle
+
+
+# return the warp device corresponding to a paddle device
+def device_from_paddle(paddle_device: Union[paddle.base.libpaddle.Place, str]) -> warp.context.Device:
+    """Return the Warp device corresponding to a Paddle device.
+
+    Args:
+        paddle_device (`paddle.base.libpaddle.Place` or `str`): Paddle device identifier
+
+    Raises:
+        RuntimeError: Paddle device does not have a corresponding Warp device
+    """
+    if type(paddle_device) is str:
+        warp_device = warp.context.runtime.device_map.get(paddle_device)
+        if warp_device is not None:
+            return warp_device
+        elif paddle_device.startswith("gpu"):
+            return warp.context.runtime.get_current_cuda_device()
+        else:
+            raise RuntimeError(f"Unsupported Paddle device {paddle_device}")
+    else:
+        import paddle
+
+        try:
+            if paddle_device.is_gpu_place():
+                return warp.context.runtime.cuda_devices[paddle_device.gpu_device_id()]
+            elif paddle_device.is_cpu_place():
+                return warp.context.runtime.cpu_device
+            else:
+                raise RuntimeError(f"Unsupported Paddle device type {paddle_device}")
+        except Exception as e:
+            import paddle
+
+            if not isinstance(paddle_device, paddle.base.libpaddle.Place):
+                raise ValueError("Argument must be a paddle.base.libpaddle.Place object or a string") from e
+            raise
+
+
+def device_to_paddle(warp_device: warp.context.Devicelike) -> str:
+    """Return the Paddle device string corresponding to a Warp device.
+
+    Args:
+        warp_device: An identifier that can be resolved to a :class:`warp.context.Device`.
+
+    Raises:
+        RuntimeError: The Warp device is not compatible with PyPaddle.
+    """
+    device = warp.get_device(warp_device)
+    if device.is_cpu or device.is_primary:
+        return str(device).replace("cuda", "gpu")
+    elif device.is_cuda and device.is_uva:
+        # it's not a primary context, but paddle can access the data ptr directly thanks to UVA
+        return f"gpu:{device.ordinal}"
+    raise RuntimeError(f"Warp device {device} is not compatible with paddle")
+
+
+def dtype_to_paddle(warp_dtype):
+    """Return the Paddle dtype corresponding to a Warp dtype.
+
+    Args:
+        warp_dtype: A Warp data type that has a corresponding ``paddle.dtype``.
+            ``warp.uint16``, ``warp.uint32``, and ``warp.uint64`` are mapped
+            to the signed integer ``paddle.dtype`` of the same width.
+    Raises:
+        TypeError: Unable to find a corresponding PyPaddle data type.
+    """
+    # initialize lookup table on first call to defer paddle import
+    if dtype_to_paddle.type_map is None:
+        import paddle
+
+        dtype_to_paddle.type_map = {
+            warp.float16: paddle.float16,
+            warp.float32: paddle.float32,
+            warp.float64: paddle.float64,
+            warp.int8: paddle.int8,
+            warp.int16: paddle.int16,
+            warp.int32: paddle.int32,
+            warp.int64: paddle.int64,
+            warp.uint8: paddle.uint8,
+            warp.bool: paddle.bool,
+            # paddle doesn't support unsigned ints bigger than 8 bits
+            warp.uint16: paddle.int16,
+            warp.uint32: paddle.int32,
+            warp.uint64: paddle.int64,
+        }
+
+    paddle_dtype = dtype_to_paddle.type_map.get(warp_dtype)
+    if paddle_dtype is not None:
+        return paddle_dtype
+    else:
+        raise TypeError(f"Cannot convert {warp_dtype} to a Paddle type")
+
+
+def dtype_from_paddle(paddle_dtype):
+    """Return the Warp dtype corresponding to a Paddle dtype.
+
+    Args:
+        paddle_dtype: A ``paddle.dtype`` that has a corresponding Warp data type.
+            Currently ``paddle.bfloat16``, ``paddle.complex64``, and
+            ``paddle.complex128`` are not supported.
+
+    Raises:
+        TypeError: Unable to find a corresponding Warp data type.
+    """
+    # initialize lookup table on first call to defer paddle import
+    if dtype_from_paddle.type_map is None:
+        import paddle
+
+        dtype_from_paddle.type_map = {
+            paddle.float16: warp.float16,
+            paddle.float32: warp.float32,
+            paddle.float64: warp.float64,
+            paddle.int8: warp.int8,
+            paddle.int16: warp.int16,
+            paddle.int32: warp.int32,
+            paddle.int64: warp.int64,
+            paddle.uint8: warp.uint8,
+            paddle.bool: warp.bool,
+            # currently unsupported by Warp
+            # paddle.bfloat16:
+            # paddle.complex64:
+            # paddle.complex128:
+        }
+
+    warp_dtype = dtype_from_paddle.type_map.get(paddle_dtype)
+
+    if warp_dtype is not None:
+        return warp_dtype
+    else:
+        raise TypeError(f"Cannot convert {paddle_dtype} to a Warp type")
+
+
+def dtype_is_compatible(paddle_dtype: paddle.dtype, warp_dtype) -> bool:
+    """Evaluates whether the given paddle dtype is compatible with the given Warp dtype."""
+    # initialize lookup table on first call to defer paddle import
+    if dtype_is_compatible.compatible_sets is None:
+        import paddle
+
+        dtype_is_compatible.compatible_sets = {
+            paddle.float64: {warp.float64},
+            paddle.float32: {warp.float32},
+            paddle.float16: {warp.float16},
+            # allow aliasing integer tensors as signed or unsigned integer arrays
+            paddle.int64: {warp.int64, warp.uint64},
+            paddle.int32: {warp.int32, warp.uint32},
+            paddle.int16: {warp.int16, warp.uint16},
+            paddle.int8: {warp.int8, warp.uint8},
+            paddle.uint8: {warp.uint8, warp.int8},
+            paddle.bool: {warp.bool, warp.uint8, warp.int8},
+            # currently unsupported by Warp
+            # paddle.bfloat16:
+            # paddle.complex64:
+            # paddle.complex128:
+        }
+
+    compatible_set = dtype_is_compatible.compatible_sets.get(paddle_dtype)
+
+    if compatible_set is not None:
+        if warp_dtype in compatible_set:
+            return True
+        # check if it's a vector or matrix type
+        if hasattr(warp_dtype, "_wp_scalar_type_"):
+            return warp_dtype._wp_scalar_type_ in compatible_set
+
+    return False
+
+
+# lookup tables initialized when needed
+dtype_from_paddle.type_map = None
+dtype_to_paddle.type_map = None
+dtype_is_compatible.compatible_sets = None
+
+
+# wrap a paddle tensor to a wp array, data is not copied
+def from_paddle(
+    t: paddle.Tensor,
+    dtype: Optional[paddle.dtype] = None,
+    requires_grad: Optional[bool] = None,
+    grad: Optional[paddle.Tensor] = None,
+    return_ctype: bool = False,
+) -> warp.array:
+    """Convert a Paddle tensor to a Warp array without copying the data.
+
+    Args:
+        t (paddle.Tensor): The paddle tensor to wrap.
+        dtype (warp.dtype, optional): The target data type of the resulting Warp array. Defaults to the tensor value type mapped to a Warp array value type.
+        requires_grad (bool, optional): Whether the resulting array should wrap the tensor's gradient, if it exists (the grad tensor will be allocated otherwise). Defaults to the tensor's `requires_grad` value.
+        grad (paddle.Tensor, optional): The grad attached to given tensor. Defaults to None.
+        return_ctype (bool, optional): Whether to return a low-level array descriptor instead of a ``wp.array`` object (faster).  The descriptor can be passed to Warp kernels.
+
+    Returns:
+        warp.array: The wrapped array or array descriptor.
+    """
+    if dtype is None:
+        dtype = dtype_from_paddle(t.dtype)
+    elif not dtype_is_compatible(t.dtype, dtype):
+        raise RuntimeError(f"Cannot convert Paddle type {t.dtype} to Warp type {dtype}")
+
+    # get size of underlying data type to compute strides
+    ctype_size = ctypes.sizeof(dtype._type_)
+
+    shape = tuple(t.shape)
+    strides = tuple(s * ctype_size for s in t.strides)
+
+    # if target is a vector or matrix type
+    # then check if trailing dimensions match
+    # the target type and update the shape
+    if hasattr(dtype, "_shape_"):
+        dtype_shape = dtype._shape_
+        dtype_dims = len(dtype._shape_)
+        # ensure inner shape matches
+        if dtype_dims > len(shape) or dtype_shape != shape[-dtype_dims:]:
+            raise RuntimeError(
+                f"Could not convert Paddle tensor with shape {shape} to Warp array with dtype={dtype}, ensure that source inner shape is {dtype_shape}"
+            )
+        # ensure inner strides are contiguous
+        if strides[-1] != ctype_size or (dtype_dims > 1 and strides[-2] != ctype_size * dtype_shape[-1]):
+            raise RuntimeError(
+                f"Could not convert Paddle tensor with shape {shape} to Warp array with dtype={dtype}, because the source inner strides are not contiguous"
+            )
+        # trim shape and strides
+        shape = tuple(shape[:-dtype_dims]) or (1,)
+        strides = tuple(strides[:-dtype_dims]) or (ctype_size,)
+
+    # gradient
+    # - if return_ctype is False, we set `grad` to a wp.array or None
+    # - if return_ctype is True, we set `grad_ptr` and set `grad` as the owner (wp.array or paddle.Tensor)
+    requires_grad = (not t.stop_gradient) if requires_grad is None else requires_grad
+    grad_ptr = 0
+    if grad is not None:
+        if isinstance(grad, warp.array):
+            if return_ctype:
+                if grad.strides != strides:
+                    raise RuntimeError(
+                        f"Gradient strides must match array strides, expected {strides} but got {grad.strides}"
+                    )
+                grad_ptr = grad.ptr
+        else:
+            # assume grad is a paddle.Tensor
+            if return_ctype:
+                if t.strides != grad.strides:
+                    raise RuntimeError(
+                        f"Gradient strides must match array strides, expected {t.strides} but got {grad.strides}"
+                    )
+                grad_ptr = grad.data_ptr()
+            else:
+                grad = from_paddle(grad, dtype=dtype, requires_grad=False)
+    elif requires_grad:
+        # wrap the tensor gradient, allocate if necessary
+        if t.grad is not None:
+            if return_ctype:
+                grad = t.grad
+                if t.strides != grad.strides:
+                    raise RuntimeError(
+                        f"Gradient strides must match array strides, expected {t.strides} but got {grad.strides}"
+                    )
+                grad_ptr = grad.data_ptr()
+            else:
+                grad = from_paddle(t.grad, dtype=dtype, requires_grad=False)
+        else:
+            # allocate a zero-filled gradient if it doesn't exist
+            # Note: we use Warp to allocate the shared gradient with compatible strides
+            grad = warp.zeros(dtype=dtype, shape=shape, strides=strides, device=device_from_paddle(t.place))
+            # use .grad_ for zero-copy
+            t.grad_ = to_paddle(grad, requires_grad=False)
+            grad_ptr = grad.ptr
+
+    if return_ctype:
+        ptr = t.data_ptr()
+
+        # create array descriptor
+        array_ctype = warp.types.array_t(ptr, grad_ptr, len(shape), shape, strides)
+
+        # keep data and gradient alive
+        array_ctype._ref = t
+        array_ctype._gradref = grad
+
+        return array_ctype
+
+    else:
+        a = warp.array(
+            ptr=t.data_ptr(),
+            dtype=dtype,
+            shape=shape,
+            strides=strides,
+            device=device_from_paddle(t.place),
+            copy=False,
+            grad=grad,
+            requires_grad=requires_grad,
+        )
+
+        # save a reference to the source tensor, otherwise it may get deallocated
+        a._tensor = t
+
+        return a
+
+
+def to_paddle(a: warp.array, requires_grad: bool = None) -> paddle.Tensor:
+    """
+    Convert a Warp array to a Paddle tensor without copying the data.
+
+    Args:
+        a (warp.array): The Warp array to convert.
+        requires_grad (bool, optional): Whether the resulting tensor should convert the array's gradient, if it exists, to a grad tensor. Defaults to the array's `requires_grad` value.
+
+    Returns:
+        paddle.Tensor: The converted tensor.
+    """
+    import paddle
+    import paddle.utils.dlpack
+
+    if requires_grad is None:
+        requires_grad = a.requires_grad
+
+    # Paddle does not support structured arrays
+    if isinstance(a.dtype, warp.codegen.Struct):
+        raise RuntimeError("Cannot convert structured Warp arrays to Paddle.")
+
+    if a.device.is_cpu:
+        # Paddle has an issue wrapping CPU objects
+        # that support the __array_interface__ protocol
+        # in this case we need to workaround by going
+        # to an ndarray first, see https://pearu.github.io/array_interface_pypaddle.html
+        t = paddle.to_tensor(numpy.asarray(a), place="cpu")
+        t.stop_gradient = not requires_grad
+        if requires_grad and a.requires_grad:
+            # use .grad_ for zero-copy
+            t.grad_ = paddle.to_tensor(numpy.asarray(a.grad), place="cpu")
+        return t
+
+    elif a.device.is_cuda:
+        # Paddle does support the __cuda_array_interface__
+        # correctly, but we must be sure to maintain a reference
+        # to the owning object to prevent memory allocs going out of scope
+        t = paddle.utils.dlpack.from_dlpack(warp.to_dlpack(a)).to(device=device_to_paddle(a.device))
+        t.stop_gradient = not requires_grad
+        if requires_grad and a.requires_grad:
+            # use .grad_ for zero-copy
+            t.grad_ = paddle.utils.dlpack.from_dlpack(warp.to_dlpack(a.grad)).to(device=device_to_paddle(a.device))
+        return t
+
+    else:
+        raise RuntimeError("Unsupported device")
+
+
+def stream_from_paddle(stream_or_device=None):
+    """Convert from a Paddle CUDA stream to a Warp CUDA stream."""
+    import paddle
+
+    if isinstance(stream_or_device, paddle.device.Stream):
+        stream = stream_or_device
+    else:
+        # assume arg is a paddle device
+        stream = paddle.device.current_stream(stream_or_device)
+
+    device = device_from_paddle(stream.device)
+
+    warp_stream = warp.Stream(device, cuda_stream=stream.stream_base.cuda_stream)
+
+    # save a reference to the source stream, otherwise it may be destroyed
+    warp_stream._paddle_stream = stream
+
+    return warp_stream