warp-lang 1.9.1__py3-none-manylinux_2_34_aarch64.whl → 1.10.0rc2__py3-none-manylinux_2_34_aarch64.whl

warp/native/warp.h

@@ -28,7 +28,7 @@ struct timing_result_t;
 // this is the core runtime API exposed on the DLL level
 extern "C"
 {
-    WP_API int wp_init();
+    WP_API int wp_init(const char* expected_version);
     //WP_API void wp_shutdown();
 
     // get error message from C++
@@ -75,23 +75,25 @@ extern "C"
     WP_API void wp_memtile_host(void* dest, const void* src, size_t srcsize, size_t n);
     WP_API void wp_memtile_device(void* context, void* dest, const void* src, size_t srcsize, size_t n);
 
-	WP_API uint64_t wp_bvh_create_host(wp::vec3* lowers, wp::vec3* uppers, int num_items, int constructor_type);
+	WP_API uint64_t wp_bvh_create_host(wp::vec3* lowers, wp::vec3* uppers, int num_items, int constructor_type, int leaf_size);
 	WP_API void wp_bvh_destroy_host(uint64_t id);
     WP_API void wp_bvh_refit_host(uint64_t id);
+    WP_API void wp_bvh_rebuild_host(uint64_t id, int constructor_type);
 
-	WP_API uint64_t wp_bvh_create_device(void* context, wp::vec3* lowers, wp::vec3* uppers, int num_items, int constructor_type);
+    WP_API uint64_t wp_bvh_create_device(void* context, wp::vec3* lowers, wp::vec3* uppers, int num_items, int constructor_type, int leaf_size);
 	WP_API void wp_bvh_destroy_device(uint64_t id);
     WP_API void wp_bvh_refit_device(uint64_t id);
+    WP_API void wp_bvh_rebuild_device(uint64_t id);
 
     // create a user-accessible copy of the mesh, it is the 
     // users responsibility to keep-alive the points/tris data for the duration of the mesh lifetime
 	WP_API uint64_t wp_mesh_create_host(wp::array_t<wp::vec3> points, wp::array_t<wp::vec3> velocities, wp::array_t<int> tris, 
-        int num_points, int num_tris, int support_winding_number, int constructor_type);
+        int num_points, int num_tris, int support_winding_number, int constructor_type, int bvh_leaf_size);
 	WP_API void wp_mesh_destroy_host(uint64_t id);
     WP_API void wp_mesh_refit_host(uint64_t id);
 
 	WP_API uint64_t wp_mesh_create_device(void* context, wp::array_t<wp::vec3> points, wp::array_t<wp::vec3> velocities, 
-        wp::array_t<int> tris, int num_points, int num_tris, int support_winding_number, int constructor_type);
+        wp::array_t<int> tris, int num_points, int num_tris, int support_winding_number, int constructor_type, int bvh_leaf_size);
 	WP_API void wp_mesh_destroy_device(uint64_t id);
     WP_API void wp_mesh_refit_device(uint64_t id);
 
@@ -232,6 +234,7 @@ extern "C"
 
     WP_API int wp_cuda_driver_version();   // CUDA driver version
     WP_API int wp_cuda_toolkit_version();  // CUDA Toolkit version used to build Warp
+    WP_API const char* wp_version();  // Warp native library version string
     WP_API bool wp_cuda_driver_is_initialized();
 
     WP_API int wp_nvrtc_supported_arch_count();
@@ -293,8 +296,8 @@ extern "C"
     WP_API void wp_cuda_stream_unregister(void* context, void* stream);
     WP_API void* wp_cuda_stream_get_current();
     WP_API void wp_cuda_stream_synchronize(void* stream);
-    WP_API void wp_cuda_stream_wait_event(void* stream, void* event);
-    WP_API void wp_cuda_stream_wait_stream(void* stream, void* other_stream, void* event);
+    WP_API void wp_cuda_stream_wait_event(void* stream, void* event, bool external=false);
+    WP_API void wp_cuda_stream_wait_stream(void* stream, void* other_stream, void* event, bool external=false);
     WP_API int wp_cuda_stream_is_capturing(void* stream);
     WP_API uint64_t wp_cuda_stream_get_capture_id(void* stream);
     WP_API int wp_cuda_stream_get_priority(void* stream);
@@ -302,7 +305,7 @@ extern "C"
     WP_API void* wp_cuda_event_create(void* context, unsigned flags);
     WP_API void wp_cuda_event_destroy(void* event);
     WP_API int wp_cuda_event_query(void* event);
-    WP_API void wp_cuda_event_record(void* event, void* stream, bool timing=false);
+    WP_API void wp_cuda_event_record(void* event, void* stream, bool external=false);
     WP_API void wp_cuda_event_synchronize(void* event);
     WP_API float wp_cuda_event_elapsed_time(void* start_event, void* end_event);
 

warp/optim/__init__.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,5 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .adam import Adam
-from .sgd import SGD
+# isort: skip_file
+
+from warp._src.optim.adam import Adam as Adam
+
+from warp._src.optim.sgd import SGD as SGD

warp/optim/adam.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,151 +13,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import warp as wp
+# TODO: Remove after cleaning up the public API.
 
+from warp._src.optim import adam as _adam
 
-@wp.kernel
-def adam_step_kernel_vec3(
-    g: wp.array(dtype=wp.vec3),
-    m: wp.array(dtype=wp.vec3),
-    v: wp.array(dtype=wp.vec3),
-    lr: float,
-    beta1: float,
-    beta2: float,
-    t: float,
-    eps: float,
-    params: wp.array(dtype=wp.vec3),
-):
-    i = wp.tid()
-    m[i] = beta1 * m[i] + (1.0 - beta1) * g[i]
-    v[i] = beta2 * v[i] + (1.0 - beta2) * wp.cw_mul(g[i], g[i])
-    mhat = m[i] / (1.0 - wp.pow(beta1, (t + 1.0)))
-    vhat = v[i] / (1.0 - wp.pow(beta2, (t + 1.0)))
-    sqrt_vhat = wp.vec3(wp.sqrt(vhat[0]), wp.sqrt(vhat[1]), wp.sqrt(vhat[2]))
-    eps_vec3 = wp.vec3(eps, eps, eps)
-    params[i] = params[i] - lr * wp.cw_div(mhat, (sqrt_vhat + eps_vec3))
 
+def __getattr__(name):
+    from warp._src.utils import get_deprecated_api
 
-@wp.kernel
-def adam_step_kernel_float(
-    g: wp.array(dtype=float),
-    m: wp.array(dtype=float),
-    v: wp.array(dtype=float),
-    lr: float,
-    beta1: float,
-    beta2: float,
-    t: float,
-    eps: float,
-    params: wp.array(dtype=float),
-):
-    i = wp.tid()
-    m[i] = beta1 * m[i] + (1.0 - beta1) * g[i]
-    v[i] = beta2 * v[i] + (1.0 - beta2) * g[i] * g[i]
-    mhat = m[i] / (1.0 - wp.pow(beta1, (t + 1.0)))
-    vhat = v[i] / (1.0 - wp.pow(beta2, (t + 1.0)))
-    params[i] = params[i] - lr * mhat / (wp.sqrt(vhat) + eps)
-
-
-@wp.kernel
-def adam_step_kernel_half(
-    g: wp.array(dtype=wp.float16),
-    m: wp.array(dtype=float),
-    v: wp.array(dtype=float),
-    lr: float,
-    beta1: float,
-    beta2: float,
-    t: float,
-    eps: float,
-    params: wp.array(dtype=wp.float16),
-):
-    i = wp.tid()
-    m[i] = beta1 * m[i] + (1.0 - beta1) * float(g[i])
-    v[i] = beta2 * v[i] + (1.0 - beta2) * float(g[i]) * float(g[i])
-    mhat = m[i] / (1.0 - wp.pow(beta1, (t + 1.0)))
-    vhat = v[i] / (1.0 - wp.pow(beta2, (t + 1.0)))
-    params[i] = params[i] - wp.float16(lr * mhat / (wp.sqrt(vhat) + eps))
-
-
-class Adam:
-    """An implementation of the Adam Optimizer
-    It is designed to mimic Pytorch's version.
-    https://pytorch.org/docs/stable/generated/torch.optim.Adam.html#torch.optim.Adam
-    """
-
-    def __init__(self, params=None, lr=0.001, betas=(0.9, 0.999), eps=1e-08):
-        self.m = []  # first moment
-        self.v = []  # second moment
-        self.set_params(params)
-        self.lr = lr
-        self.beta1 = betas[0]
-        self.beta2 = betas[1]
-        self.eps = eps
-        self.t = 0
-
-    def set_params(self, params):
-        self.params = params
-        if params is not None and isinstance(params, list) and len(params) > 0:
-            if len(self.m) != len(params):
-                self.m = [None] * len(params)  # reset first moment
-            if len(self.v) != len(params):
-                self.v = [None] * len(params)  # reset second moment
-            for i in range(len(params)):
-                param = params[i]
-
-                if param.dtype == wp.vec3:
-                    dtype = wp.vec3
-                elif param.dtype == wp.float32:
-                    dtype = wp.float32
-                elif param.dtype == wp.float16:
-                    dtype = wp.float32  # we always use fp32 for moments, even if params are fp16
-                else:
-                    raise RuntimeError(f"Unsupported dtype for Warp Adam optimizer: {param.dtype}")
-
-                if self.m[i] is None or self.m[i].shape != param.shape or self.m[i].dtype != param.dtype:
-                    self.m[i] = wp.zeros(shape=param.shape, dtype=dtype, device=param.device)
-                if self.v[i] is None or self.v[i].shape != param.shape or self.v[i].dtype != param.dtype:
-                    self.v[i] = wp.zeros(shape=param.shape, dtype=dtype, device=param.device)
-
-    def reset_internal_state(self):
-        for m_i in self.m:
-            m_i.zero_()
-        for v_i in self.v:
-            v_i.zero_()
-        self.t = 0
-
-    def step(self, grad):
-        assert self.params is not None
-        for i in range(len(self.params)):
-            Adam.step_detail(
-                grad[i], self.m[i], self.v[i], self.lr, self.beta1, self.beta2, self.t, self.eps, self.params[i]
-            )
-        self.t = self.t + 1
-
-    @staticmethod
-    def step_detail(g, m, v, lr, beta1, beta2, t, eps, params):
-        assert params.dtype == g.dtype
-        assert params.shape == g.shape
-        kernel_inputs = [g, m, v, lr, beta1, beta2, t, eps, params]
-        if params.dtype == wp.types.float32:
-            wp.launch(
-                kernel=adam_step_kernel_float,
-                dim=len(params),
-                inputs=kernel_inputs,
-                device=params.device,
-            )
-        elif params.dtype == wp.types.float16:
-            wp.launch(
-                kernel=adam_step_kernel_half,
-                dim=len(params),
-                inputs=kernel_inputs,
-                device=params.device,
-            )
-        elif params.dtype == wp.types.vec3:
-            wp.launch(
-                kernel=adam_step_kernel_vec3,
-                dim=len(params),
-                inputs=kernel_inputs,
-                device=params.device,
-            )
-        else:
-            raise RuntimeError("Params data type not supported in Adam step kernels.")
+    return get_deprecated_api(_adam, "wp.optim", name)