Rename ArrayConstraint.stride_static to stride_constant

Signed-off-by: Greg Bonik <gbonik@nvidia.com>

Author: gbonik

cext/tile_kernel.cpp

@@ -699,8 +699,8 @@ static PyPtr parse_array_constraint(ConstantCursor& cursor) {
     PyPtr dtype = dtype_to_python(arrty.dtype);
     if (!dtype) return {};
 
-    PyPtr static_strides = steal(PyTuple_New(arrty.ndim));
-    if (!static_strides) return {};
+    PyPtr constant_strides = steal(PyTuple_New(arrty.ndim));
+    if (!constant_strides) return {};
 
     PyPtr stride_divisible_by = steal(PyTuple_New(arrty.ndim));
     if (!stride_divisible_by) return {};
@@ -726,7 +726,7 @@ static PyPtr parse_array_constraint(ConstantCursor& cursor) {
 
     for (size_t i = 0; i < arrty.ndim; ++i) {
         PyObject* obj = special_bits.is_stride_one(i) ? one.get() : Py_None;
-        PyTuple_SET_ITEM(static_strides.get(), i, Py_NewRef(obj));
+        PyTuple_SET_ITEM(constant_strides.get(), i, Py_NewRef(obj));
 
         obj = special_bits.is_stride_16byte_divisible(i) ? stride_divisor.get() : one.get();
         PyTuple_SET_ITEM(stride_divisible_by.get(), i, Py_NewRef(obj));
@@ -739,7 +739,7 @@ static PyPtr parse_array_constraint(ConstantCursor& cursor) {
             "{sO sI sO sO s() sO sO sO sO}",
             "dtype", dtype.get(),
             "ndim", static_cast<unsigned>(arrty.ndim),
-            "stride_static", static_strides.get(),
+            "stride_constant", constant_strides.get(),
             "stride_lower_bound_incl", zero.get(),
             "alias_groups",
             "may_alias_internally", special_bits.disjoint_elements ? Py_False : Py_True,

src/cuda/tile/_compile.py

@@ -151,7 +151,7 @@ def _create_kernel_parameters(parameter_constraints: Sequence[ParameterConstrain
 
 
 def _get_array_ty(param: ArrayConstraint):
-    for static_stride, bound in zip(param.stride_static, param.stride_lower_bound_incl,
+    for static_stride, bound in zip(param.stride_constant, param.stride_lower_bound_incl,
                                     strict=True):
         if static_stride is not None:
             continue
@@ -161,7 +161,7 @@ def _get_array_ty(param: ArrayConstraint):
 
     return ArrayTy(param.dtype,
                    shape=(None,) * param.ndim,
-                   strides=param.stride_static,
+                   strides=param.stride_constant,
                    elements_disjoint=not param.may_alias_internally,
                    base_ptr_div_by=param.base_addr_divisible_by,
                    stride_div_by=param.stride_divisible_by,

src/cuda/tile/compilation/_name_mangling.py

@@ -188,7 +188,7 @@ def _mangle_array_constraint(a: ArrayConstraint,
 
     axis_predicates = OrderedDict()
     _collect_axis_predicate(a.shape_divisible_by, "i", 1, axis_predicates)
-    _collect_axis_predicate(a.stride_static, "t", None, axis_predicates)
+    _collect_axis_predicate(a.stride_constant, "t", None, axis_predicates)
     _collect_axis_predicate(a.stride_divisible_by, "v", 1, axis_predicates)
     _collect_axis_predicate(a.stride_lower_bound_incl, "l", None, axis_predicates)
 
@@ -221,7 +221,7 @@ def _demangle_array_constraint(cursor: _Cursor,
 
     # Read axis predicates
     shape_divisible_by = [1] * ndim
-    stride_static = [None] * ndim
+    stride_constant = [None] * ndim
     stride_divisible_by = [1] * ndim
     stride_lower_bound_incl = [None] * ndim
     while True:
@@ -241,9 +241,9 @@ def _demangle_array_constraint(cursor: _Cursor,
         if cursor.read("i") is not None:
             axis_shape_div_by = _demangle_divisibility(cursor)
 
-        axis_stride_static = None
+        axis_stride_constant = None
         if cursor.read("t") is not None:
-            axis_stride_static = _demangle_signed_int(cursor)
+            axis_stride_constant = _demangle_signed_int(cursor)
 
         axis_stride_div_by = 1
         if cursor.read("v") is not None:
@@ -262,11 +262,11 @@ def _demangle_array_constraint(cursor: _Cursor,
                         f"Shape divisibility specified more than once for axis #{i}")
                 shape_divisible_by[i] = axis_shape_div_by
 
-            if axis_stride_static is not None:
-                if stride_static[i] is not None:
+            if axis_stride_constant is not None:
+                if stride_constant[i] is not None:
                     raise mask_cursor.make_error(
                         f"Static stride specified more than once for axis #{i}")
-                stride_static[i] = axis_stride_static
+                stride_constant[i] = axis_stride_constant
 
             if axis_stride_div_by != 1:
                 if stride_divisible_by[i] != 1:
@@ -283,7 +283,7 @@ def _demangle_array_constraint(cursor: _Cursor,
             axis_mask &= ~(1 << i)
 
     for i in range(ndim):
-        if stride_static[i] is not None:
+        if stride_constant[i] is not None:
             if stride_divisible_by[i] != 1:
                 raise orig_cursor.make_error(f"Stride divisibility specified together"
                                              f" with static stride for axis {i}")
@@ -309,7 +309,7 @@ def _demangle_array_constraint(cursor: _Cursor,
                            stride_lower_bound_incl=stride_lower_bound_incl,
                            alias_groups=alias_groups,
                            may_alias_internally=may_alias_internally,
-                           stride_static=stride_static,
+                           stride_constant=stride_constant,
                            stride_divisible_by=stride_divisible_by,
                            shape_divisible_by=shape_divisible_by,
                            base_addr_divisible_by=base_addr_div_by)

src/cuda/tile/compilation/_signature.py

@@ -55,8 +55,8 @@ class ArrayConstraint:
             array has a zero stride. For most arrays produced by major tensor libraries,
             this can be assumed to be false. Setting this to True may disable certain
             optimizations of loads and stores to/from this array.
-        stride_static (Sequence[int | None] | None):
-            For each dimension of the array, an optional statically known value of its stride.
+        stride_constant (Sequence[int | None] | None):
+            For each dimension of the array, an optional constant value of its stride.
             For example, if the array is known to have a C-contiguous layout, the stride of
             the last dimension can be set to 1, which may enable certain optimizations of loads
             and stores from/to this array. Can be set to `None` if none of the dimensions
@@ -84,7 +84,7 @@ class ArrayConstraint:
     stride_lower_bound_incl: tuple[int | None, ...]
     alias_groups: tuple[str, ...]
     may_alias_internally: bool
-    stride_static: tuple[int | None, ...]
+    stride_constant: tuple[int | None, ...]
     stride_divisible_by: tuple[int, ...]
     shape_divisible_by: tuple[int, ...]
     base_addr_divisible_by: int
@@ -96,7 +96,7 @@ def __init__(self,
                  stride_lower_bound_incl: Sequence[int | None] | int | None,
                  alias_groups: Sequence[str],
                  may_alias_internally: bool,
-                 stride_static: Sequence[int | None] | None = None,
+                 stride_constant: Sequence[int | None] | None = None,
                  stride_divisible_by: Sequence[int] | int = 1,
                  shape_divisible_by: Sequence[int] | int = 1,
                  base_addr_divisible_by: int = 1):
@@ -110,21 +110,21 @@ def __init__(self,
         if ndim < 0:
             raise ValueError("`ndim` cannot be negative")
 
-        # stride_static
-        stride_static = _parse_assumption_tuple(
-                stride_static, ndim, "stride_static", None, _check_optional_int)
+        # stride_constant
+        stride_constant = _parse_assumption_tuple(
+                stride_constant, ndim, "stride_constant", None, _check_optional_int)
 
         # stride_lower_bound
         stride_lower_bound_incl = _parse_assumption_tuple(
             stride_lower_bound_incl, ndim, "stride_lower_bound_incl", None, _check_optional_int)
         stride_lower_bound_incl = _remove_redundant_lower_bounds(
-            stride_static, stride_lower_bound_incl, "stride_lower_bound_incl")
+            stride_constant, stride_lower_bound_incl, "stride_lower_bound_incl")
 
         # stride_divisible_by
         stride_divisible_by = _parse_assumption_tuple(
                 stride_divisible_by, ndim, "stride_divisible_by", 1, _check_divisibility)
         stride_divisible_by = _remove_redundant_divisibility_constraints(
-                stride_static, stride_divisible_by, "stride_static")
+                stride_constant, stride_divisible_by, "stride_constant")
 
         # shape_divisible_by
         shape_divisible_by = _parse_assumption_tuple(

test/test_export_compat.py

@@ -105,7 +105,7 @@ def test_export_compat_cutile_python_v1():
             ct.compilation.ArrayConstraint(ct.int32, 2, stride_lower_bound_incl=0,
                                            alias_groups=(), may_alias_internally=False,
                                            stride_divisible_by=(4, 1),
-                                           stride_static=(None, 1)),
+                                           stride_constant=(None, 1)),
             ct.compilation.ArrayConstraint(ct.float32, 3, stride_lower_bound_incl=0,
                                            alias_groups=(), may_alias_internally=False),
         ],

test/test_name_mangling.py

@@ -47,15 +47,15 @@
         id="array_simple",
     ),
 
-    # 3D array with stride_static, stride_divisible_by, shape_divisible_by
+    # 3D array with stride_constant, stride_divisible_by, shape_divisible_by
     # (dims 0 and 1 share shape_divisible_by=16), stride_lower_bound_incl,
     # and base_addr_divisible_by
     pytest.param(
         [ArrayConstraint(float32, 3,
                          stride_lower_bound_incl=0,
                          alias_groups=(),
                          may_alias_internally=False,
-                         stride_static=[None, None, 1],
+                         stride_constant=[None, None, 1],
                          stride_divisible_by=[8, 1, 1],
                          shape_divisible_by=[16, 16, 1],
                          base_addr_divisible_by=16)],