warp-lang 1.2.1__py3-none-manylinux2014_x86_64.whl → 1.3.0__py3-none-manylinux2014_x86_64.whl

warp/tests/test_matmul.py

@@ -72,17 +72,19 @@ class gemm_test_bed_runner:
         ones = wp.zeros_like(D)
         ones.fill_(1.0)
 
+        np_dtype = wp.types.warp_type_to_np_dtype[self.dtype]
+
         if batch_count == 1:
             tape = wp.Tape()
             with tape:
                 wp.matmul(A, B, C, D, alpha, beta, False)
             tape.backward(grads={D: ones})
 
-            D_np = alpha * (A.numpy() @ B.numpy()) + beta * C.numpy()
+            D_np = alpha * np.matmul(A.numpy(), B.numpy(), dtype=np_dtype) + beta * C.numpy()
             assert_np_equal(D.numpy(), D_np)
 
-            adj_A_np = alpha * np.matmul(ones.numpy(), B.numpy().transpose())
-            adj_B_np = alpha * (A.numpy().transpose() @ ones.numpy())
+            adj_A_np = alpha * np.matmul(ones.numpy(), B.numpy().transpose(), dtype=np_dtype)
+            adj_B_np = alpha * np.matmul(A.numpy().transpose(), ones.numpy(), dtype=np_dtype)
             adj_C_np = beta * ones.numpy()
 
         else:
@@ -91,11 +93,11 @@ class gemm_test_bed_runner:
                 wp.batched_matmul(A, B, C, D, alpha, beta, False)
             tape.backward(grads={D: ones})
 
-            D_np = alpha * np.matmul(A.numpy(), B.numpy()) + beta * C.numpy()
+            D_np = alpha * np.matmul(A.numpy(), B.numpy(), dtype=np_dtype) + beta * C.numpy()
             assert_np_equal(D.numpy(), D_np)
 
-            adj_A_np = alpha * np.matmul(ones.numpy(), B.numpy().transpose((0, 2, 1)))
-            adj_B_np = alpha * np.matmul(A.numpy().transpose((0, 2, 1)), ones.numpy())
+            adj_A_np = alpha * np.matmul(ones.numpy(), B.numpy().transpose((0, 2, 1)), dtype=np_dtype)
+            adj_B_np = alpha * np.matmul(A.numpy().transpose((0, 2, 1)), ones.numpy(), dtype=np_dtype)
             adj_C_np = beta * ones.numpy()
 
         assert_np_equal(A.grad.numpy(), adj_A_np)
@@ -103,9 +105,9 @@ class gemm_test_bed_runner:
         assert_np_equal(C.grad.numpy(), adj_C_np)
 
     def run(self):
-        Ms = [64, 128, 512]
-        Ns = [64, 128, 512]
-        Ks = [64, 128, 512]
+        Ms = [64, 128, 256]
+        Ns = [64, 128, 256]
+        Ks = [64, 128, 256]
         batch_counts = [1, 4]
         betas = [0.0, 1.0]
         alpha = 1.0
@@ -188,6 +190,8 @@ class gemm_test_bed_runner_transpose:
         ones3 = wp.zeros_like(D3)
         ones3.fill_(1.0)
 
+        np_dtype = wp.types.warp_type_to_np_dtype[self.dtype]
+
         if batch_count == 1:
             ATT1 = AT1.transpose([1, 0])
             BTT1 = BT1.transpose([1, 0])
@@ -200,13 +204,13 @@ class gemm_test_bed_runner_transpose:
                 wp.matmul(ATT2, BTT2, C3, D3, alpha, beta, False)
             tape.backward(grads={D1: ones1, D2: ones2, D3: ones3})
 
-            D_np = alpha * (A.numpy() @ B.numpy()) + beta * C1.numpy()
+            D_np = alpha * np.matmul(A.numpy(), B.numpy(), dtype=np_dtype) + beta * C1.numpy()
             assert_np_equal(D1.numpy(), D_np)
             assert_np_equal(D2.numpy(), D_np)
             assert_np_equal(D3.numpy(), D_np)
 
-            adj_A_np = alpha * (ones1.numpy() @ B.numpy().transpose())
-            adj_B_np = alpha * (A.numpy().transpose() @ ones1.numpy())
+            adj_A_np = alpha * np.matmul(ones1.numpy(), B.numpy().transpose(), dtype=np_dtype)
+            adj_B_np = alpha * np.matmul(A.numpy().transpose(), ones1.numpy(), dtype=np_dtype)
             adj_C_np = beta * ones1.numpy()
 
         else:
@@ -221,13 +225,13 @@ class gemm_test_bed_runner_transpose:
                 wp.batched_matmul(ATT2, BTT2, C3, D3, alpha, beta, False)
             tape.backward(grads={D1: ones1, D2: ones2, D3: ones3})
 
-            D_np = alpha * np.matmul(A.numpy(), B.numpy()) + beta * C1.numpy()
+            D_np = alpha * np.matmul(A.numpy(), B.numpy(), dtype=np_dtype) + beta * C1.numpy()
             assert_np_equal(D1.numpy(), D_np)
             assert_np_equal(D2.numpy(), D_np)
             assert_np_equal(D3.numpy(), D_np)
 
-            adj_A_np = alpha * np.matmul(ones1.numpy(), B.numpy().transpose((0, 2, 1)))
-            adj_B_np = alpha * np.matmul(A.numpy().transpose((0, 2, 1)), ones1.numpy())
+            adj_A_np = alpha * np.matmul(ones1.numpy(), B.numpy().transpose((0, 2, 1)), dtype=np_dtype)
+            adj_B_np = alpha * np.matmul(A.numpy().transpose((0, 2, 1)), ones1.numpy(), dtype=np_dtype)
             adj_C_np = beta * ones1.numpy()
 
         assert_np_equal(A.grad.numpy(), adj_A_np)
@@ -494,5 +498,5 @@ add_function_test(TestMatmul, "test_cuda_graph_capture", test_cuda_graph_capture
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=False)

warp/tests/test_matmul_lite.py

@@ -404,5 +404,5 @@ add_function_test(TestMatmulLite, "test_large_batch_count", test_large_batch_cou
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=False)

warp/tests/test_mempool.py

@@ -182,5 +182,5 @@ add_function_test(TestMempool, "test_mempool_access_exceptions_cpu", test_mempoo
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_mesh.py

@@ -266,7 +266,10 @@ devices = get_test_devices()
 
 
 class TestMesh(unittest.TestCase):
-    pass
+    def test_mesh_new_del(self):
+        # test the scenario in which a mesh is created but not initialized before gc
+        instance = wp.Mesh.__new__(wp.Mesh)
+        instance.__del__()
 
 
 add_function_test(TestMesh, "test_mesh_read_properties", test_mesh_read_properties, devices=devices)
@@ -277,5 +280,5 @@ add_function_test(TestMesh, "test_mesh_exceptions", test_mesh_exceptions, device
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_mesh_query_aabb.py

@@ -222,5 +222,5 @@ add_function_test(
 )
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_mesh_query_point.py

@@ -686,5 +686,5 @@ add_function_test(TestMeshQueryPoint, "test_mesh_query_furthest_point", test_mes
 add_function_test(TestMeshQueryPoint, "test_adj_mesh_query_point", test_adj_mesh_query_point, devices=devices)
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_mesh_query_ray.py

@@ -286,5 +286,5 @@ add_function_test(TestMeshQueryRay, "test_mesh_query_ray_grad", test_mesh_query_
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_mlp.py

@@ -270,5 +270,5 @@ add_function_test(TestMLP, "test_mlp_grad", test_mlp_grad, devices=devices)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=False)

warp/tests/test_model.py

@@ -104,5 +104,5 @@ class TestModel(unittest.TestCase):
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_module_hashing.py

@@ -66,6 +66,65 @@ def fn(value: int):
     wp.print(value + 1)
 """
 
+FUNC_GENERIC_1 = """# -*- coding: utf-8 -*-
+import warp as wp
+
+from typing import Any
+
+@wp.func
+def generic_fn(x: Any):
+    return x * x
+
+@wp.func
+def generic_fn(x: Any, y: Any):
+    return x * y
+"""
+
+# should be same hash as FUNC_GENERIC_1
+FUNC_GENERIC_2 = """# -*- coding: utf-8 -*-
+import warp as wp
+
+from typing import Any
+
+@wp.func
+def generic_fn(x: Any):
+    return x * x
+
+@wp.func
+def generic_fn(x: Any, y: Any):
+    return x * y
+"""
+
+# should be different hash than FUNC_GENERIC_1 (first overload is different)
+FUNC_GENERIC_3 = """# -*- coding: utf-8 -*-
+import warp as wp
+
+from typing import Any
+
+@wp.func
+def generic_fn(x: Any):
+    return x + x
+
+@wp.func
+def generic_fn(x: Any, y: Any):
+    return x * y
+"""
+
+# should be different hash than FUNC_GENERIC_1 (second overload is different)
+FUNC_GENERIC_4 = """# -*- coding: utf-8 -*-
+import warp as wp
+
+from typing import Any
+
+@wp.func
+def generic_fn(x: Any):
+    return x * x
+
+@wp.func
+def generic_fn(x: Any, y: Any):
+    return x + y
+"""
+
 
 def load_code_as_module(code, name):
     file, file_path = tempfile.mkstemp(suffix=".py")
@@ -99,13 +158,30 @@ def test_function_overload_hashing(test, device):
     test.assertNotEqual(hash4, hash1)
 
 
+def test_function_generic_overload_hashing(test, device):
+    m1 = load_code_as_module(FUNC_GENERIC_1, "func_generic_1")
+    m2 = load_code_as_module(FUNC_GENERIC_2, "func_generic_2")
+    m3 = load_code_as_module(FUNC_GENERIC_3, "func_generic_3")
+    m4 = load_code_as_module(FUNC_GENERIC_4, "func_generic_4")
+
+    hash1 = m1.hash_module()
+    hash2 = m2.hash_module()
+    hash3 = m3.hash_module()
+    hash4 = m4.hash_module()
+
+    test.assertEqual(hash2, hash1)
+    test.assertNotEqual(hash3, hash1)
+    test.assertNotEqual(hash4, hash1)
+
+
 class TestModuleHashing(unittest.TestCase):
     pass
 
 
 add_function_test(TestModuleHashing, "test_function_overload_hashing", test_function_overload_hashing)
+add_function_test(TestModuleHashing, "test_function_generic_overload_hashing", test_function_generic_overload_hashing)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_modules_lite.py

@@ -32,5 +32,5 @@ class TestModuleLite(unittest.TestCase):
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_multigpu.py

@@ -157,5 +157,5 @@ class TestMultiGPU(unittest.TestCase):
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=False)

warp/tests/test_noise.py

@@ -240,5 +240,5 @@ add_function_test(TestNoise, "test_adj_noise", test_adj_noise, devices=devices)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_operators.py

@@ -244,5 +244,5 @@ add_kernel_test(TestOperators, test_operators_mat44, dim=1, devices=devices)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_options.py

@@ -117,5 +117,5 @@ add_function_test(TestOptions, "test_options_4", test_options_4, devices=devices
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)