Update docs

Author: haijieg

cext/tile_kernel.cpp

@@ -1728,7 +1728,12 @@ static PyMethodDef functions[] = {
     {"launch", reinterpret_cast<PyCFunction>(cuda_tile_launch), METH_FASTCALL,
         LAUNCH_SIGNATURE "\n"
         "--\n\n"
-        "Launch a cuTile kernel."
+        "Launch a cuTile kernel.\n\n"
+        "Args:\n"
+        "   stream: The CUDA stream to execute the |kernel| on.\n"
+        "   grid: Tuple of up to 3 grid dimensions to execute the |kernel| over.\n"
+        "   kernel: The |kernel| to execute.\n"
+        "   kernel_args: Positional arguments to pass to the kernel.\n"
     },
     NULL
 };

docs/source/data.rst

@@ -139,16 +139,16 @@ to a common dtype using the following process:
 Scalars
 -------
 
-A *scalar* is a single immutable value of a specific |data type|.
+A *scalar* is a single immutable value of a specific |data type|. A *scalar* and *0D-tile*
+can be used interchangably in a tile |kernel|. They can also be |kernel| parameters.
 
-|Scalars| can be used in |host code| and |tile code|.
-They can be |kernel| parameters.
+Typing of a *scalar* has the following rules:
 
-.. toctree::
-   :maxdepth: 2
-   :hidden:
-
-   data/scalar
+- Constant scalars are |loosely typed| by default, for example, a literal ``2`` or
+  a constant property like ``Tile.ndim``, ``Tile.shape``, or ``Array.ndim``.
+- ``Array.shape`` and ``Array.stride`` are not constant by default and has default int type `int32`.
+  Using default `int32` makes kernel more performant at the cost of limiting max representable shape.
+  This limitation will be lifted in the near future.
 
 Tuples
 ------

docs/source/data/scalar.rst

@@ -28,9 +28,3 @@ This includes:
 - Passing the same kinds of arrays to both tile and SIMT kernels.
 
 Inter-kernel interoperability shall be supported.
-
-Hybrid Kernels
-~~~~~~~~~~~~~~
-
-Hybrid kernels refer to kernels that contain both |tile code| and |SIMT code|.
-Hybrid kernels are not yet supported.

docs/source/interoperability.rst

@@ -16,11 +16,11 @@ Prerequisites
 
 cuTile Python requires the following:   
 
+    - Linux x86_64, Linux aarch64 or Windows x86_64
     - A GPU with compute capability 10.x or 12.x
     - NVIDIA Driver r580 or later
     - CUDA Toolkit 13.1 or later
-    - The `PATH` environment variable must contain the path to the `bin/` directory of the CUDA Toolkit
-    - Python version 3.10 or higher
+    - Python version 3.10, 3.11, 3.12 or 3.13
 
 
 Installing cuTile Python
@@ -47,9 +47,9 @@ The quickstart sample on this page uses cupy, which can be installed with:
 
 The cuTile Python samples in the ``samples/`` directory also use pytest, torch, and numpy packages.
 
-For torch installation instructions, see `<https://pytorch.org/get-started/locally/>`__. 
+For PyTorch installation instructions, see `<https://pytorch.org/get-started/locally/>`__.
 
-Pytest and numpy can be installed with:
+Pytest and Numpy can be installed with:
 
 .. code-block::  bash
 
@@ -68,7 +68,7 @@ This example shows a structure common to cuTile kernels:
 * Write the resulting tile(s) out to GPU memory
 
 In this case, the kernel loads tiles from two vectors, ``a`` and ``b``. These loads create tiles called ``a_tile`` and ``b_tile``. These tiles are added together to form a third tile, called ``result``. In the last step, the kernel stores the ``result`` tile to the output vector ``c``.
-This code can be found in the cuTile Python repository at ``samples/quickstart/VectorAdd_quickstart.py``.
+More samples can be found in the cuTile Python `repository <https://github.com/nvidia/cutile-python>`_.
 
 .. literalinclude:: ../../samples/quickstart/VectorAdd_quickstart.py
    :language: python

docs/source/quickstart.rst

@@ -47,6 +47,7 @@
 .. |constant embedded| replace:: :ref:`constant embedded <execution:Constant Embedding>`
 .. |Constant embedded| replace:: :ref:`Constant embedded <execution:Constant Embedding>`
 
+.. |loosely typed| replace:: :ref:`loosely typed <execution:Constant Expressions & Objects>`
 .. |loosely typed numeric constant| replace:: :ref:`loosely typed numeric constant <execution:Constant Expressions & Objects>`
 .. |loosely typed numeric constants| replace:: :ref:`loosely typed numeric constants <execution:Constant Expressions & Objects>`
 
@@ -101,10 +102,10 @@
 .. |tile spaces| replace:: :ref:`tile spaces <data:Element & Tile Space>`
 .. |Tile spaces| replace:: :ref:`Tile spaces <data:Element & Tile Space>`
 
-.. |scalar| replace:: :ref:`scalar <data/scalar:cuda.tile.Scalar>`
-.. |Scalar| replace:: :ref:`Scalar <data/scalar:cuda.tile.Scalar>`
-.. |scalars| replace:: :ref:`scalars <data/scalar:cuda.tile.Scalar>`
-.. |Scalars| replace:: :ref:`Scalars <data/scalar:cuda.tile.Scalar>`
+.. |scalar| replace:: :ref:`scalar <data:Scalars>`
+.. |Scalar| replace:: :ref:`Scalar <data:Scalars>`
+.. |scalars| replace:: :ref:`scalars <data:Scalars>`
+.. |Scalars| replace:: :ref:`Scalars <data:Scalars>`
 
 .. |Rounding Modes| replace:: :ref:`Rounding Modes <data:Rounding Modes>`
 .. |Padding Modes| replace:: :ref:`Padding Modes <data:Padding Modes>`

docs/source/references.rst

@@ -7,8 +7,6 @@
 Shows how to perform elementwise operations on vectors.
 """
 
-from math import ceil
-
 import cupy as cp
 import numpy as np
 import cuda.tile as ct
@@ -34,7 +32,7 @@ def test():
     # Create input data
     vector_size = 2**12
     tile_size = 2**4
-    grid = (ceil(vector_size / tile_size), 1, 1)
+    grid = (ct.cdiv(vector_size, tile_size), 1, 1)
 
     a = cp.random.uniform(-1, 1, vector_size)
     b = cp.random.uniform(-1, 1, vector_size)

samples/quickstart/VectorAdd_quickstart.py

@@ -11,15 +11,7 @@ def launch(stream,
            kernel,
            kernel_args: tuple[Any, ...],
            /):
-    """
-    Queue a |kernel| for execution over |grid| on a particular stream.
-
-    Args:
-        stream: The CUDA stream to execute the |kernel| on.
-        grid: Tuple of up to 3 grid dimensions to execute the |kernel| over.
-        kernel: The |kernel| to execute.
-        kernel_args: Positional arguments to pass to the kernel.
-    """
+    ...
 
 
 class TileDispatcher:

src/cuda/tile/_cext.pyi

@@ -1564,6 +1564,7 @@ def getattr_impl(object: Var, name: Var) -> Var:
         case ArrayTy(), "dtype": return loosely_typed_const(ty.dtype)
         case ArrayTy(), "ndim": return loosely_typed_const(ty.ndim)
         case ArrayTy(), "shape": return get_array_shape(object)
+        case ArrayTy(), "strides": return get_array_strides(object)
 
         case TileTy(), "dtype": return loosely_typed_const(ty.dtype)
         case TileTy(), "shape": return loosely_typed_const(ty.shape_value)

src/cuda/tile/_ir/ops.py

@@ -148,27 +148,38 @@ class Array:
     @property
     @function
     def dtype(self) -> "DType":
-        """The |data type| of the |array|'s elements."""
+        """The |data type| of the |array|'s elements.
+
+        Returns:
+            DType (constant):
+        """
 
     @property
     @function
     def shape(self) -> tuple[int, ...]:
-        """The number of elements in each of the |array|'s dimensions."""
+        """The number of elements in each of the |array|'s dimensions.
+
+        Returns:
+            tuple[int32,...]:
+        """
 
     @property
     @function
     def strides(self) -> tuple[int, ...]:
-        """The number of elements to step in each dimension while traversing the |array|."""
+        """The number of elements to step in each dimension while traversing the |array|.
 
-    @property
-    @function
-    def size(self) -> int:
-        """The number of elements in the |array|."""
+        Returns:
+            tuple[int32,...]:
+        """
 
     @property
     @function
     def ndim(self) -> int:
-        """The number of dimensions in the |array|."""
+        """The number of dimensions in the |array|.
+
+        Returns:
+            int (constant):
+        """
 
 
 class Tile:
@@ -188,35 +199,37 @@ class Tile:
     @property
     @function
     def dtype(self) -> "DType":
-        """The |data type| of the |tile|'s elements."""
+        """The |data type| of the |tile|'s elements.
 
-    @property
-    @function
-    def shape(self) -> tuple[int, ...]:
-        """The number of elements in each of the |tile|'s dimensions."""
+        Returns:
+            DType (constant):
+        """
 
     @property
     @function
-    def strides(self) -> tuple[int, ...]:
-        """The number of elements to step in each dimension while traversing the |tile|."""
+    def shape(self) -> tuple[int, ...]:
+        """The number of elements in each of the |tile|'s dimensions.
 
-    @property
-    @function
-    def size(self) -> int:
-        """The number of elements in the |tile|."""
+        Returns:
+            tuple[const int,...]:
+        """
 
     @property
     @function
     def ndim(self) -> int:
-        """The number of dimensions in the |tile|."""
+        """The number of dimensions in the |tile|.
+
+        Returns:
+            int (constant):
+        """
 
     @function
-    def item(self) -> "Scalar":
-        """Extract scalar from a single element tile.
+    def item(self) -> "Tile":
+        """Extract scalar (0D Tile) from a single element tile.
         Tile must contain only 1 element.
 
         Returns:
-            Scalar:
+            Tile: A 0D Tile usable as a scalar.
 
         Examples:
 
@@ -441,6 +454,9 @@ def num_tiles(array: Array, /,
         shape (const int...): A sequence of const integers definining the shape of the tile.
         order ("C" or "F", or tuple[const int,...]): Order of axis mapping. See :py:func:`load`.
 
+    Returns:
+        int32
+
     Examples:
 
         Suppose array size is (32, 16), tile shape (4, 8),