warp-lang 1.7.0__py3-none-manylinux_2_34_aarch64.whl → 1.7.2rc1__py3-none-manylinux_2_34_aarch64.whl

warp/tests/tile/test_tile_load.py

@@ -184,6 +184,122 @@ def test_tile_load_unaligned(test, device):
     assert_np_equal(input.grad.numpy(), expected_grad)
 
 
+@wp.kernel
+def tile_load_aligned_small_kernel(
+    input: wp.array2d(dtype=float),
+    output: wp.array2d(dtype=float),
+):
+    t = wp.tile_load(input, shape=(3, 3), offset=(0, 0), storage="shared")
+    wp.tile_store(output, t, offset=(0, 0))
+
+
+# regression test for tiles that are smaller than sizeof(float4) in that last
+# dimension but are aligned to float4. Did trigger the fast float4 path by accident.
+def test_tile_load_aligned_small(test, device):
+    rng = np.random.default_rng(42)
+
+    shape = [TILE_M, TILE_N]
+
+    input = wp.array(rng.random(shape), dtype=float, requires_grad=True, device=device)
+    output = wp.zeros(shape, dtype=float, device=device)
+
+    wp.launch_tiled(
+        tile_load_aligned_small_kernel,
+        dim=[1],
+        inputs=[input, output],
+        block_dim=TILE_DIM,
+        device=device,
+    )
+
+    # zeros except for the 3x3 tile at 0, 0
+    assert_np_equal(output.numpy()[3:, :], np.zeros((TILE_M - 3, TILE_N)))
+    assert_np_equal(output.numpy()[:, 3:], np.zeros((TILE_M, TILE_N - 3)))
+
+    # check output elements
+    assert_np_equal(output.numpy()[:3, :3], input.numpy()[:3, :3])
+
+
+TILE_WIDTH = 5
+TILE_OFFSET_X = 0
+TILE_OFFSET_Y = 8
+
+
+@wp.kernel
+def test_tile_load_aligned_offset_unaligned_size_kernel(
+    input: wp.array2d(dtype=float),
+    output: wp.array2d(dtype=float),
+):
+    # Load a 5x5 tile from the input array starting at offset (0,8)
+    # and store it in shared memory
+    tile = wp.tile_load(input, shape=(TILE_WIDTH, TILE_WIDTH), offset=(TILE_OFFSET_X, TILE_OFFSET_Y), storage="shared")
+
+    # Store the loaded tile back to the output array at the same offset
+    wp.tile_store(output, tile, offset=(TILE_OFFSET_X, TILE_OFFSET_Y))
+
+
+def test_tile_load_aligned_offset_unaligned_size(test, device):
+    """Test loading a tile with aligned offset but unaligned size."""
+
+    rng = np.random.default_rng(42)
+    array_shape = [TILE_N, TILE_M]
+
+    input_array = wp.array(rng.random(array_shape), dtype=float, requires_grad=True, device=device)
+    output_array = wp.zeros(array_shape, dtype=float, device=device)
+
+    wp.launch_tiled(
+        test_tile_load_aligned_offset_unaligned_size_kernel,
+        dim=[1],
+        inputs=[input_array, output_array],
+        block_dim=TILE_DIM,
+        device=device,
+    )
+
+    # Region before the tile offset should be zeros
+    assert_np_equal(output_array.numpy()[:TILE_WIDTH, :TILE_OFFSET_Y], np.zeros((TILE_WIDTH, TILE_OFFSET_Y)))
+
+    # Region where the tile was loaded/stored should match input
+    assert_np_equal(
+        output_array.numpy()[:TILE_WIDTH, TILE_OFFSET_Y : TILE_OFFSET_Y + TILE_WIDTH],
+        input_array.numpy()[:TILE_WIDTH, TILE_OFFSET_Y : TILE_OFFSET_Y + TILE_WIDTH],
+    )
+
+    # Region after the tile should be zeros
+    remaining_width = TILE_M - (TILE_OFFSET_Y + TILE_WIDTH)
+    assert_np_equal(
+        output_array.numpy()[:TILE_WIDTH, TILE_OFFSET_Y + TILE_WIDTH :], np.zeros((TILE_WIDTH, remaining_width))
+    )
+
+    # Rows below the tile should all be zeros
+    remaining_height = TILE_N - TILE_WIDTH
+    assert_np_equal(output_array.numpy()[TILE_WIDTH:, :], np.zeros((remaining_height, TILE_M)))
+
+
+@wp.kernel
+def test_tile_load_stride_unaligned_kernel(input: wp.array2d(dtype=wp.float32), output: wp.array2d(dtype=wp.float32)):
+    tile = wp.tile_load(input, shape=(4, 4))
+    wp.tile_store(output, tile)
+
+
+# regression test for float4 aligned tiles that load from a source array with an incommensurate stride
+def test_tile_load_stride_unaligned(test, device):
+    DIM = 5
+    input_np = np.eye(DIM) * 2.0
+    input_array = wp.array(input_np, dtype=wp.float32, device=device)
+    output_array = wp.zeros_like(input_array)
+
+    wp.launch_tiled(
+        test_tile_load_stride_unaligned_kernel,
+        dim=(1, 1),
+        inputs=[input_array],
+        outputs=[output_array],
+        block_dim=TILE_DIM,
+        device=device,
+    )
+
+    input_np[DIM - 1, DIM - 1] = 0.0
+    assert_np_equal(output_array.numpy(), input_np)
+
+
 # ----------------------------------------------------------------------------------------
 
 TILE_SIZE = 4
@@ -388,6 +504,14 @@ add_function_test(TestTileLoad, "test_tile_load_2d", test_tile_load(tile_load_2d
 add_function_test(TestTileLoad, "test_tile_load_3d", test_tile_load(tile_load_3d_kernel, 3), devices=devices)
 add_function_test(TestTileLoad, "test_tile_load_4d", test_tile_load(tile_load_4d_kernel, 4), devices=devices)
 add_function_test(TestTileLoad, "test_tile_load_unaligned", test_tile_load_unaligned, devices=devices)
+add_function_test(TestTileLoad, "test_tile_load_aligned_small", test_tile_load_aligned_small, devices=devices)
+add_function_test(
+    TestTileLoad,
+    "test_tile_load_aligned_offset_unaligned_size",
+    test_tile_load_aligned_offset_unaligned_size,
+    devices=devices,
+)
+add_function_test(TestTileLoad, "test_tile_load_stride_unaligned", test_tile_load_stride_unaligned, devices=devices)
 
 add_function_test(TestTileLoad, "test_tile_extract_1d", test_tile_extract(tile_extract_1d_kernel, 1), devices=devices)
 add_function_test(TestTileLoad, "test_tile_extract_2d", test_tile_extract(tile_extract_2d_kernel, 2), devices=devices)

warp/tests/unittest_suites.py

@@ -116,8 +116,7 @@ def default_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader)
     from warp.tests.sim.test_collision import TestCollision
     from warp.tests.sim.test_coloring import TestColoring
     from warp.tests.sim.test_model import TestModel
-
-    # from warp.tests.test_sim_grad import TestSimGradients Disabled, flaky
+    from warp.tests.sim.test_sim_grad import TestSimGradients
     from warp.tests.sim.test_sim_kinematics import TestSimKinematics
     from warp.tests.sim.test_vbd import TestVbd
     from warp.tests.test_adam import TestAdam
@@ -281,7 +280,7 @@ def default_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader)
         TestRounding,
         TestRunlengthEncode,
         TestScalarOps,
-        # TestSimGradients, Disabled, flaky
+        TestSimGradients,
         TestSimKinematics,
         TestSmoothstep,
         TestSnippets,
@@ -357,7 +356,6 @@ def kit_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_rand import TestRand
-    from warp.tests.test_reload import TestReload
     from warp.tests.test_rounding import TestRounding
     from warp.tests.test_runlength_encode import TestRunlengthEncode
     from warp.tests.test_scalar_ops import TestScalarOps
@@ -407,7 +405,6 @@ def kit_suite(test_loader: unittest.TestLoader = unittest.defaultTestLoader):
         TestPeer,
         TestPinned,
         TestRand,
-        TestReload,
         TestRounding,
         TestRunlengthEncode,
         TestScalarOps,

warp/types.py

@@ -278,7 +278,12 @@ def vector(length, dtype):
         def __str__(self):
             return f"[{', '.join(map(str, self))}]"
 
+        def __repr__(self):
+            return f"{type_repr(self)}([{', '.join(map(repr, self))}])"
+
         def __eq__(self, other):
+            if self._length_ != len(other):
+                return False
             for i in range(self._length_):
                 if self[i] != other[i]:
                     return False
@@ -421,7 +426,11 @@ def matrix(shape, dtype):
             return "[" + ",\n ".join(row_str) + "]"
 
         def __eq__(self, other):
+            if self._shape_[0] != len(other):
+                return False
             for i in range(self._shape_[0]):
+                if self._shape_[1] != len(other[i]):
+                    return False
                 for j in range(self._shape_[1]):
                     if self[i][j] != other[i][j]:
                         return False
@@ -723,7 +732,7 @@ def transformation(dtype=Any):
                 super().__init__(*args)
                 return
 
-            # Even if the arguments match the original “from components”
+            # Even if the arguments match the original "from components"
             # signature, we still need to make sure that they represent
             # sequences that can be unpacked.
             if hasattr(p, "__len__") and hasattr(q, "__len__"):
@@ -1101,6 +1110,39 @@ def dtype_to_numpy(warp_dtype):
         raise TypeError(f"Cannot convert {warp_dtype} to a NumPy type")
 
 
+np_dtype_compatible_sets: dict[np.dtype, set[Any]] = {
+    np.dtype(np.bool_): {bool, int8, uint8},
+    np.dtype(np.int8): {int8, uint8},
+    np.dtype(np.uint8): {int8, uint8},
+    np.dtype(np.int16): {int16, uint16},
+    np.dtype(np.uint16): {int16, uint16},
+    np.dtype(np.int32): {int32, uint32},
+    np.dtype(np.int64): {int64, uint64},
+    np.dtype(np.uint32): {int32, uint32},
+    np.dtype(np.uint64): {int64, uint64},
+    np.dtype(np.byte): {bool, int8, uint8},
+    np.dtype(np.ubyte): {bool, int8, uint8},
+    np.dtype(np.float16): {float16},
+    np.dtype(np.float32): {float32},
+    np.dtype(np.float64): {float64},
+}
+
+
+def np_dtype_is_compatible(numpy_dtype: np.dtype, warp_dtype) -> builtins.bool:
+    """Evaluate whether the given NumPy dtype is compatible with the given Warp dtype."""
+
+    compatible_set: set[Any] | None = np_dtype_compatible_sets.get(numpy_dtype)
+
+    if compatible_set is not None:
+        if warp_dtype in compatible_set:
+            return True
+        # check if it's a vector or matrix type
+        if hasattr(warp_dtype, "_wp_scalar_type_"):
+            return warp_dtype._wp_scalar_type_ in compatible_set
+
+    return False
+
+
 # represent a Python range iterator
 class range_t:
     def __init__(self):
@@ -1339,22 +1381,67 @@ def type_typestr(dtype: type) -> str:
         raise Exception("Unknown ctype")
 
 
+def scalar_short_name(t):
+    if t == float32:
+        return "f"
+    elif t == float64:
+        return "d"
+    elif t == int8:
+        return "b"
+    elif t == int16:
+        return "s"
+    elif t == int32:
+        return "i"
+    elif t == int64:
+        return "l"
+    elif t == uint8:
+        return "ub"
+    elif t == uint16:
+        return "us"
+    elif t == uint32:
+        return "ui"
+    elif t == uint64:
+        return "ul"
+    return None
+
+
 # converts any known type to a human readable string, good for error messages, reporting etc
 def type_repr(t):
     if is_array(t):
-        return str(f"array(ndim={t.ndim}, dtype={t.dtype})")
+        if t.device is None:
+            # array is used as a type annotation - display ndim instead of shape
+            return f"array(ndim={t.ndim}, dtype={type_repr(t.dtype)})"
+        return f"array(shape={t.shape}, dtype={type_repr(t.dtype)})"
     if is_tile(t):
-        return str(f"tile(dtype={t.dtype}, shape={t.shape}")
-    if type_is_vector(t):
-        return str(f"vector(length={t._shape_[0]}, dtype={t._wp_scalar_type_})")
-    if type_is_matrix(t):
-        return str(f"matrix(shape=({t._shape_[0]}, {t._shape_[1]}), dtype={t._wp_scalar_type_})")
+        return f"tile(shape={t.shape}, dtype={type_repr(t.dtype)})"
     if isinstance(t, warp.codegen.Struct):
         return type_repr(t.cls)
+    sn = None
+    if hasattr(t, "_wp_scalar_type_"):
+        sn = scalar_short_name(t._wp_scalar_type_)
+    if type_is_transformation(t):
+        if sn is not None:
+            return f"transform{sn}"
+        return f"transform(dtype={type_repr(t._wp_scalar_type_)})"
+    if type_is_quaternion(t):
+        if sn is not None:
+            return f"quat{sn}"
+        return f"quat(dtype={type_repr(t._wp_scalar_type_)})"
+    if type_is_vector(t):
+        if sn is not None and t._shape_[0] <= 4:
+            return f"vec{t._shape_[0]}{sn}"
+        return f"vector(length={t._shape_[0]}, dtype={type_repr(t._wp_scalar_type_)})"
+    if type_is_matrix(t):
+        if sn is not None and t._shape_[0] <= 4 and t._shape_[1] <= 4:
+            return f"mat{t._shape_[0]}{t._shape_[1]}({sn})"
+        return f"matrix(shape=({t._shape_[0]}, {t._shape_[1]}), dtype={type_repr(t._wp_scalar_type_)})"
     if t in scalar_types:
         return t.__name__
 
-    name = getattr(t, "__qualname__", t.__name__)
+    name = getattr(t, "__name__", None)
+    if name is None:
+        return repr(t)
+    name = getattr(t, "__qualname__", name)
     return t.__module__ + "." + name
 
 
@@ -1418,7 +1505,7 @@ def is_array(a) -> builtins.bool:
     return isinstance(a, array_types)
 
 
-def scalars_equal(a, b, match_generic):
+def scalars_equal(a, b, match_generic=False):
     # convert to canonical types
     if a == float:
         a = float32
@@ -1809,6 +1896,14 @@ class array(Array[DType]):
 
             if dtype == Any:
                 dtype = np_dtype_to_warp_type[data_dtype]
+            else:
+                # Warn if the data type is compatible with the requested dtype
+                if not np_dtype_is_compatible(data_dtype, dtype):
+                    warp.utils.warn(
+                        f"The input data type {data_dtype} does not appear to be "
+                        f"compatible with the requested dtype {dtype}. If "
+                        "data-type sizes do not match, then this may lead to memory-access violations."
+                    )
 
             if data_strides is None:
                 data_strides = strides_from_shape(data_shape, dtype)
@@ -2235,6 +2330,9 @@ class array(Array[DType]):
         else:
             return str(self.numpy())
 
+    def __repr__(self):
+        return type_repr(self)
+
     def __getitem__(self, key):
         if isinstance(key, int):
             if self.ndim == 1:

{warp_lang-1.7.0.dist-info → warp_lang-1.7.2rc1.dist-info}/METADATA

@@ -1,12 +1,18 @@
 Metadata-Version: 2.4
 Name: warp-lang
-Version: 1.7.0
+Version: 1.7.2rc1
 Summary: A Python framework for high-performance simulation and graphics programming
 Author-email: NVIDIA Corporation <warp-python@nvidia.com>
 License: Apache-2.0
-Project-URL: GitHub, https://github.com/NVIDIA/warp
+Project-URL: Homepage, https://developer.nvidia.com/warp-python
 Project-URL: Documentation, https://nvidia.github.io/warp
+Project-URL: Repository, https://github.com/NVIDIA/warp
+Project-URL: Issues, https://github.com/NVIDIA/warp/issues
 Project-URL: Changelog, https://github.com/NVIDIA/warp/blob/main/CHANGELOG.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -14,15 +20,22 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Environment :: GPU :: NVIDIA CUDA :: 12
 Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: numpy
+Provides-Extra: docs
+Requires-Dist: nvidia-sphinx-theme; python_version >= "3.9" and extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: ruff==0.11.10; extra == "docs"
+Requires-Dist: myst_parser; extra == "docs"
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: ruff==0.11.10; extra == "dev"
 Requires-Dist: nvtx; extra == "dev"
 Requires-Dist: nvidia-sphinx-theme; python_version >= "3.9" and extra == "dev"
 Requires-Dist: sphinx-copybutton; extra == "dev"
@@ -52,7 +65,8 @@ and comes with a rich set of primitives that make it easy to write
 programs for physics simulation, perception, robotics, and geometry processing. In addition, Warp kernels
 are differentiable and can be used as part of machine-learning pipelines with frameworks such as PyTorch, JAX and Paddle.
 
-Please refer to the project [Documentation](https://nvidia.github.io/warp/) for API and language reference and [CHANGELOG.md](./CHANGELOG.md) for release history.
+Please refer to the project [Documentation](https://nvidia.github.io/warp/) for API and language reference and
+[CHANGELOG.md](https://github.com/NVIDIA/warp/blob/main/CHANGELOG.md) for release history.
 
 <div align="center">
     <img src="https://github.com/NVIDIA/warp/raw/main/docs/img/header.jpg">
@@ -82,9 +96,9 @@ the `pip install` command, e.g.
 
 | Platform        | Install Command                                                                                                               |
 | --------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| Linux aarch64   | `pip install https://github.com/NVIDIA/warp/releases/download/v1.7.0/warp_lang-1.7.0+cu11-py3-none-manylinux2014_aarch64.whl` |
-| Linux x86-64    | `pip install https://github.com/NVIDIA/warp/releases/download/v1.7.0/warp_lang-1.7.0+cu11-py3-none-manylinux2014_x86_64.whl`  |
-| Windows x86-64  | `pip install https://github.com/NVIDIA/warp/releases/download/v1.7.0/warp_lang-1.7.0+cu11-py3-none-win_amd64.whl`             |
+| Linux aarch64   | `pip install https://github.com/NVIDIA/warp/releases/download/v1.7.2/warp_lang-1.7.2+cu11-py3-none-manylinux2014_aarch64.whl` |
+| Linux x86-64    | `pip install https://github.com/NVIDIA/warp/releases/download/v1.7.2/warp_lang-1.7.2+cu11-py3-none-manylinux2014_x86_64.whl`  |
+| Windows x86-64  | `pip install https://github.com/NVIDIA/warp/releases/download/v1.7.2/warp_lang-1.7.2+cu11-py3-none-win_amd64.whl`             |
 
 The `--force-reinstall` option may need to be used to overwrite a previous installation.
 
@@ -491,26 +505,34 @@ Note that prior to 0.11.0, this schema was not strictly adhered to.
 
 ## License
 
-Warp is provided under the Apache License, Version 2.0. Please see [LICENSE.md](./LICENSE.md) for full license text.
+Warp is provided under the Apache License, Version 2.0.
+Please see [LICENSE.md](https://github.com/NVIDIA/warp/blob/main/LICENSE.md) for full license text.
 
 ## Contributing
 
-Contributions and pull requests from the community are welcome and are taken under the
-terms described in the **Feedback** section of [LICENSE.md](LICENSE.md#9-feedback).
+Contributions and pull requests from the community are welcome.
 Please see the [Contribution Guide](https://nvidia.github.io/warp/modules/contribution_guide.html) for more
 information on contributing to the development of Warp.
 
-## Citing
+## Publications & Citation
 
-If you use Warp in your research, please use the following citation:
+### Research Using Warp
+
+Our [PUBLICATIONS.md](https://github.com/NVIDIA/warp/blob/main/PUBLICATIONS.md) file lists academic and research
+publications that leverage the capabilities of Warp.
+We encourage you to add your own published work using Warp to this list.
+
+### Citing Warp
+
+To cite Warp itself in your own publications, please use the following BibTeX entry:
 
 ```bibtex
 @misc{warp2022,
-title= {Warp: A High-performance Python Framework for GPU Simulation and Graphics},
-author = {Miles Macklin},
-month = {March},
-year = {2022},
-note= {NVIDIA GPU Technology Conference (GTC)},
-howpublished = {\url{https://github.com/nvidia/warp}}
+  title        = {Warp: A High-performance Python Framework for GPU Simulation and Graphics},
+  author       = {Miles Macklin},
+  month        = {March},
+  year         = {2022},
+  note         = {NVIDIA GPU Technology Conference (GTC)},
+  howpublished = {\url{https://github.com/nvidia/warp}}
 }
 ```