warp-lang 1.8.1__py3-none-macosx_10_13_universal2.whl → 1.9.0__py3-none-macosx_10_13_universal2.whl

warp/native/array.h

@@ -252,6 +252,89 @@ struct array_t
 };
 
 
+// Required when compiling adjoints.
+template <typename T>
+inline CUDA_CALLABLE array_t<T> add(
+    const array_t<T>& a, const array_t<T>& b
+)
+{
+    return array_t<T>();
+}
+
+
+// Stack‑allocated counterpart to `array_t<T>`.
+// Useful for small buffers that have their shape known at compile-time,
+// and that gain from having array semantics instead of vectors.
+template <int Size, typename T>
+struct fixedarray_t : array_t<T>
+{
+    using Base = array_t<T>;
+
+    static_assert(Size > 0, "Expected Size > 0");
+
+    CUDA_CALLABLE inline fixedarray_t()
+        : Base(storage, Size), storage()
+    {}
+
+    CUDA_CALLABLE fixedarray_t(int dim0, T* grad=nullptr)
+        : Base(storage, dim0, grad), storage()
+    {
+        assert(Size == dim0);
+    }
+
+    CUDA_CALLABLE fixedarray_t(int dim0, int dim1, T* grad=nullptr)
+        : Base(storage, dim0, dim1, grad), storage()
+    {
+        assert(Size == dim0 * dim1);
+    }
+
+    CUDA_CALLABLE fixedarray_t(int dim0, int dim1, int dim2, T* grad=nullptr)
+        : Base(storage, dim0, dim1, dim2, grad), storage()
+    {
+        assert(Size == dim0 * dim1 * dim2);
+    }
+
+    CUDA_CALLABLE fixedarray_t(int dim0, int dim1, int dim2, int dim3, T* grad=nullptr)
+        : Base(storage, dim0, dim1, dim2, dim3, grad), storage()
+    {
+        assert(Size == dim0 * dim1 * dim2 * dim3);
+    }
+
+    CUDA_CALLABLE fixedarray_t<Size, T>& operator=(const fixedarray_t<Size, T>& other)
+    {
+        for (unsigned int i = 0; i < Size; ++i)
+        {
+            this->storage[i] = other.storage[i];
+        }
+
+        this->data = this->storage;
+        this->grad = nullptr;
+        this->shape = other.shape;
+
+        for (unsigned int i = 0; i < ARRAY_MAX_DIMS; ++i)
+        {
+            this->strides[i] = other.strides[i];
+        }
+
+        this->ndim = other.ndim;
+
+        return *this;
+    }
+
+    T storage[Size];
+};
+
+
+// Required when compiling adjoints.
+template <int Size, typename T>
+inline CUDA_CALLABLE fixedarray_t<Size, T> add(
+    const fixedarray_t<Size, T>& a, const fixedarray_t<Size, T>& b
+)
+{
+    return fixedarray_t<Size, T>();
+}
+
+
 // TODO:
 // - templated index type?
 // - templated dimensionality? (also for array_t to save space when passing arrays to kernels)
@@ -762,13 +845,25 @@ template<template<typename> class A, typename T>
 inline CUDA_CALLABLE T atomic_exch(const A<T>& buf, int i, int j, int k, int l, T value) { return atomic_exch(&index(buf, i, j, k, l), value); }
 
 template<template<typename> class A, typename T>
-inline CUDA_CALLABLE T* address(const A<T>& buf, int i) { return &index(buf, i); }
+inline CUDA_CALLABLE T* address(const A<T>& buf, int i)
+{
+    return &index(buf, i); // cppcheck-suppress returnDanglingLifetime
+}
 template<template<typename> class A, typename T>
-inline CUDA_CALLABLE T* address(const A<T>& buf, int i, int j) { return &index(buf, i, j); }
+inline CUDA_CALLABLE T* address(const A<T>& buf, int i, int j)
+{
+    return &index(buf, i, j); // cppcheck-suppress returnDanglingLifetime
+}
 template<template<typename> class A, typename T>
-inline CUDA_CALLABLE T* address(const A<T>& buf, int i, int j, int k) { return &index(buf, i, j, k); }
+inline CUDA_CALLABLE T* address(const A<T>& buf, int i, int j, int k)
+{
+    return &index(buf, i, j, k); // cppcheck-suppress returnDanglingLifetime
+}
 template<template<typename> class A, typename T>
-inline CUDA_CALLABLE T* address(const A<T>& buf, int i, int j, int k, int l) { return &index(buf, i, j, k, l); }
+inline CUDA_CALLABLE T* address(const A<T>& buf, int i, int j, int k, int l)
+{
+    return &index(buf, i, j, k, l); // cppcheck-suppress returnDanglingLifetime
+}
 
 template<template<typename> class A, typename T>
 inline CUDA_CALLABLE void array_store(const A<T>& buf, int i, T value)

warp/native/builtin.h

@@ -49,7 +49,7 @@
 #define DEG_TO_RAD  0.01745329251994329577
 
 #if defined(__CUDACC__) && !defined(_MSC_VER)
-__device__ void __debugbreak() {}
+__device__ void __debugbreak() { __brkpt(); }
 #endif
 
 #if defined(__clang__) && defined(__CUDA__) && defined(__CUDA_ARCH__)
@@ -197,19 +197,19 @@ CUDA_CALLABLE inline float half_to_float(half h)
 
 #else  // Native C++ for Warp builtins outside of kernels
 
-extern "C" WP_API uint16_t float_to_half_bits(float x);
-extern "C" WP_API float half_bits_to_float(uint16_t u);
+extern "C" WP_API uint16_t wp_float_to_half_bits(float x);
+extern "C" WP_API float wp_half_bits_to_float(uint16_t u);
 
 inline half float_to_half(float x)
 {
     half h;
-    h.u = float_to_half_bits(x);
+    h.u = wp_float_to_half_bits(x);
     return h;
 }
 
 inline float half_to_float(half h)
 {
-   return half_bits_to_float(h.u);
+   return wp_half_bits_to_float(h.u);
 }
 
 #endif
@@ -1277,6 +1277,83 @@ inline CUDA_CALLABLE_DEVICE void tid(int& i, int& j, int& k, int& l, size_t inde
     l = c.l;
 }
 
+// should match types.py
+constexpr int SLICE_BEGIN = (1U << (sizeof(int) - 1)) - 1; // std::numeric_limits<int>::max()
+constexpr int SLICE_END = -(1U << (sizeof(int) - 1)); // std::numeric_limits<int>::min()
+
+struct slice_t
+{
+    int start;
+    int stop;
+    int step;
+
+    CUDA_CALLABLE inline slice_t()
+        : start(SLICE_BEGIN), stop(SLICE_END), step(1)
+    {}
+
+    CUDA_CALLABLE inline slice_t(int start, int stop, int step)
+        : start(start), stop(stop), step(step)
+    {}
+};
+
+CUDA_CALLABLE inline slice_t slice_adjust_indices(const slice_t& slice, int length)
+{
+#ifndef NDEBUG
+    if (slice.step == 0)
+    {
+        printf("%s:%d slice step cannot be 0\n", __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    int start, stop;
+
+    if (slice.start == SLICE_BEGIN)
+    {
+        start = slice.step < 0 ? length - 1 : 0;
+    }
+    else
+    {
+        start = min(max(slice.start, -length), length);
+        start = start < 0 ? start + length : start;
+    }
+
+    if (slice.stop == SLICE_END)
+    {
+        stop = slice.step < 0 ? -1 : length;
+    }
+    else
+    {
+        stop = min(max(slice.stop, -length), length);
+        stop = stop < 0 ? stop + length : stop;
+    }
+
+    return {start, stop, slice.step};
+}
+
+CUDA_CALLABLE inline int slice_get_length(const slice_t& slice)
+{
+#ifndef NDEBUG
+    if (slice.step == 0)
+    {
+        printf("%s:%d slice step cannot be 0\n", __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (slice.step > 0 && slice.start < slice.stop)
+    {
+        return 1 + (slice.stop - slice.start - 1) / slice.step;
+    }
+
+    if (slice.step < 0 && slice.start > slice.stop)
+    {
+        return 1 + (slice.start - slice.stop - 1) / (-slice.step);
+    }
+
+    return 0;
+}
+
 template<typename T>
 inline CUDA_CALLABLE T atomic_add(T* buf, T value)
 {

warp/native/bvh.cpp

@@ -22,7 +22,9 @@
 #include "warp.h"
 #include "cuda_util.h"
 
+#include <cassert>
 #include <map>
+#include <climits>
 
 using namespace wp;
 
@@ -40,6 +42,8 @@ public:
 
 private:
 
+    void initialize_empty(BVH& bvh);
+
     bounds3 calc_bounds(const vec3* lowers, const vec3* uppers, const int* indices, int start, int end);
 
     int partition_median(const vec3* lowers, const vec3* uppers, int* indices, int start, int end, bounds3 range_bounds);
@@ -54,30 +58,64 @@ private:
 
 //////////////////////////////////////////////////////////////////////
 
+void TopDownBVHBuilder::initialize_empty(BVH& bvh)
+{
+    bvh.max_depth = 0;
+    bvh.max_nodes = 0;
+    bvh.node_lowers = nullptr;
+    bvh.node_uppers = nullptr;
+    bvh.node_parents = nullptr;
+    bvh.node_counts = nullptr;
+    bvh.root = nullptr;
+    bvh.primitive_indices = nullptr;
+    bvh.num_leaf_nodes = 0;
+}
+
 void TopDownBVHBuilder::build(BVH& bvh, const vec3* lowers, const vec3* uppers, int n, int in_constructor_type)
 {
+    assert(n >= 0);
+    if (n > 0)
+    {
+        assert(lowers != nullptr && uppers != nullptr && "Pointers must be valid for n > 0");
+    }
+
     constructor_type = in_constructor_type;
     if (constructor_type != BVH_CONSTRUCTOR_SAH && constructor_type != BVH_CONSTRUCTOR_MEDIAN)
     {
-        printf("Unrecognized Constructor type: %d! For CPU constructor it should be either SAH (%d) or Median (%d)!\n",
+        fprintf(stderr, "Unrecognized Constructor type: %d! For CPU constructor it should be either SAH (%d) or Median (%d)!\n",
             constructor_type, BVH_CONSTRUCTOR_SAH, BVH_CONSTRUCTOR_MEDIAN);
         return;
     }
 
+    if (n < 0)
+    {
+        fprintf(stderr, "Error: Cannot build BVH with a negative primitive count: %d\n", n);
+        initialize_empty(bvh);
+        return;
+    }
+    else if (n == 0)
+    {
+        initialize_empty(bvh);
+        return;
+    }
+    else if (n > INT_MAX / 2)
+    {
+        fprintf(stderr, "Error: Primitive count %d is too large and would cause an integer overflow.\n", n);
+        initialize_empty(bvh);
+        return;
+    }
+
     bvh.max_depth = 0;
     bvh.max_nodes = 2*n-1;
 
     bvh.node_lowers = new BVHPackedNodeHalf[bvh.max_nodes];
     bvh.node_uppers = new BVHPackedNodeHalf[bvh.max_nodes];
     bvh.node_parents = new int[bvh.max_nodes];
-    bvh.node_counts = NULL;
+    bvh.node_counts = nullptr;
 
     // root is always in first slot for top down builders
     bvh.root = new int[1];
     bvh.root[0] = 0;
-
-    if (n == 0)
-        return;
     
     bvh.primitive_indices = new int[n];
     for (int i = 0; i < n; ++i)
@@ -273,8 +311,6 @@ int TopDownBVHBuilder::build_recursive(BVH& bvh, const vec3* lowers, const vec3*
 {
     assert(start < end);
 
-    // printf("start %d end %d\n", start, end);
-
     const int n = end - start;
     const int node_index = bvh.num_nodes++;
 
@@ -353,8 +389,8 @@ void bvh_refit_recursive(BVH& bvh, int index)
             bound.add_bounds(bvh.item_lowers[item], bvh.item_uppers[item]);
         }
 
-        (vec3&)lower = bound.lower;
-        (vec3&)upper = bound.upper;
+        reinterpret_cast<vec3&>(lower) = bound.lower;
+        reinterpret_cast<vec3&>(upper) = bound.upper;
     }
     else
     {
@@ -365,19 +401,19 @@ void bvh_refit_recursive(BVH& bvh, int index)
         bvh_refit_recursive(bvh, right_index);
 
         // compute union of children
-        const vec3& left_lower = (vec3&)bvh.node_lowers[left_index];
-        const vec3& left_upper = (vec3&)bvh.node_uppers[left_index];
+        const vec3& left_lower = reinterpret_cast<const vec3&>(bvh.node_lowers[left_index]);
+        const vec3& left_upper = reinterpret_cast<const vec3&>(bvh.node_uppers[left_index]);
 
-        const vec3& right_lower = (vec3&)bvh.node_lowers[right_index];
-        const vec3& right_upper = (vec3&)bvh.node_uppers[right_index];
+        const vec3& right_lower = reinterpret_cast<const vec3&>(bvh.node_lowers[right_index]);
+        const vec3& right_upper = reinterpret_cast<const vec3&>(bvh.node_uppers[right_index]);
 
         // union of child bounds
         vec3 new_lower = min(left_lower, right_lower);
         vec3 new_upper = max(left_upper, right_upper);
         
         // write new BVH nodes
-        (vec3&)lower = new_lower;
-        (vec3&)upper = new_upper;
+        reinterpret_cast<vec3&>(lower) = new_lower;
+        reinterpret_cast<vec3&>(upper) = new_upper;
     }
 }
 
@@ -448,11 +484,11 @@ void bvh_destroy_host(BVH& bvh)
     delete[] bvh.primitive_indices;
     delete[] bvh.root;
 
-    bvh.node_lowers = NULL;
-    bvh.node_uppers = NULL;
-    bvh.node_parents = NULL;
-    bvh.primitive_indices = NULL;
-    bvh.root = NULL;
+    bvh.node_lowers = nullptr;
+    bvh.node_uppers = nullptr;
+    bvh.node_parents = nullptr;
+    bvh.primitive_indices = nullptr;
+    bvh.root = nullptr;
 
     bvh.max_nodes = 0;
     bvh.num_items = 0;
@@ -460,7 +496,7 @@ void bvh_destroy_host(BVH& bvh)
 
 } // namespace wp
 
-uint64_t bvh_create_host(vec3* lowers, vec3* uppers, int num_items, int constructor_type)
+uint64_t wp_bvh_create_host(vec3* lowers, vec3* uppers, int num_items, int constructor_type)
 {
     BVH* bvh = new BVH();
     wp::bvh_create_host(lowers, uppers, num_items, constructor_type, *bvh);
@@ -468,16 +504,16 @@ uint64_t bvh_create_host(vec3* lowers, vec3* uppers, int num_items, int construc
     return (uint64_t)bvh;
 }
 
-void bvh_refit_host(uint64_t id)
+void wp_bvh_refit_host(uint64_t id)
 {
     BVH* bvh = (BVH*)(id);
-    bvh_refit_host(*bvh);
+    wp::bvh_refit_host(*bvh);
 }
 
-void bvh_destroy_host(uint64_t id)
+void wp_bvh_destroy_host(uint64_t id)
 {
     BVH* bvh = (BVH*)(id);
-    bvh_destroy_host(*bvh);
+    wp::bvh_destroy_host(*bvh);
     delete bvh;
 }
 
@@ -485,8 +521,8 @@ void bvh_destroy_host(uint64_t id)
 // stubs for non-CUDA platforms
 #if !WP_ENABLE_CUDA
 
-uint64_t bvh_create_device(void* context, wp::vec3* lowers, wp::vec3* uppers, int num_items, int constructor_type) { return 0; }
-void bvh_refit_device(uint64_t id) {}
-void bvh_destroy_device(uint64_t id) {}
+uint64_t wp_bvh_create_device(void* context, wp::vec3* lowers, wp::vec3* uppers, int num_items, int constructor_type) { return 0; }
+void wp_bvh_refit_device(uint64_t id) {}
+void wp_bvh_destroy_device(uint64_t id) {}
 
 #endif // !WP_ENABLE_CUDA