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

warp/native/mathdx.cpp

@@ -24,48 +24,24 @@ extern "C"
 {
 
 WP_API
-bool cuda_compile_fft(
-                      const char* ltoir_output_path,
-                      const char* symbol_name,
-                      int num_include_dirs,
-                      const char** include_dirs,
-                      const char* mathdx_include_dir,
-                      int arch,
-                      int size,
-                      int elements_per_thread,
-                      int direction,
-                      int precision,
-                      int* shared_memory_size)
+bool wp_cuda_compile_fft(
+                         const char* ltoir_output_path,
+                         const char* symbol_name,
+                         int num_include_dirs,
+                         const char** include_dirs,
+                         const char* mathdx_include_dir,
+                         int arch,
+                         int size,
+                         int elements_per_thread,
+                         int direction,
+                         int precision,
+                         int* shared_memory_size)
 {
     printf("CUDA is disabled and/or Warp was not compiled with MathDx support.\n");
     return false;
 }
 
-WP_API bool cuda_compile_dot(
-                             const char* ltoir_output_path,
-                             const char* symbol_name,
-                             int num_include_dirs,
-                             const char** include_dirs,
-                             const char* mathdx_include_dir,
-                             int arch,
-                             int M,
-                             int N,
-                             int K,
-                             int precision_A,
-                             int precision_B,
-                             int precision_C,
-                             int type,
-                             int arrangement_A,
-                             int arrangement_B,
-                             int arrangement_C,
-                             int num_threads)
-{
-    printf("CUDA is disabled and/or Warp was not compiled with MathDx support.\n");
-    return false;
-}
-
-WP_API bool cuda_compile_solver(
-                                const char* fatbin_output_path,
+WP_API bool wp_cuda_compile_dot(
                                 const char* ltoir_output_path,
                                 const char* symbol_name,
                                 int num_include_dirs,
@@ -74,20 +50,44 @@ WP_API bool cuda_compile_solver(
                                 int arch,
                                 int M,
                                 int N,
-                                int NRHS,
-                                int function,
-                                int side,
-                                int diag,
-                                int precision,
+                                int K,
+                                int precision_A,
+                                int precision_B,
+                                int precision_C,
+                                int type,
                                 int arrangement_A,
                                 int arrangement_B,
-                                int fill_mode,
+                                int arrangement_C,
                                 int num_threads)
 {
     printf("CUDA is disabled and/or Warp was not compiled with MathDx support.\n");
     return false;
 }
 
+WP_API bool wp_cuda_compile_solver(
+                                   const char* fatbin_output_path,
+                                   const char* ltoir_output_path,
+                                   const char* symbol_name,
+                                   int num_include_dirs,
+                                   const char** include_dirs,
+                                   const char* mathdx_include_dir,
+                                   int arch,
+                                   int M,
+                                   int N,
+                                   int NRHS,
+                                   int function,
+                                   int side,
+                                   int diag,
+                                   int precision,
+                                   int arrangement_A,
+                                   int arrangement_B,
+                                   int fill_mode,
+                                   int num_threads)
+{
+    printf("CUDA is disabled and/or Warp was not compiled with MathDx support.\n");
+    return false;
+}
+
 } // extern "C"
 
 #endif // !WP_ENABLE_CUDA || !WP_ENABLE_MATHDX

warp/native/mesh.cpp

@@ -96,8 +96,8 @@ void bvh_refit_with_solid_angle_recursive_host(BVH& bvh, int index, Mesh& mesh)
              }
          }
 
-         (vec3&)lower = mesh.solid_angle_props[index].box.lower;
-         (vec3&)upper = mesh.solid_angle_props[index].box.upper;
+         reinterpret_cast<vec3&>(lower) = mesh.solid_angle_props[index].box.lower;
+         reinterpret_cast<vec3&>(upper) = mesh.solid_angle_props[index].box.upper;
     }
     else
     {
@@ -114,19 +114,19 @@ void bvh_refit_with_solid_angle_recursive_host(BVH& bvh, int index, Mesh& mesh)
         combine_precomputed_solid_angle_props(mesh.solid_angle_props[index], left_child_data, right_child_data);
 
         // 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; 
     }
 }
 
@@ -135,7 +135,7 @@ void bvh_refit_with_solid_angle_host(BVH& bvh, Mesh& mesh)
     bvh_refit_with_solid_angle_recursive_host(bvh, 0, mesh);
 }
 
-uint64_t mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities, array_t<int> indices, int num_points, int num_tris, int support_winding_number, int constructor_type)
+uint64_t wp_mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities, array_t<int> indices, int num_points, int num_tris, int support_winding_number, int constructor_type)
 {
     Mesh* m = new Mesh(points, velocities, indices, num_points, num_tris);
 
@@ -177,7 +177,7 @@ uint64_t mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities
 }
 
 
-void mesh_destroy_host(uint64_t id)
+void wp_mesh_destroy_host(uint64_t id)
 {
     Mesh* m = (Mesh*)(id);
 
@@ -187,12 +187,12 @@ void mesh_destroy_host(uint64_t id)
     if (m->solid_angle_props) {
         delete [] m->solid_angle_props;
     }
-    bvh_destroy_host(m->bvh);
+    wp::bvh_destroy_host(m->bvh);
 
     delete m;
 }
 
-void mesh_refit_host(uint64_t id)
+void wp_mesh_refit_host(uint64_t id)
 {
     Mesh* m = (Mesh*)(id);
 
@@ -223,30 +223,30 @@ void mesh_refit_host(uint64_t id)
     }
     else
     {
-        bvh_refit_host(m->bvh);
+        wp::bvh_refit_host(m->bvh);
     }
 }
 
-void mesh_set_points_host(uint64_t id, wp::array_t<wp::vec3> points)
+void wp_mesh_set_points_host(uint64_t id, wp::array_t<wp::vec3> points)
 {
     Mesh* m = (Mesh*)(id);
     if (points.ndim != 1 || points.shape[0] != m->points.shape[0])
     {
-        fprintf(stderr, "The new points input for mesh_set_points_host does not match the shape of the original points!\n");
+        fprintf(stderr, "The new points input for wp_mesh_set_points_host does not match the shape of the original points!\n");
         return;
     }
 
     m->points = points;
 
-    mesh_refit_host(id);
+    wp_mesh_refit_host(id);
 }
 
-void mesh_set_velocities_host(uint64_t id, wp::array_t<wp::vec3> velocities)
+void wp_mesh_set_velocities_host(uint64_t id, wp::array_t<wp::vec3> velocities)
 {
     Mesh* m = (Mesh*)(id);
     if (velocities.ndim != 1 || velocities.shape[0] != m->velocities.shape[0])
     {
-        fprintf(stderr, "The new velocities input for mesh_set_velocities_host does not match the shape of the original velocities!\n");
+        fprintf(stderr, "The new velocities input for wp_mesh_set_velocities_host does not match the shape of the original velocities!\n");
         return;
     }
     m->velocities = velocities;
@@ -256,11 +256,11 @@ void mesh_set_velocities_host(uint64_t id, wp::array_t<wp::vec3> velocities)
 #if !WP_ENABLE_CUDA
 
 
-WP_API uint64_t 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) { return 0; }
-WP_API void mesh_destroy_device(uint64_t id) {}
-WP_API void mesh_refit_device(uint64_t id) {}
-WP_API void mesh_set_points_device(uint64_t id, wp::array_t<wp::vec3> points) {};
-WP_API void mesh_set_velocities_device(uint64_t id, wp::array_t<wp::vec3> points) {};
+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) { return 0; }
+WP_API void wp_mesh_destroy_device(uint64_t id) {}
+WP_API void wp_mesh_refit_device(uint64_t id) {}
+WP_API void wp_mesh_set_points_device(uint64_t id, wp::array_t<wp::vec3> points) {};
+WP_API void wp_mesh_set_velocities_device(uint64_t id, wp::array_t<wp::vec3> points) {};
 
 
-#endif // !WP_ENABLE_CUDA
+#endif // !WP_ENABLE_CUDA

warp/native/mesh.cu

@@ -237,7 +237,7 @@ void bvh_refit_with_solid_angle_device(BVH& bvh, Mesh& mesh)
     ContextGuard guard(bvh.context);
 
     // clear child counters
-    memset_device(WP_CURRENT_CONTEXT, bvh.node_counts, 0, sizeof(int) * bvh.max_nodes);
+    wp_memset_device(WP_CURRENT_CONTEXT, bvh.node_counts, 0, sizeof(int) * bvh.max_nodes);
     wp_launch_device(WP_CURRENT_CONTEXT, bvh_refit_with_solid_angle_kernel, bvh.num_leaf_nodes, 
         (bvh.num_leaf_nodes, bvh.node_parents, bvh.node_counts, bvh.node_lowers, bvh.node_uppers, mesh.points, mesh.indices, bvh.primitive_indices, mesh.solid_angle_props));
 }
@@ -245,26 +245,26 @@ void bvh_refit_with_solid_angle_device(BVH& bvh, Mesh& mesh)
 } // namespace wp
 
 
-uint64_t mesh_create_device(void* context, wp::array_t<wp::vec3> points, wp::array_t<wp::vec3> velocities, wp::array_t<int> indices, int num_points, int num_tris, int support_winding_number, int constructor_type)
+uint64_t wp_mesh_create_device(void* context, wp::array_t<wp::vec3> points, wp::array_t<wp::vec3> velocities, wp::array_t<int> indices, int num_points, int num_tris, int support_winding_number, int constructor_type)
 {
     ContextGuard guard(context);
 
     wp::Mesh mesh(points, velocities, indices, num_points, num_tris);
 
-    mesh.context = context ? context : cuda_context_get_current();
+    mesh.context = context ? context : wp_cuda_context_get_current();
 
     // create lower upper arrays expected by GPU BVH builder
-    mesh.lowers = (wp::vec3*)alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::vec3)*num_tris);
-    mesh.uppers = (wp::vec3*)alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::vec3)*num_tris);
+    mesh.lowers = (wp::vec3*)wp_alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::vec3)*num_tris);
+    mesh.uppers = (wp::vec3*)wp_alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::vec3)*num_tris);
 
     if (support_winding_number)
     {
         int num_bvh_nodes = 2 * num_tris;
-        mesh.solid_angle_props = (wp::SolidAngleProps*)alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::SolidAngleProps) * num_bvh_nodes);
+        mesh.solid_angle_props = (wp::SolidAngleProps*)wp_alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::SolidAngleProps) * num_bvh_nodes);
     }
 
-    wp::Mesh* mesh_device = (wp::Mesh*)alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::Mesh));
-    memcpy_h2d(WP_CURRENT_CONTEXT, mesh_device, &mesh, sizeof(wp::Mesh));
+    wp::Mesh* mesh_device = (wp::Mesh*)wp_alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::Mesh));
+    wp_memcpy_h2d(WP_CURRENT_CONTEXT, mesh_device, &mesh, sizeof(wp::Mesh));
 
     // save descriptor
     uint64_t mesh_id = (uint64_t)mesh_device;
@@ -283,17 +283,17 @@ uint64_t mesh_create_device(void* context, wp::array_t<wp::vec3> points, wp::arr
     wp::bvh_create_device(mesh.context, mesh.lowers, mesh.uppers, num_tris, constructor_type, mesh.bvh);
 
     // we need to overwrite mesh.bvh because it is not initialized when we construct it on device
-    memcpy_h2d(WP_CURRENT_CONTEXT, &(mesh_device->bvh), &mesh.bvh, sizeof(wp::BVH));
+    wp_memcpy_h2d(WP_CURRENT_CONTEXT, &(mesh_device->bvh), &mesh.bvh, sizeof(wp::BVH));
 
     mesh_add_descriptor(mesh_id, mesh);
 
     if (support_winding_number) 
-        mesh_refit_device(mesh_id);
+        wp_mesh_refit_device(mesh_id);
 
     return mesh_id;
 }
 
-void mesh_destroy_device(uint64_t id)
+void wp_mesh_destroy_device(uint64_t id)
 {
     wp::Mesh mesh;
     if (wp::mesh_get_descriptor(id, mesh))
@@ -302,12 +302,12 @@ void mesh_destroy_device(uint64_t id)
 
         wp::bvh_destroy_device(mesh.bvh);
 
-        free_device(WP_CURRENT_CONTEXT, mesh.lowers);
-        free_device(WP_CURRENT_CONTEXT, mesh.uppers);
-        free_device(WP_CURRENT_CONTEXT, (wp::Mesh*)id);
+        wp_free_device(WP_CURRENT_CONTEXT, mesh.lowers);
+        wp_free_device(WP_CURRENT_CONTEXT, mesh.uppers);
+        wp_free_device(WP_CURRENT_CONTEXT, (wp::Mesh*)id);
 
         if (mesh.solid_angle_props) {
-            free_device(WP_CURRENT_CONTEXT, mesh.solid_angle_props);
+            wp_free_device(WP_CURRENT_CONTEXT, mesh.solid_angle_props);
         }
         wp::mesh_rem_descriptor(id);
     }
@@ -318,7 +318,7 @@ void mesh_update_stats(uint64_t id)
     
 }
 
-void mesh_refit_device(uint64_t id)
+void wp_mesh_refit_device(uint64_t id)
 {
     // recompute triangle bounds
     wp::Mesh m;
@@ -346,59 +346,59 @@ void mesh_refit_device(uint64_t id)
         }
         else 
         {
-            bvh_refit_device(m.bvh);
+            wp::bvh_refit_device(m.bvh);
         }
     }
 }
 
-void mesh_set_points_device(uint64_t id, wp::array_t<wp::vec3> points)
+void wp_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");
+            fprintf(stderr, "The new points input for wp_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));
+        wp_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);
+        wp_mesh_refit_device(id);
     }
     else 
     {
-        fprintf(stderr, "The mesh id provided to mesh_set_points_device is not valid!\n");
+        fprintf(stderr, "The mesh id provided to wp_mesh_set_points_device is not valid!\n");
         return;
     }
 }
 
-void mesh_set_velocities_device(uint64_t id, wp::array_t<wp::vec3> velocities)
+void wp_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");
+            fprintf(stderr, "The new velocities input for wp_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));
+        wp_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");
+        fprintf(stderr, "The mesh id provided to wp_mesh_set_velocities_device is not valid!\n");
         return;
     }
 }

warp/native/mesh.h

@@ -58,6 +58,7 @@ struct Mesh
         context = nullptr;
         solid_angle_props = nullptr;	
         average_edge_length = 0.0f;
+        bvh = BVH{};
     }
 
     inline CUDA_CALLABLE Mesh(
@@ -73,6 +74,7 @@ struct Mesh
         uppers = nullptr;
         solid_angle_props = nullptr;
         average_edge_length = 0.0f;
+        bvh = BVH{};
     }
 };
 
@@ -1630,7 +1632,7 @@ CUDA_CALLABLE inline mesh_query_aabb_t mesh_query_aabb(
         BVHPackedNodeHalf node_lower = bvh_load_node(mesh.bvh.node_lowers, nodeIndex);
         BVHPackedNodeHalf node_upper = bvh_load_node(mesh.bvh.node_uppers, nodeIndex);
 
-        if (!input_bounds.overlaps((vec3&)node_lower, (vec3&)node_upper))
+        if (!input_bounds.overlaps(reinterpret_cast<vec3&>(node_lower), reinterpret_cast<vec3&>(node_upper)))
         {
             // Skip this box, it doesn't overlap with our target box.
             continue;
@@ -1715,7 +1717,7 @@ CUDA_CALLABLE inline bool mesh_query_aabb_next(mesh_query_aabb_t& query, int& in
         BVHPackedNodeHalf node_lower = bvh_load_node(mesh.bvh.node_lowers, node_index);
         BVHPackedNodeHalf node_upper = bvh_load_node(mesh.bvh.node_uppers, node_index);
 
-        if (!input_bounds.overlaps((vec3&)node_lower, (vec3&)node_upper))
+        if (!input_bounds.overlaps(reinterpret_cast<vec3&>(node_lower), reinterpret_cast<vec3&>(node_upper)))
         {
             // Skip this box, it doesn't overlap with our target box.
             continue;