Rename load/store_advanced to load/store_advanced_indexing

Signed-off-by: Qiqi Xiao <qiqix@nvidia.com>

Author: xiaoqiqi177

changelog.d/load-store-advanced.md

@@ -1,4 +1,4 @@
 <!--- SPDX-FileCopyrightText: Copyright (c) <2026> NVIDIA CORPORATION & AFFILIATES. All rights reserved. -->
 <!--- SPDX-License-Identifier: Apache-2.0 -->
 
-- New `ct.load_advanced(array, indices)` and `ct.store_advanced(array, indices, tile)` for gathering/scattering along one dimension from/to a 2D or higher-rank array. A 1D integer `Tile` selects the sparse dimension; `ct.Slice(start, length)` selects a contiguous range along each dense dimension.
+- New `ct.load_advanced_indexing(array, indices)` and `ct.store_advanced_indexing(array, indices, tile)` for gathering/scattering along one dimension from/to a 2D or higher-rank array. A 1D integer `Tile` selects the sparse dimension; `ct.Slice(start, length)` selects a contiguous range along each dense dimension.

docs/source/operations.rst

@@ -22,8 +22,8 @@ Load/Store
    num_tiles
    load
    store
-   load_advanced
-   store_advanced
+   load_advanced_indexing
+   store_advanced_indexing
    gather
    scatter
 

src/cuda/tile/__init__.py

@@ -115,7 +115,7 @@
     less,
     less_equal,
     load,
-    load_advanced,
+    load_advanced_indexing,
     log,
     log2,
     matmul,
@@ -150,7 +150,7 @@
     static_eval,
     static_iter,
     store,
-    store_advanced,
+    store_advanced_indexing,
     sub,
     sum,
     tan,
@@ -276,7 +276,7 @@
     "less",
     "less_equal",
     "load",
-    "load_advanced",
+    "load_advanced_indexing",
     "log",
     "log2",
     "matmul",
@@ -311,7 +311,7 @@
     "static_eval",
     "static_iter",
     "store",
-    "store_advanced",
+    "store_advanced_indexing",
     "sub",
     "sum",
     "tan",

src/cuda/tile/_ir/ops.py

@@ -4875,7 +4875,7 @@ def _parse_advanced_index(indices: Var, ndim: int) -> tuple[int, tuple[int, ...]
     items = list(indices.get_aggregate().items)
     if len(items) != ndim:
         raise TileTypeError(
-            f"load_advanced/store_advanced index length {len(items)} does not "
+            f"load_advanced_indexing/store_advanced_indexing index length {len(items)} does not "
             f"match array rank {ndim}")
 
     sparse_dims: list[int] = []
@@ -4901,7 +4901,7 @@ def _parse_advanced_index(indices: Var, ndim: int) -> tuple[int, tuple[int, ...]
             if not length_var.is_constant():
                 raise TileTypeError(
                     f"ct.Slice length at dim {dim} must be a compile-time constant "
-                    f"in load_advanced/store_advanced")
+                    f"in load_advanced_indexing/store_advanced_indexing")
             length_val = length_var.get_constant()
             if not isinstance(length_val, int) or length_val <= 0:
                 raise TileTypeError(
@@ -4910,17 +4910,17 @@ def _parse_advanced_index(indices: Var, ndim: int) -> tuple[int, tuple[int, ...]
             gs_index.append(item.get_aggregate().start)
         else:
             raise TileTypeError(
-                f"load_advanced/store_advanced index at dim {dim} must be a "
+                f"load_advanced_indexing/store_advanced_indexing index at dim {dim} must be a "
                 f"1D integer Tile (sparse dim) or ct.Slice(start, length) "
                 f"(dense dim), got type {item_ty}")
 
     if len(sparse_dims) == 0:
         raise TileTypeError(
-            "load_advanced/store_advanced: exactly one index must be a 1D "
+            "load_advanced_indexing/store_advanced_indexing: exactly one index must be a 1D "
             "integer Tile (the sparse dim); none found")
     if len(sparse_dims) > 1:
         raise TileTypeError(
-            f"load_advanced/store_advanced: exactly one index must be a 1D "
+            f"load_advanced_indexing/store_advanced_indexing: exactly one index must be a 1D "
             f"integer Tile (the sparse dim); found {len(sparse_dims)} at "
             f"dims {sparse_dims}")
 
@@ -4932,13 +4932,13 @@ def _parse_advanced_index(indices: Var, ndim: int) -> tuple[int, tuple[int, ...]
     return sparse_dims[0], tuple(tile_shape), tuple(gs_index)
 
 
-@impl(ct.load_advanced, min_version=BytecodeVersion.V_13_3)
+@impl(ct.load_advanced_indexing, min_version=BytecodeVersion.V_13_3)
 def load_advanced_impl(array: Var, indices: Var, padding_mode: Var,
                        latency: Var, allow_tma: Var) -> Var:
     array_ty = require_array_type(array)
     if array_ty.ndim < 2:
         raise TileTypeError(
-            "load_advanced requires a 2D or higher-rank array; "
+            "load_advanced_indexing requires a 2D or higher-rank array; "
             "use ct.gather() for 1D arrays")
     sparse_dim, tile_shape, gs_index = _parse_advanced_index(indices, array_ty.ndim)
     padding_mode_val = require_constant_enum(padding_mode, PaddingMode)
@@ -4953,13 +4953,13 @@ def load_advanced_impl(array: Var, indices: Var, padding_mode: Var,
     return result
 
 
-@impl(ct.store_advanced, min_version=BytecodeVersion.V_13_3)
+@impl(ct.store_advanced_indexing, min_version=BytecodeVersion.V_13_3)
 def store_advanced_impl(array: Var, indices: Var, tile: Var,
                         latency: Var, allow_tma: Var):
     array_ty = require_array_type(array)
     if array_ty.ndim < 2:
         raise TileTypeError(
-            "store_advanced requires a 2D or higher-rank array; "
+            "store_advanced_indexing requires a 2D or higher-rank array; "
             "use ct.scatter() for 1D arrays")
     sparse_dim, tile_shape, gs_index = _parse_advanced_index(indices, array_ty.ndim)
     tile_ty = require_tile_type(tile)

src/cuda/tile/_stub.py

@@ -948,11 +948,11 @@ class Slice:
     _cutile_is_builtin = True
     """A start + length index for array dimensions.
 
-    Used as a dense-dimension entry in :func:`load_advanced` and
-    :func:`store_advanced`.  ``start`` is an integer giving the
+    Used as a dense-dimension entry in :func:`load_advanced_indexing` and
+    :func:`store_advanced_indexing`.  ``start`` is an integer giving the
     element-space start offset along this dimension; ``length`` is the
     tile size, and must be a power of two and must be a
-    compile-time constant at the :func:`load_advanced`/:func:`store_advanced`
+    compile-time constant at the :func:`load_advanced_indexing`/:func:`store_advanced_indexing`
     call site.
 
     Args:
@@ -1414,10 +1414,10 @@ def kernel(x):
 
 
 @stub
-def load_advanced(array: Array, indices, /, *,
-                  padding_mode: PaddingMode = PaddingMode.UNDETERMINED,
-                  latency: Optional[int] = None,
-                  allow_tma: Optional[bool] = None) -> Tile:
+def load_advanced_indexing(array: Array, indices, /, *,
+                           padding_mode: PaddingMode = PaddingMode.UNDETERMINED,
+                           latency: Optional[int] = None,
+                           allow_tma: Optional[bool] = None) -> Tile:
     """Loads a tile from non-contiguous slices of `array`.
 
     ``indices`` is a tuple of length ``array.ndim``.  Exactly one entry must
@@ -1458,7 +1458,7 @@ def load_advanced(array: Array, indices, /, *,
             @ct.kernel
             def kernel(x, y, col_start):
                 row_indices = ct.arange(4, dtype=ct.int32)
-                tile = ct.load_advanced(x, (row_indices, ct.Slice(col_start, 4)),
+                tile = ct.load_advanced_indexing(x, (row_indices, ct.Slice(col_start, 4)),
                                         padding_mode=ct.PaddingMode.ZERO)
                 ct.store(y, (0, 0), tile)
 
@@ -1472,17 +1472,17 @@ def kernel(x, y, col_start):
             [[2, 3, 4, 5], [10, 11, 12, 13], [18, 19, 20, 21], [26, 27, 28, 29]]
 
     .. seealso::
-        - :func:`store_advanced`
+        - :func:`store_advanced_indexing`
     """
 
 
 @stub
-def store_advanced(array: Array, indices, tile: TileOrScalar, /, *,
-                   latency: Optional[int] = None,
-                   allow_tma: Optional[bool] = None) -> None:
+def store_advanced_indexing(array: Array, indices, tile: TileOrScalar, /, *,
+                            latency: Optional[int] = None,
+                            allow_tma: Optional[bool] = None) -> None:
     """Stores a `tile` into non-contiguous slices of `array`.
 
-    Uses the same ``indices`` convention as :func:`load_advanced` — exactly
+    Uses the same ``indices`` convention as :func:`load_advanced_indexing` — exactly
     one entry is a 1-D integer :class:`Tile` (sparse dim) and the rest are
     :class:`Slice` objects (dense dims).
     The tile's shape must exactly match the shape implied by the indices.
@@ -1491,7 +1491,7 @@ def store_advanced(array: Array, indices, tile: TileOrScalar, /, *,
 
     Args:
         array (Array): Array to store into.
-        indices (tuple): Same convention as :func:`load_advanced`.
+        indices (tuple): Same convention as :func:`load_advanced_indexing`.
         tile (Tile): Tile to store. Shape must exactly match the shape
             implied by ``indices``.
         latency (int, optional): DRAM traffic hint (1 = low, 10 = high).
@@ -1506,7 +1506,7 @@ def store_advanced(array: Array, indices, tile: TileOrScalar, /, *,
             def kernel(y):
                 row_indices = ct.arange(4, dtype=ct.int32) + 1
                 tile = ct.full((4, 4), 1, dtype=y.dtype)
-                ct.store_advanced(y, (row_indices, ct.Slice(0, 4)), tile)
+                ct.store_advanced_indexing(y, (row_indices, ct.Slice(0, 4)), tile)
 
             y = torch.zeros(6, 4, device='cuda', dtype=torch.int32)
             ct.launch(stream, (1,), kernel, (y,))
@@ -1517,7 +1517,7 @@ def kernel(y):
             [[0, 0, 0, 0], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [0, 0, 0, 0]]
 
     .. seealso::
-        - :func:`load_advanced`
+        - :func:`load_advanced_indexing`
     """