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

warp/tests/test_vec.py

@@ -49,23 +49,6 @@ def getkernel(func, suffix=""):
     return kernel_cache[key]
 
 
-def test_anon_constructor_error_dtype_keyword_missing(test, device):
-    @wp.kernel
-    def kernel():
-        wp.vector(length=123)
-
-    with test.assertRaisesRegex(
-        RuntimeError,
-        r"vec\(\) must have dtype as a keyword argument if it has no positional arguments, e.g.: wp.vector\(length=5, dtype=wp.float32\)$",
-    ):
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[],
-            device=device,
-        )
-
-
 def test_anon_constructor_error_length_mismatch(test, device):
     @wp.kernel
     def kernel():
@@ -77,7 +60,7 @@ def test_anon_constructor_error_length_mismatch(test, device):
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Incompatible vector lengths for casting copy constructor, 3 vs 2$",
+        r"incompatible vector of length 3 given when copy constructing a vector of length 2$",
     ):
         wp.launch(
             kernel,
@@ -87,14 +70,14 @@ def test_anon_constructor_error_length_mismatch(test, device):
         )
 
 
-def test_anon_constructor_error_numeric_arg_missing_1(test, device):
+def test_anon_constructor_error_numeric_arg_missing(test, device):
     @wp.kernel
     def kernel():
         wp.vector(1.0, 2.0, length=12345)
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"vec\(\) must have one scalar argument or the dtype keyword argument if the length keyword argument is specified, e.g.: wp.vec\(1.0, length=5\)$",
+        r"incompatible number of values given \(2\) when constructing a vector of length 12345$",
     ):
         wp.launch(
             kernel,
@@ -104,31 +87,14 @@ def test_anon_constructor_error_numeric_arg_missing_1(test, device):
         )
 
 
-def test_anon_constructor_error_numeric_arg_missing_2(test, device):
+def test_anon_constructor_error_length_arg_missing(test, device):
     @wp.kernel
     def kernel():
         wp.vector()
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"vec\(\) must have at least one numeric argument, if it's length, dtype is not specified$",
-    ):
-        wp.launch(
-            kernel,
-            dim=1,
-            inputs=[],
-            device=device,
-        )
-
-
-def test_anon_constructor_error_dtype_keyword_extraneous(test, device):
-    @wp.kernel
-    def kernel():
-        wp.vector(1.0, 2.0, 3.0, dtype=float)
-
-    with test.assertRaisesRegex(
-        RuntimeError,
-        r"vec\(\) should not have dtype specified if numeric arguments are given, the dtype will be inferred from the argument types$",
+        r"the `length` argument must be specified when zero-initializing a vector$",
     ):
         wp.launch(
             kernel,
@@ -145,9 +111,7 @@ def test_anon_constructor_error_numeric_args_mismatch(test, device):
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"All numeric arguments to vec\(\) constructor should have the same "
-        r"type, expected 2 arg_types of type <class 'warp.types.float32'>, "
-        r"received <class 'warp.types.float32'>,<class 'warp.types.int32'>$",
+        r"all values given when constructing a vector must have the same type$",
     ):
         wp.launch(
             kernel,
@@ -162,7 +126,9 @@ def test_tpl_constructor_error_incompatible_sizes(test, device):
     def kernel():
         wp.vec3(wp.vec2(1.0, 2.0))
 
-    with test.assertRaisesRegex(RuntimeError, r"Incompatible matrix sizes for casting copy constructor, 3 vs 2"):
+    with test.assertRaisesRegex(
+        RuntimeError, "incompatible vector of length 3 given when copy constructing a vector of length 2"
+    ):
         wp.launch(
             kernel,
             dim=1,
@@ -178,9 +144,7 @@ def test_tpl_constructor_error_numeric_args_mismatch(test, device):
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"All numeric arguments to vec\(\) constructor should have the same "
-        r"type, expected 2 arg_types of type <class 'warp.types.float32'>, "
-        r"received <class 'warp.types.float32'>,<class 'warp.types.int32'>$",
+        r"all values given when constructing a vector must have the same type$",
     ):
         wp.launch(
             kernel,
@@ -1207,12 +1171,6 @@ for dtype in np_float_types:
         dtype=dtype,
     )
 
-add_function_test(
-    TestVec,
-    "test_anon_constructor_error_dtype_keyword_missing",
-    test_anon_constructor_error_dtype_keyword_missing,
-    devices=devices,
-)
 add_function_test(
     TestVec,
     "test_anon_constructor_error_length_mismatch",
@@ -1221,20 +1179,14 @@ add_function_test(
 )
 add_function_test(
     TestVec,
-    "test_anon_constructor_error_numeric_arg_missing_1",
-    test_anon_constructor_error_numeric_arg_missing_1,
-    devices=devices,
-)
-add_function_test(
-    TestVec,
-    "test_anon_constructor_error_numeric_arg_missing_2",
-    test_anon_constructor_error_numeric_arg_missing_2,
+    "test_anon_constructor_error_numeric_arg_missing",
+    test_anon_constructor_error_numeric_arg_missing,
     devices=devices,
 )
 add_function_test(
     TestVec,
-    "test_anon_constructor_error_dtype_keyword_extraneous",
-    test_anon_constructor_error_dtype_keyword_extraneous,
+    "test_anon_constructor_error_length_arg_missing",
+    test_anon_constructor_error_length_arg_missing,
     devices=devices,
 )
 add_function_test(
@@ -1258,5 +1210,5 @@ add_function_test(
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_vec_lite.py

@@ -17,6 +17,7 @@ def test_vector_constructor_value_func():
     b = wp.vector(a, dtype=wp.float16)
     c = wp.vector(a)
     d = wp.vector(a, length=2)
+    e = wp.vector(1.0, length=3)
 
 
 # Test matrix constructors using explicit type (float16)
@@ -67,5 +68,5 @@ add_kernel_test(TestVecLite, test_constructors_default_precision, dim=1, devices
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_vec_scalar_ops.py

@@ -687,10 +687,22 @@ def test_equality(test, device, dtype, register_kernels=False):
     vec4 = wp.types.vector(length=4, dtype=wptype)
     vec5 = wp.types.vector(length=5, dtype=wptype)
 
-    def check_equality(
+    def check_unsigned_equality(
         v20: wp.array(dtype=vec2),
         v21: wp.array(dtype=vec2),
         v22: wp.array(dtype=vec2),
+        v30: wp.array(dtype=vec3),
+        v40: wp.array(dtype=vec4),
+        v50: wp.array(dtype=vec5),
+    ):
+        wp.expect_eq(v20[0], v20[0])
+        wp.expect_neq(v21[0], v20[0])
+        wp.expect_neq(v22[0], v20[0])
+        wp.expect_eq(v30[0], v30[0])
+        wp.expect_eq(v40[0], v40[0])
+        wp.expect_eq(v50[0], v50[0])
+
+    def check_signed_equality(
         v30: wp.array(dtype=vec3),
         v31: wp.array(dtype=vec3),
         v32: wp.array(dtype=vec3),
@@ -707,29 +719,21 @@ def test_equality(test, device, dtype, register_kernels=False):
         v54: wp.array(dtype=vec5),
         v55: wp.array(dtype=vec5),
     ):
-        wp.expect_eq(v20[0], v20[0])
-        wp.expect_neq(v21[0], v20[0])
-        wp.expect_neq(v22[0], v20[0])
-
-        wp.expect_eq(v30[0], v30[0])
         wp.expect_neq(v31[0], v30[0])
         wp.expect_neq(v32[0], v30[0])
         wp.expect_neq(v33[0], v30[0])
-
-        wp.expect_eq(v40[0], v40[0])
         wp.expect_neq(v41[0], v40[0])
         wp.expect_neq(v42[0], v40[0])
         wp.expect_neq(v43[0], v40[0])
         wp.expect_neq(v44[0], v40[0])
-
-        wp.expect_eq(v50[0], v50[0])
         wp.expect_neq(v51[0], v50[0])
         wp.expect_neq(v52[0], v50[0])
         wp.expect_neq(v53[0], v50[0])
         wp.expect_neq(v54[0], v50[0])
         wp.expect_neq(v55[0], v50[0])
 
-    kernel = getkernel(check_equality, suffix=dtype.__name__)
+    unsigned_kernel = getkernel(check_unsigned_equality, suffix=dtype.__name__)
+    signed_kernel = getkernel(check_signed_equality, suffix=dtype.__name__)
 
     if register_kernels:
         return
@@ -739,49 +743,64 @@ def test_equality(test, device, dtype, register_kernels=False):
     v22 = wp.array([3.0, 2.0], dtype=vec2, requires_grad=True, device=device)
 
     v30 = wp.array([1.0, 2.0, 3.0], dtype=vec3, requires_grad=True, device=device)
-    v31 = wp.array([-1.0, 2.0, 3.0], dtype=vec3, requires_grad=True, device=device)
-    v32 = wp.array([1.0, -2.0, 3.0], dtype=vec3, requires_grad=True, device=device)
-    v33 = wp.array([1.0, 2.0, -3.0], dtype=vec3, requires_grad=True, device=device)
-
     v40 = wp.array([1.0, 2.0, 3.0, 4.0], dtype=vec4, requires_grad=True, device=device)
-    v41 = wp.array([-1.0, 2.0, 3.0, 4.0], dtype=vec4, requires_grad=True, device=device)
-    v42 = wp.array([1.0, -2.0, 3.0, 4.0], dtype=vec4, requires_grad=True, device=device)
-    v43 = wp.array([1.0, 2.0, -3.0, 4.0], dtype=vec4, requires_grad=True, device=device)
-    v44 = wp.array([1.0, 2.0, 3.0, -4.0], dtype=vec4, requires_grad=True, device=device)
-
     v50 = wp.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
-    v51 = wp.array([-1.0, 2.0, 3.0, 4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
-    v52 = wp.array([1.0, -2.0, 3.0, 4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
-    v53 = wp.array([1.0, 2.0, -3.0, 4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
-    v54 = wp.array([1.0, 2.0, 3.0, -4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
-    v55 = wp.array([1.0, 2.0, 3.0, 4.0, -5.0], dtype=vec5, requires_grad=True, device=device)
+
     wp.launch(
-        kernel,
+        unsigned_kernel,
         dim=1,
         inputs=[
             v20,
             v21,
             v22,
             v30,
-            v31,
-            v32,
-            v33,
             v40,
-            v41,
-            v42,
-            v43,
-            v44,
             v50,
-            v51,
-            v52,
-            v53,
-            v54,
-            v55,
         ],
         outputs=[],
         device=device,
     )
 
+    if dtype not in np_unsigned_int_types:
+        v31 = wp.array([-1.0, 2.0, 3.0], dtype=vec3, requires_grad=True, device=device)
+        v32 = wp.array([1.0, -2.0, 3.0], dtype=vec3, requires_grad=True, device=device)
+        v33 = wp.array([1.0, 2.0, -3.0], dtype=vec3, requires_grad=True, device=device)
+
+        v41 = wp.array([-1.0, 2.0, 3.0, 4.0], dtype=vec4, requires_grad=True, device=device)
+        v42 = wp.array([1.0, -2.0, 3.0, 4.0], dtype=vec4, requires_grad=True, device=device)
+        v43 = wp.array([1.0, 2.0, -3.0, 4.0], dtype=vec4, requires_grad=True, device=device)
+        v44 = wp.array([1.0, 2.0, 3.0, -4.0], dtype=vec4, requires_grad=True, device=device)
+
+        v51 = wp.array([-1.0, 2.0, 3.0, 4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
+        v52 = wp.array([1.0, -2.0, 3.0, 4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
+        v53 = wp.array([1.0, 2.0, -3.0, 4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
+        v54 = wp.array([1.0, 2.0, 3.0, -4.0, 5.0], dtype=vec5, requires_grad=True, device=device)
+        v55 = wp.array([1.0, 2.0, 3.0, 4.0, -5.0], dtype=vec5, requires_grad=True, device=device)
+
+        wp.launch(
+            signed_kernel,
+            dim=1,
+            inputs=[
+                v30,
+                v31,
+                v32,
+                v33,
+                v40,
+                v41,
+                v42,
+                v43,
+                v44,
+                v50,
+                v51,
+                v52,
+                v53,
+                v54,
+                v55,
+            ],
+            outputs=[],
+            device=device,
+        )
+
 
 def test_scalar_multiplication(test, device, dtype, register_kernels=False):
     rng = np.random.default_rng(123)
@@ -1883,6 +1902,62 @@ def test_constants(test, device, dtype, register_kernels=False):
     wp.launch(kernel, dim=1, inputs=[], device=device)
 
 
+def test_abs(test, device, dtype, register_kernels=False):
+    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp.types.vector(length=2, dtype=wptype)
+    vec3 = wp.types.vector(length=3, dtype=wptype)
+    vec4 = wp.types.vector(length=4, dtype=wptype)
+    vec5 = wp.types.vector(length=5, dtype=wptype)
+
+    def check_vector_abs():
+        res2 = wp.abs(vec2(wptype(-1), wptype(2)))
+        wp.expect_eq(res2, vec2(wptype(1), wptype(2)))
+
+        res3 = wp.abs(vec3(wptype(1), wptype(-2), wptype(3)))
+        wp.expect_eq(res3, vec3(wptype(1), wptype(2), wptype(3)))
+
+        res4 = wp.abs(vec4(wptype(-1), wptype(2), wptype(3), wptype(-4)))
+        wp.expect_eq(res4, vec4(wptype(1), wptype(2), wptype(3), wptype(4)))
+
+        res5 = wp.abs(vec5(wptype(-1), wptype(2), wptype(-3), wptype(4), wptype(-5)))
+        wp.expect_eq(res5, vec5(wptype(1), wptype(2), wptype(3), wptype(4), wptype(5)))
+
+    kernel = getkernel(check_vector_abs, suffix=dtype.__name__)
+
+    if register_kernels:
+        return
+
+    wp.launch(kernel, dim=1, inputs=[], device=device)
+
+
+def test_sign(test, device, dtype, register_kernels=False):
+    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp.types.vector(length=2, dtype=wptype)
+    vec3 = wp.types.vector(length=3, dtype=wptype)
+    vec4 = wp.types.vector(length=4, dtype=wptype)
+    vec5 = wp.types.vector(length=5, dtype=wptype)
+
+    def check_vector_sign():
+        res2 = wp.sign(vec2(wptype(-1), wptype(2)))
+        wp.expect_eq(res2, vec2(wptype(-1), wptype(1)))
+
+        res3 = wp.sign(vec3(wptype(1), wptype(-2), wptype(3)))
+        wp.expect_eq(res3, vec3(wptype(1), wptype(-1), wptype(1)))
+
+        res4 = wp.sign(vec4(wptype(-1), wptype(2), wptype(3), wptype(-4)))
+        wp.expect_eq(res4, vec4(wptype(-1), wptype(1), wptype(1), wptype(-1)))
+
+        res5 = wp.sign(vec5(wptype(-1), wptype(2), wptype(-3), wptype(4), wptype(-5)))
+        wp.expect_eq(res5, vec5(wptype(-1), wptype(1), wptype(-1), wptype(1), wptype(-1)))
+
+    kernel = getkernel(check_vector_sign, suffix=dtype.__name__)
+
+    if register_kernels:
+        return
+
+    wp.launch(kernel, dim=1, inputs=[], device=device)
+
+
 def test_minmax(test, device, dtype, register_kernels=False):
     rng = np.random.default_rng(123)
 
@@ -2088,10 +2163,18 @@ for dtype in np_scalar_types:
         TestVecScalarOps, f"test_constants_{dtype.__name__}", test_constants, devices=devices, dtype=dtype
     )
 
+    if dtype not in np_unsigned_int_types:
+        add_function_test_register_kernel(
+            TestVecScalarOps, f"test_abs_{dtype.__name__}", test_abs, devices=devices, dtype=dtype
+        )
+        add_function_test_register_kernel(
+            TestVecScalarOps, f"test_sign_{dtype.__name__}", test_sign, devices=devices, dtype=dtype
+        )
+
     # the kernels in this test compile incredibly slowly...
     # add_function_test_register_kernel(TestVecScalarOps, f"test_minmax_{dtype.__name__}", test_minmax, devices=devices, dtype=dtype)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_verify_fp.py

@@ -88,5 +88,5 @@ add_function_test(TestVerifyFP, "test_nan", test_nan, devices=devices, check_out
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_volume.py

@@ -843,8 +843,31 @@ def test_volume_from_numpy(test, device):
     test.assertIsNone(sphere_vdb_array.deleter)
 
 
+def test_volume_aniso_transform(test, device):
+    # XY-rotation + z scale
+    transform = [
+        [0, -1, 0],
+        [1, 0, 0],
+        [0, 0, 2],
+    ]
+
+    points = wp.array([[-1, 1, 4]], dtype=float, device=device)
+    volume = wp.Volume.allocate_by_voxels(voxel_points=points, transform=transform, device=device)
+
+    # Check that world points are correctly converted to local space
+    voxels = volume.get_voxels().numpy()
+    assert_np_equal(voxels, [[1, 1, 2]])
+
+    # Check that we retrieve the correct transform from the grid metadata
+    assert_np_equal(volume.get_voxel_size(), [-1, 1, 2])
+    assert_np_equal(transform, np.array(volume.get_grid_info().transform_matrix).reshape(3, 3))
+
+
 class TestVolume(unittest.TestCase):
-    pass
+    def test_volume_new_del(self):
+        # test the scenario in which a volume is created but not initialized before gc
+        instance = wp.Volume.__new__(wp.Volume)
+        instance.__del__()
 
 
 add_function_test(
@@ -871,6 +894,9 @@ add_function_test(TestVolume, "test_volume_introspection", test_volume_introspec
 add_function_test(
     TestVolume, "test_volume_from_numpy", test_volume_from_numpy, devices=get_selected_cuda_test_devices()
 )
+add_function_test(
+    TestVolume, "test_volume_aniso_transform", test_volume_aniso_transform, devices=get_selected_cuda_test_devices()
+)
 add_function_test(TestVolume, "test_volume_multiple_grids", test_volume_multiple_grids, devices=devices)
 add_function_test(TestVolume, "test_volume_feature_array", test_volume_feature_array, devices=devices)
 add_function_test(TestVolume, "test_volume_sample_index", test_volume_sample_index, devices=devices)
@@ -957,5 +983,5 @@ for device in devices:
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_volume_write.py

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

warp/tests/unittest_serial.py

@@ -15,7 +15,7 @@ def run_suite() -> bool:
     """Run a test suite"""
 
     # force rebuild of all kernels
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     print("Cleared Warp kernel cache")
 
     runner = unittest.TextTestRunner(verbosity=2, failfast=True)

warp/tests/unittest_suites.py

@@ -120,6 +120,7 @@ def default_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader)
     from warp.tests.test_generics import TestGenerics
     from warp.tests.test_grad import TestGrad
     from warp.tests.test_grad_customs import TestGradCustoms
+    from warp.tests.test_grad_debug import TestGradDebug
     from warp.tests.test_hash_grid import TestHashGrid
     from warp.tests.test_import import TestImport
     from warp.tests.test_indexedarray import TestIndexedArray
@@ -150,6 +151,7 @@ def default_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader)
     from warp.tests.test_noise import TestNoise
     from warp.tests.test_operators import TestOperators
     from warp.tests.test_options import TestOptions
+    from warp.tests.test_overwrite import TestOverwrite
     from warp.tests.test_peer import TestPeer
     from warp.tests.test_pinned import TestPinned
     from warp.tests.test_print import TestPrint
@@ -164,6 +166,7 @@ def default_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader)
     from warp.tests.test_snippet import TestSnippets
     from warp.tests.test_sparse import TestSparse
     from warp.tests.test_spatial import TestSpatial
+    from warp.tests.test_special_values import TestSpecialValues
     from warp.tests.test_streams import TestStreams
     from warp.tests.test_struct import TestStruct
     from warp.tests.test_tape import TestTape
@@ -211,6 +214,7 @@ def default_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader)
         TestGenerics,
         TestGrad,
         TestGradCustoms,
+        TestGradDebug,
         TestHashGrid,
         TestImport,
         TestIndexedArray,
@@ -241,6 +245,7 @@ def default_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader)
         TestNoise,
         TestOperators,
         TestOptions,
+        TestOverwrite,
         TestPeer,
         TestPinned,
         TestPrint,
@@ -252,9 +257,10 @@ def default_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader)
         TestSimGradients,
         TestSimKinematics,
         TestSmoothstep,
-        TestSparse,
         TestSnippets,
+        TestSparse,
         TestSpatial,
+        TestSpecialValues,
         TestStreams,
         TestStruct,
         TestTape,
@@ -291,6 +297,7 @@ def kit_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader):
     from warp.tests.test_func import TestFunc
     from warp.tests.test_generics import TestGenerics
     from warp.tests.test_grad_customs import TestGradCustoms
+    from warp.tests.test_grad_debug import TestGradDebug
     from warp.tests.test_hash_grid import TestHashGrid
     from warp.tests.test_indexedarray import TestIndexedArray
     from warp.tests.test_launch import TestLaunch
@@ -334,6 +341,7 @@ def kit_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader):
         TestFunc,
         TestGenerics,
         TestGradCustoms,
+        TestGradDebug,
         TestHashGrid,
         TestIndexedArray,
         TestLaunch,

warp/tests/walkthrough_debug.py

@@ -81,5 +81,5 @@ def example_breakpoint(n: int):
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     wp.launch(example_breakpoint, dim=1, inputs=[10], device="cpu")

warp/thirdparty/unittest_parallel.py

@@ -173,7 +173,7 @@ def main(argv=None):
     import warp as wp  # NVIDIA Modification
 
     # Clear the Warp cache (NVIDIA Modification)
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     print("Cleared Warp kernel cache")
 
     # Create the temporary directory (for coverage files)
@@ -244,7 +244,7 @@ def main(argv=None):
                     initargs=(manager.Lock(), shared_index, args, temp_dir),
                 ) as executor:
                     test_manager = ParallelTestManager(manager, args, temp_dir)
-                    results = list(executor.map(test_manager.run_tests, test_suites, timeout=7200))
+                    results = list(executor.map(test_manager.run_tests, test_suites, timeout=2400))
         else:
             # This entire path is an NVIDIA Modification
 
@@ -554,9 +554,6 @@ def initialize_test_process(lock, shared_index, args, temp_dir):
             wp.config.kernel_cache_dir = cache_root_dir
 
             wp.build.clear_kernel_cache()
-        else:
-            # Initialize Warp is if hasn't been initialized already
-            wp.init()
 
 
 if __name__ == "__main__":  # pragma: no cover