This is an automated email from the ASF dual-hosted git repository.
tqchen pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tvm-tirx.git
The following commit(s) were added to refs/heads/main by this push:
new bf804cbf8 [DOCS] Polish Quick Start and landing page; bump to 0.1.0a5
(#112)
bf804cbf8 is described below
commit bf804cbf8fa44ad97257b8613d0f477efa1bcc8e
Author: Tianqi Chen <[email protected]>
AuthorDate: Wed Oct 28 11:57:50 2026 -0400
[DOCS] Polish Quick Start and landing page; bump to 0.1.0a5 (#112)
---
CMakeLists.txt | 2 +-
ci/wheel/tvm-tirx-llvm-targets/pyproject.toml | 4 +-
cmake/tvm_tirx-config.cmake | 19 +-
docs/conf.py | 1 +
docs/get_started/quick_start.rst | 320 ++++++++++++++++++---
docs/index.rst | 18 +-
docs/ir/functions_and_modules.rst | 2 +-
docs/ir/operators_and_calls.rst | 2 +-
docs/ir/printing_and_parsing.rst | 4 +-
docs/ir/statements.rst | 6 +-
docs/ir/types_and_expressions.rst | 8 +-
examples/quick_start/CMakeLists.txt | 49 ++++
examples/quick_start/README.md | 75 +++++
.../quick_start}/add_one_cpu.py | 13 +-
.../quick_start}/add_one_cuda.py | 17 +-
.../quick_start/inspect_and_transform.py | 29 +-
.../quick_start/load_add_one_cpu.py | 28 +-
.../quick_start/load_add_one_cuda.py | 30 +-
examples/quick_start/load_cpp.cc | 55 ++++
examples/quick_start/run_all_cpu.bat | 31 ++
.../quick_start/run_all_cpu.sh | 33 +--
.../quick_start/run_all_cuda.sh | 29 +-
include/tvm/runtime/base.h | 2 +-
pyproject.toml | 4 +-
python/tvm_tirx/libinfo.py | 2 +-
25 files changed, 612 insertions(+), 171 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cb664d142..ac80edcc1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,7 +32,7 @@ endfunction()
# ######### Common options ##########
-set(TVM_TIRX_VERSION "0.1.0a4")
+set(TVM_TIRX_VERSION "0.1.0a5")
if(PROJECT_IS_TOP_LEVEL)
tvm_tirx_option(TVM_TIRX_BUILD_TESTS BOOL OFF "Build C++ tests")
tvm_tirx_option(TVM_TIRX_BUILD_PYTHON_MODULE BOOL OFF "Build the Python
package with scikit-build-core")
diff --git a/ci/wheel/tvm-tirx-llvm-targets/pyproject.toml
b/ci/wheel/tvm-tirx-llvm-targets/pyproject.toml
index a53fbc4bb..40f74a933 100644
--- a/ci/wheel/tvm-tirx-llvm-targets/pyproject.toml
+++ b/ci/wheel/tvm-tirx-llvm-targets/pyproject.toml
@@ -16,11 +16,11 @@
# under the License.
[project]
name = "apache-tvm-tirx-llvm-targets"
-version = "0.1.0a4"
+version = "0.1.0a5"
description = "Additional LLVM code generation targets for TVM TIRx"
license = "Apache-2.0"
requires-python = ">=3.10"
-dependencies = ["apache-tvm-tirx==0.1.0a4"]
+dependencies = ["apache-tvm-tirx==0.1.0a5"]
[build-system]
requires = [
diff --git a/cmake/tvm_tirx-config.cmake b/cmake/tvm_tirx-config.cmake
index 118342b0e..24d699902 100644
--- a/cmake/tvm_tirx-config.cmake
+++ b/cmake/tvm_tirx-config.cmake
@@ -18,12 +18,21 @@
include(CMakeFindDependencyMacro)
find_dependency(Python 3.10 COMPONENTS Interpreter)
-# Query this installation's helper, independently of any other Python wheel.
-# Passing the exact library directory also supports lib64 and multiarch
layouts.
-get_filename_component(_tvm_tirx_libdir "${CMAKE_CURRENT_LIST_DIR}/../.."
ABSOLUTE)
+if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/config.py")
+ # Installed package: query this installation's helper, independently of any
+ # other Python wheel. Passing the exact library directory also supports lib64
+ # and multiarch layouts.
+ get_filename_component(_tvm_tirx_libdir "${CMAKE_CURRENT_LIST_DIR}/../.."
ABSOLUTE)
+ set(_tvm_tirx_config_args
+ "${CMAKE_CURRENT_LIST_DIR}/config.py" --library-dir "${_tvm_tirx_libdir}")
+else()
+ # Source checkout (``tvm-tirx-config --cmakedir`` returns its ``cmake/``):
+ # the source helper locates the build's library directory itself.
+ set(_tvm_tirx_config_args
"${CMAKE_CURRENT_LIST_DIR}/../python/tvm_tirx/config.py")
+endif()
execute_process(
- COMMAND "${Python_EXECUTABLE}" "${CMAKE_CURRENT_LIST_DIR}/config.py"
- --library-dir "${_tvm_tirx_libdir}" --platform "${CMAKE_SYSTEM_NAME}"
--json
+ COMMAND "${Python_EXECUTABLE}" ${_tvm_tirx_config_args}
+ --platform "${CMAKE_SYSTEM_NAME}" --json
OUTPUT_VARIABLE _tvm_tirx_config OUTPUT_STRIP_TRAILING_WHITESPACE
COMMAND_ERROR_IS_FATAL ANY)
string(JSON TVM_TIRX_VERSION GET "${_tvm_tirx_config}" version)
diff --git a/docs/conf.py b/docs/conf.py
index 25766b6c8..c54256133 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -43,6 +43,7 @@ extensions = [
"sphinx.ext.autosummary",
"sphinx.ext.mathjax",
"sphinx.ext.napoleon",
+ "sphinx_tabs.tabs",
]
if build_exhale:
diff --git a/docs/get_started/quick_start.rst b/docs/get_started/quick_start.rst
index 5d6bdac77..35f1d0b51 100644
--- a/docs/get_started/quick_start.rst
+++ b/docs/get_started/quick_start.rst
@@ -18,60 +18,290 @@
Quick Start
===========
-In this chapter, we'll write and run a small TIRx program using TVMScript,
-which lets us describe tensor computations with Python syntax. We'll also
-inspect the IR that TVMScript creates from the code. The examples use
-PyTorch tensors; the :doc:`/dev/source_build` guide explains how to set up
-TIRx.
+.. note::
-Our example computes ``B[i] = A[i] + 1``, where ``A`` is the input tensor
-and ``B`` is the output. Both tensors have the same dynamic length ``n``,
-so the compiled program can handle different input lengths without
-recompilation.
+ All the code in this guide is under
+ `examples/quick_start
<https://github.com/apache/tvm-tirx/tree/main/examples/quick_start>`_
+ in the repository.
-We'll show two versions of this program: one for the CPU and one for an
-NVIDIA GPU. We'll first compile and run the CPU version using LLVM.
+This guide walks through a small ``add_one`` program that computes
+``B = A + 1`` on CPU and CUDA with TIRx, a minimal, open ML compiler
+foundation:
-.. literalinclude:: examples/add_one_cpu.py
+- **Programs in Python**: tensor programs are written as Python functions and
+ compiled directly.
+- **Transparent program structure**: every element of a program, from
+ functions to statements and types, is accessible from Python and other
+ languages, so developers and agents can inspect and transform it.
+- **Built for extension**: all compiler APIs are open, so developers and
+ agents can quickly iterate on extensions in separate packages that link to
+ TIRx dynamically, without rebuilding one monolithic bundle.
+
+This guide shows the first two in action and gives a first taste of the third.
+
+.. admonition:: Prerequisite
+ :class: hint
+
+ - Python 3.10 or newer
+ - PyTorch, to create and check tensors
+ - CUDA 13 or newer environment, for the CUDA example
+ - TIRx, installed with:
+
+ .. code-block:: bash
+
+ pip install --upgrade --force-reinstall apache-tvm-tirx
+ # add the cuda-bindings dependency:
+ # pip install --upgrade --force-reinstall "apache-tvm-tirx[cuda]"
+
+
+Write a Simple ``add_one``
+--------------------------
+
+A TIRx program is an ordinary Python function marked with ``@T.function``.
+Here ``add_one`` takes an input tensor ``A`` and an output tensor ``B``, each
+holding ``n`` float32 values. We create ``n`` with ``T.dynamic`` instead of
+picking a fixed number, so the same program works for tensors of any length.
+
+.. tabs::
+
+ .. group-tab:: CPU
+
+ .. literalinclude:: ../../examples/quick_start/add_one_cpu.py
+ :language: python
+ :start-after: # [function.begin]
+ :end-at: B[i] = A[i] + 1
+
+ .. group-tab:: CUDA
+
+ .. literalinclude:: ../../examples/quick_start/add_one_cuda.py
+ :language: python
+ :start-after: # [function.begin]
+ :end-at: B[i] = A[i] + 1
+
+The CPU version is a loop that walks over all ``n`` elements. The CUDA
+version spreads the work across many GPU threads instead: ``T.device_entry``
+starts the GPU code and launches it in blocks of 256 threads, with enough
+blocks to cover all ``n`` elements. Each thread works out the element ``i`` it
+owns and updates only that one. The last block may have more threads than
+elements left, so the ``if i < n`` check keeps those extra threads from going
+past the end of the tensors.
+
+Compile and Run
+---------------
+
+With the program written, we compile it for a target, ``"llvm"`` for the CPU
+or ``"cuda"`` for an NVIDIA GPU, using ``tvm_tirx.compile``. The result is a
+compiled program that we call like a function, passing PyTorch tensors
+directly, so we create the inputs with ``torch`` and check the output with
+``torch.testing.assert_close``:
+
+.. tabs::
+
+ .. group-tab:: CPU
+
+ .. literalinclude:: ../../examples/quick_start/add_one_cpu.py
+ :language: python
+ :start-after: # [run.begin]
+ :end-before: # [run.end]
+
+ .. group-tab:: CUDA
+
+ .. literalinclude:: ../../examples/quick_start/add_one_cuda.py
+ :language: python
+ :start-after: # [run.begin]
+ :end-before: # [run.end]
+
+The script prints the result, each input value plus one (the CUDA version also
+shows ``device='cuda:0'``):
+
+.. code-block:: text
+
+ tensor([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
+
+
+Inspect and Transform the Program
+---------------------------------
+
+Besides compiling and running ``add_one``, we can also look inside it. The
+``add_one`` returned by ``@T.function`` is a tree of program elements,
+commonly called an intermediate representation (IR). Roughly, the tree for
+the CPU version looks like this:
+
+.. code-block:: text
+
+ Function
+ ├── params
+ │ ├── Var(name="A", ty=TensorType(shape=[n], dtype=float32))
+ │ └── Var(name="B", ty=TensorType(shape=[n], dtype=float32))
+ └── body
+ └── For(var=i, begin=0, end=n)
+ └── body
+ └── TensorStore(dest=B, indices=[i])
+ └── value
+ └── Add
+ ├── a: TensorLoad(source=A, indices=[i])
+ └── b: FloatImm(value=1.0)
+
+Every element is accessible from Python and other languages, so we can walk
+this tree directly in Python:
+
+.. literalinclude:: ../../examples/quick_start/inspect_and_transform.py
:language: python
- :start-after: # begin program
- :end-before: # end program
+ :start-after: # [inspect.begin]
+ :end-before: # [inspect.end]
-``@T.function`` turns the ``add_one`` definition into IR. The code
-in ``add_one`` loops over the input and writes each result to ``B``.
-``tvm_tirx.compile`` compiles it for the CPU. The compiled function accepts
-PyTorch tensors directly, and ``torch.testing.assert_close`` checks its
-output.
+Named values in the program, such as the parameters ``A`` and ``B``, the length
+``n``, and the loop index ``i``, are variables represented by
+:py:class:`~tvm_tirx.ir.Var` objects. Note that the constant ``1`` was
+converted to ``T.float32(1.0)`` to match the element type.
-The same ``add_one`` object lets us inspect the program's IR. We can get
-the type of parameter ``A`` through ``params[0].ty``, then read its symbolic
-length from ``shape[0]``:
+These elements are minimal `TVM-FFI <https://tvm.apache.org/ffi/>`_ objects,
+which share one representation across languages. On top of them, TIRx provides
+reusable APIs to build analyses and transformations. For example, we can
+specialize ``add_one`` for tensors of exactly 128 elements by replacing every
+use of ``n`` with ``128``:
+
+.. literalinclude:: ../../examples/quick_start/inspect_and_transform.py
+ :language: python
+ :start-after: # [transform.begin]
+ :end-before: # [transform.end]
.. code-block:: python
- input_type = add_one.params[0].ty
- length = input_type.shape[0]
+ @T.function
+ def add_one(A: T.Tensor((128,), T.float32), B: T.Tensor((128,), T.float32)):
+ for i in range(128):
+ B[i] = A[i] + T.float32(1.0)
-The :doc:`IR Walkthrough </ir/overview>` explains these IR objects and how
-to work with them.
+``tvm_ffi.structural_map`` walks every element of the program and calls our
+function on each ``Var``, replacing it with whatever we return.
+The result, ``add_one_specialized``, is a new program specialized to tensors of
+128 elements. We can compile it with ``tvm_tirx.compile`` like any other
+program, while the original ``add_one`` stays unchanged.
-We can also run this computation on an NVIDIA GPU. In addition to LLVM,
-it still needs CUDA support, an NVIDIA driver, the CUDA toolkit, and
-``cuda-bindings`` to run.
+.. seealso::
-.. literalinclude:: examples/add_one_cuda.py
- :language: python
- :start-after: # begin program
- :end-before: # end program
-
-``T.device_entry`` marks the GPU computation and configures blocks of 256
-threads. Each thread handles one element, so the block count is rounded
-up to cover ``n`` elements. The ``if i < n`` check keeps extra threads in
-the last block from accessing the tensors. We compile the function for
-CUDA with ``tvm_tirx.compile`` and run it with input and output tensors on
-``"cuda:0"``, then check the result with PyTorch as in the CPU example.
-
-The complete examples are available as
-:download:`add_one_cpu.py <examples/add_one_cpu.py>` and
-:download:`add_one_cuda.py <examples/add_one_cuda.py>`. You can run them with
-``python add_one_cpu.py`` and ``python add_one_cuda.py``, respectively.
+ :doc:`IR Walkthrough </ir/overview>` for a more in-depth introduction to the
+ main IR objects and their roles in the overall program structure.
+
+
+Export and Load the Compiled Program
+------------------------------------
+
+So far, we have compiled and run ``add_one`` in the same Python process. In
+practice, we often want to compile a program once and run it somewhere else:
+in another process, on another machine, or inside an application that is not
+written in Python.
+
+We support this by exporting the compiled program as a shared library. Under
+the hood, ``tvm_tirx.compile`` returns an ``Executable``. It holds the compiled
+module, which contains the function ``add_one``; calling the executable, as we
+did earlier, calls that function. The executable's ``export_library`` method
+writes this module to a shared library:
+
+.. tabs::
+
+ .. group-tab:: CPU
+
+ .. literalinclude:: ../../examples/quick_start/add_one_cpu.py
+ :language: python
+ :start-after: # [export.begin]
+ :end-before: # [export.end]
+
+ .. group-tab:: CUDA
+
+ .. literalinclude:: ../../examples/quick_start/add_one_cuda.py
+ :language: python
+ :start-after: # [export.begin]
+ :end-before: # [export.end]
+
+The exported library is a regular TVM-FFI module, so any language or framework
+that TVM-FFI supports, such as C++, Rust, and JAX, can load and call it.
+Running it does not need the compiler, only the minimal TVM runtime libraries,
+``libtvm_runtime.so`` and ``libtvm_runtime_cuda.so`` (for CUDA), each under
+1 MB.
+
+Load in Python
+~~~~~~~~~~~~~~
+
+Later, for example in a new Python process, ``tvm_ffi.load_module`` loads the
+module back. Importing ``tvm_tirx`` loads the runtime libraries the module
+needs. The loaded module exposes its functions by name, so we call ``add_one``
+as an attribute of the module:
+
+.. tabs::
+
+ .. group-tab:: CPU
+
+ .. literalinclude:: ../../examples/quick_start/load_add_one_cpu.py
+ :language: python
+ :start-after: # [load.begin]
+ :end-before: # [load.end]
+
+ .. group-tab:: CUDA
+
+ .. literalinclude:: ../../examples/quick_start/load_add_one_cuda.py
+ :language: python
+ :start-after: # [load.begin]
+ :end-before: # [load.end]
+
+Load from C++
+~~~~~~~~~~~~~
+
+The following C++ program loads the CPU build, ``add_one_cpu.so``, and calls
+``add_one`` through the TVM-FFI C++ API. TIRx kernels require 64-byte aligned
+tensor data for performance, so the program allocates its tensors with
+``std::aligned_alloc``:
+
+.. literalinclude:: ../../examples/quick_start/load_cpp.cc
+ :language: cpp
+ :start-after: // [main.begin]
+ :end-before: // [main.end]
+
+To build it, we link against only the runtime libraries, which
+``tvm-tirx-config`` finds for us, so the program runs without the compiler.
+Run it from the directory that contains ``add_one_cpu.so``:
+
+.. code-block:: bash
+
+ g++ -O2 load_cpp.cc \
+ $(tvm-tirx-config --cxxflags --ldflags --libs runtime) \
+ -Wl,-rpath,$(tvm-tirx-config --libdir) \
+ -Wl,-rpath,$(tvm-ffi-config --libdir) \
+ -o load_cpp
+ ./load_cpp
+
+The same program can also be built with CMake. The ``CMakeLists.txt`` in
+``examples/quick_start`` finds the TIRx and TVM-FFI CMake packages with
+``python -m tvm_tirx.config --cmakedir`` and ``python -m tvm_ffi.config
+--cmakedir``, then links ``load_cpp`` against ``tvm_runtime::shared`` and
+``tvm_ffi::shared``:
+
+.. code-block:: bash
+
+ cmake . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
+ cmake --build build --config RelWithDebInfo
+ build/load_cpp
+
+
+Troubleshooting
+---------------
+
+If compiling for CUDA fails with ``ValueError: CUDA compilation requires an
+explicit backend_config arch or Target arch when no CUDA device is available``
+even though the machine has a GPU, TIRx could not find the CUDA runtime library
+``libcudart.so.13``. Install and import a CUDA 13 build of PyTorch, which ships
+this library, or install the CUDA 13 toolkit and add its ``lib64`` directory to
+``LD_LIBRARY_PATH``.
+
+
+Further Reading
+---------------
+
+- :doc:`/ir/overview`: the IR objects in depth and how they fit together.
+- :doc:`TIRx CUDA Programming Guide </cuda/language_basics>`: writing CUDA
+ kernels with TIRx.
+- :doc:`Python API </reference/python/index>`: the full Python API reference.
+- :doc:`/dev/source_build`: building TIRx from source.
+- `TVM-FFI documentation <https://tvm.apache.org/ffi/>`_: the FFI and ABI
+ foundation TIRx is built upon.
diff --git a/docs/index.rst b/docs/index.rst
index 0e1db6aaa..ad34a7160 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -15,8 +15,22 @@
specific language governing permissions and limitations
under the License.
-tvm-tirx
-========
+Apache TVM TIRx Documentation
+=============================
+
+Welcome to the documentation for TVM TIRx. You can get started by reading the
+Get Started section, then reading through the other sections.
+
+Installation
+------------
+
+To try out TVM TIRx, install it via pip or uv:
+
+.. code-block:: bash
+
+ pip install --upgrade --force-reinstall apache-tvm-tirx
+ # add the cuda-bindings dependency:
+ # pip install --upgrade --force-reinstall "apache-tvm-tirx[cuda]"
Table of Contents
-----------------
diff --git a/docs/ir/functions_and_modules.rst
b/docs/ir/functions_and_modules.rst
index e04482ae9..330897ece 100644
--- a/docs/ir/functions_and_modules.rst
+++ b/docs/ir/functions_and_modules.rst
@@ -58,7 +58,7 @@ The main fields of ``tirx.Function`` are:
In TVMScript, ``@T.function`` produces this IR object from a function
definition. The CPU example is defined as:
-.. literalinclude:: ../get_started/examples/add_one_cpu.py
+.. literalinclude:: ../../examples/quick_start/add_one_cpu.py
:language: python
:start-at: from tvm_tirx.script import tirx as T
:end-at: B[i] = A[i] + 1
diff --git a/docs/ir/operators_and_calls.rst b/docs/ir/operators_and_calls.rst
index bfb0ca656..09208ffed 100644
--- a/docs/ir/operators_and_calls.rst
+++ b/docs/ir/operators_and_calls.rst
@@ -134,7 +134,7 @@ both calls produce an int32 coordinate:
A call's result can be an operand in a larger expression. In the GPU
example, two calls contribute to the element index ``i``:
-.. literalinclude:: ../get_started/examples/add_one_cuda.py
+.. literalinclude:: ../../examples/quick_start/add_one_cuda.py
:language: python
:start-at: i = T.cuda.block_idx
:end-at: i = T.cuda.block_idx
diff --git a/docs/ir/printing_and_parsing.rst b/docs/ir/printing_and_parsing.rst
index 849647fdb..7fb4ce2ab 100644
--- a/docs/ir/printing_and_parsing.rst
+++ b/docs/ir/printing_and_parsing.rst
@@ -33,7 +33,7 @@ Printing IR
In the CPU example, the TVMScript decorator ``@T.function`` parses the
function definition into a ``tirx.Function`` IR object:
-.. literalinclude:: ../get_started/examples/add_one_cpu.py
+.. literalinclude:: ../../examples/quick_start/add_one_cpu.py
:language: python
:start-at: from tvm_tirx.script import tirx as T
:end-at: B[i] = A[i] + 1
@@ -300,7 +300,7 @@ The parser also determines which statements belong to a
region. In the
GPU example, TVMScript recognizes ``T.device_entry`` as a region
construct. Its standalone form starts the device region:
-.. literalinclude:: ../get_started/examples/add_one_cuda.py
+.. literalinclude:: ../../examples/quick_start/add_one_cuda.py
:language: python
:start-at: @T.function
:end-at: B[i] = A[i] + 1
diff --git a/docs/ir/statements.rst b/docs/ir/statements.rst
index 21bcf01b9..bc37a3239 100644
--- a/docs/ir/statements.rst
+++ b/docs/ir/statements.rst
@@ -89,7 +89,7 @@ stored in a ``SeqStmt``.
The CPU example writes one output element in each loop iteration:
-.. literalinclude:: ../get_started/examples/add_one_cpu.py
+.. literalinclude:: ../../examples/quick_start/add_one_cpu.py
:language: python
:start-at: for i in range(n):
:end-at: B[i] = A[i] + 1
@@ -174,7 +174,7 @@ which body runs.
The CPU example visits every element with a loop:
-.. literalinclude:: ../get_started/examples/add_one_cpu.py
+.. literalinclude:: ../../examples/quick_start/add_one_cpu.py
:language: python
:start-at: for i in range(n):
:end-at: B[i] = A[i] + 1
@@ -216,7 +216,7 @@ The GPU example distributes this work across threads.
``T.device_entry``
introduces the GPU computation. Each thread computes an index ``i`` and
checks whether it has an element to process:
-.. literalinclude:: ../get_started/examples/add_one_cuda.py
+.. literalinclude:: ../../examples/quick_start/add_one_cuda.py
:language: python
:start-at: T.device_entry(
:end-at: B[i] = A[i] + 1
diff --git a/docs/ir/types_and_expressions.rst
b/docs/ir/types_and_expressions.rst
index 9a5d5d6c8..44be5f866 100644
--- a/docs/ir/types_and_expressions.rst
+++ b/docs/ir/types_and_expressions.rst
@@ -74,7 +74,7 @@ In the program's tensor annotations, ``T.float32`` is an
The program declares its dynamic length as:
-.. literalinclude:: ../get_started/examples/add_one_cpu.py
+.. literalinclude:: ../../examples/quick_start/add_one_cpu.py
:language: python
:start-at: from tvm_tirx.script import tirx as T
:end-at: n = T.dynamic
@@ -120,7 +120,7 @@ the type of each element.
The program declares its input and output as:
-.. literalinclude:: ../get_started/examples/add_one_cpu.py
+.. literalinclude:: ../../examples/quick_start/add_one_cpu.py
:language: python
:start-at: def add_one(
:end-at: def add_one(
@@ -306,7 +306,7 @@ four-lane expression ``vector_plus_one``.
The GPU example combines multiplication, addition, and comparison to
compute and check each thread's element index:
-.. literalinclude:: ../get_started/examples/add_one_cuda.py
+.. literalinclude:: ../../examples/quick_start/add_one_cuda.py
:language: python
:start-at: i = T.cuda.block_idx
:end-at: B[i] = A[i] + 1
@@ -447,7 +447,7 @@ and range.
The parameter ``A`` is declared on this line of the CPU program:
-.. literalinclude:: ../get_started/examples/add_one_cpu.py
+.. literalinclude:: ../../examples/quick_start/add_one_cpu.py
:language: python
:start-at: def add_one(
:end-at: def add_one(
diff --git a/examples/quick_start/CMakeLists.txt
b/examples/quick_start/CMakeLists.txt
new file mode 100644
index 000000000..d30abcec9
--- /dev/null
+++ b/examples/quick_start/CMakeLists.txt
@@ -0,0 +1,49 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+cmake_minimum_required(VERSION 3.20)
+project(tirx_quick_start LANGUAGES CXX)
+
+# Locate the CMake packages with the TIRx and TVM-FFI config tools.
+find_package(
+ Python
+ COMPONENTS Interpreter
+ REQUIRED
+)
+execute_process(
+ COMMAND "${Python_EXECUTABLE}" -m tvm_tirx.config --cmakedir
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ OUTPUT_VARIABLE tvm_tirx_ROOT
+ COMMAND_ERROR_IS_FATAL ANY
+)
+execute_process(
+ COMMAND "${Python_EXECUTABLE}" -m tvm_ffi.config --cmakedir
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ OUTPUT_VARIABLE tvm_ffi_ROOT
+ COMMAND_ERROR_IS_FATAL ANY
+)
+find_package(tvm_ffi CONFIG REQUIRED)
+find_package(tvm_tirx CONFIG REQUIRED)
+
+# Load add_one_cpu.so from C++ using only the runtime libraries.
+add_executable(load_cpp load_cpp.cc)
+# load_cpp never calls the TIRx runtime directly; keep it linked so that it is
+# loaded at startup and can run the exported module.
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+ target_link_options(load_cpp PRIVATE "LINKER:--no-as-needed")
+endif ()
+target_link_libraries(load_cpp PRIVATE tvm_runtime::shared tvm_ffi::shared)
+set_target_properties(load_cpp PROPERTIES RUNTIME_OUTPUT_DIRECTORY
"${CMAKE_BINARY_DIR}")
diff --git a/examples/quick_start/README.md b/examples/quick_start/README.md
new file mode 100644
index 000000000..0098147db
--- /dev/null
+++ b/examples/quick_start/README.md
@@ -0,0 +1,75 @@
+<!--- Licensed to the Apache Software Foundation (ASF) under one -->
+<!--- or more contributor license agreements. See the NOTICE file -->
+<!--- distributed with this work for additional information -->
+<!--- regarding copyright ownership. The ASF licenses this file -->
+<!--- to you under the Apache License, Version 2.0 (the -->
+<!--- "License"); you may not use this file except in compliance -->
+<!--- with the License. You may obtain a copy of the License at -->
+
+<!--- http://www.apache.org/licenses/LICENSE-2.0 -->
+
+<!--- Unless required by applicable law or agreed to in writing, -->
+<!--- software distributed under the License is distributed on an -->
+<!--- "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -->
+<!--- KIND, either express or implied. See the License for the -->
+<!--- specific language governing permissions and limitations -->
+<!--- under the License. -->
+
+# Quick Start Examples
+
+This directory contains all the source code for the
+[Quick Start](https://tvm.apache.org/tirx/get_started/quick_start.html)
tutorial.
+
+| File | What it does |
+| --- | --- |
+| `add_one_cpu.py`, `add_one_cuda.py` | Write, compile, and run `add_one`;
export it to `add_one_cpu.so` / `add_one_cuda.so` |
+| `load_add_one_cpu.py`, `load_add_one_cuda.py` | Load the exported library in
a new Python process and run it |
+| `inspect_and_transform.py` | Inspect the program and specialize it to 128
elements |
+| `load_cpp.cc`, `CMakeLists.txt` | Load `add_one_cpu.so` from C++ using only
the runtime libraries |
+
+## Run everything
+
+```bash
+pip install apache-tvm-tirx torch
+bash run_all_cpu.sh # on Windows: run_all_cpu.bat (Python steps only)
+
+# needs an NVIDIA GPU with CUDA 13 or newer
+pip install "apache-tvm-tirx[cuda]"
+bash run_all_cuda.sh
+```
+
+## Run step by step
+
+Run the scripts from this directory:
+
+```bash
+python add_one_cpu.py
+python load_add_one_cpu.py
+python inspect_and_transform.py
+```
+
+For CUDA:
+
+```bash
+python add_one_cuda.py
+python load_add_one_cuda.py
+```
+
+For C++, run `add_one_cpu.py` first, then build and run the loader with CMake:
+
+```bash
+cmake . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
+cmake --build build --config RelWithDebInfo
+build/load_cpp
+```
+
+or directly with `g++`, using `tvm-tirx-config` for the flags:
+
+```bash
+g++ -O2 load_cpp.cc \
+ $(tvm-tirx-config --cxxflags --ldflags --libs runtime) \
+ -Wl,-rpath,$(tvm-tirx-config --libdir) \
+ -Wl,-rpath,$(tvm-ffi-config --libdir) \
+ -o load_cpp
+./load_cpp
+```
diff --git a/docs/get_started/examples/add_one_cpu.py
b/examples/quick_start/add_one_cpu.py
similarity index 85%
copy from docs/get_started/examples/add_one_cpu.py
copy to examples/quick_start/add_one_cpu.py
index bdbe8a1c5..81c728781 100644
--- a/docs/get_started/examples/add_one_cpu.py
+++ b/examples/quick_start/add_one_cpu.py
@@ -14,9 +14,9 @@
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
-"""Add one to each element on the CPU. Requires LLVM support."""
+"""Add one to each element on the CPU."""
-# begin program
+# [function.begin]
import torch
import tvm_tirx
@@ -31,10 +31,15 @@ def add_one(A: T.Tensor((n,), T.float32), B: T.Tensor((n,),
T.float32)):
B[i] = A[i] + 1
+# [run.begin]
add_one_compiled = tvm_tirx.compile(add_one, target="llvm")
a = torch.arange(10, dtype=torch.float32)
-b = torch.empty(a.shape, dtype=a.dtype)
+b = torch.empty_like(a)
add_one_compiled(a, b)
torch.testing.assert_close(b, a + 1)
print(b)
-# end program
+# [run.end]
+
+# [export.begin]
+add_one_compiled.export_library("./add_one_cpu.so")
+# [export.end]
diff --git a/docs/get_started/examples/add_one_cuda.py
b/examples/quick_start/add_one_cuda.py
similarity index 78%
rename from docs/get_started/examples/add_one_cuda.py
rename to examples/quick_start/add_one_cuda.py
index e2da17eef..aea3b92ff 100644
--- a/docs/get_started/examples/add_one_cuda.py
+++ b/examples/quick_start/add_one_cuda.py
@@ -14,9 +14,9 @@
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
-"""Add one to each element on an NVIDIA GPU. Requires LLVM and CUDA support."""
+"""Add one to each element on CUDA."""
-# begin program
+# [function.begin]
import torch
import tvm_tirx
@@ -27,16 +27,21 @@ n = T.dynamic("n")
@T.function
def add_one(A: T.Tensor((n,), T.float32), B: T.Tensor((n,), T.float32)):
- T.device_entry(launch=T.cuda.LaunchConfig(grid=((n + 255) // 256,),
block=(256,)))
+ T.device_entry(launch=T.cuda.LaunchConfig(grid=T.ceildiv(n, 256),
block=256))
i = T.cuda.block_idx("x") * 256 + T.cuda.thread_idx("x")
if i < n:
B[i] = A[i] + 1
+# [run.begin]
add_one_compiled = tvm_tirx.compile(add_one, target="cuda")
-a = torch.arange(10, dtype=torch.float32, device="cuda:0")
-b = torch.empty(a.shape, dtype=a.dtype, device=a.device)
+a = torch.arange(10, dtype=torch.float32, device="cuda")
+b = torch.empty_like(a)
add_one_compiled(a, b)
torch.testing.assert_close(b, a + 1)
print(b)
-# end program
+# [run.end]
+
+# [export.begin]
+add_one_compiled.export_library("./add_one_cuda.so")
+# [export.end]
diff --git a/docs/get_started/examples/add_one_cpu.py
b/examples/quick_start/inspect_and_transform.py
similarity index 64%
copy from docs/get_started/examples/add_one_cpu.py
copy to examples/quick_start/inspect_and_transform.py
index bdbe8a1c5..cdb96e096 100644
--- a/docs/get_started/examples/add_one_cpu.py
+++ b/examples/quick_start/inspect_and_transform.py
@@ -13,11 +13,9 @@
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
-# under the License.
-"""Add one to each element on the CPU. Requires LLVM support."""
+# under the License."""Inspect and transform the add_one program."""
-# begin program
-import torch
+import tvm_ffi
import tvm_tirx
from tvm_tirx.script import tirx as T
@@ -31,10 +29,19 @@ def add_one(A: T.Tensor((n,), T.float32), B: T.Tensor((n,),
T.float32)):
B[i] = A[i] + 1
-add_one_compiled = tvm_tirx.compile(add_one, target="llvm")
-a = torch.arange(10, dtype=torch.float32)
-b = torch.empty(a.shape, dtype=a.dtype)
-add_one_compiled(a, b)
-torch.testing.assert_close(b, a + 1)
-print(b)
-# end program
+# fmt: off
+# [inspect.begin]
+A, B = add_one.params # parameters are Vars
+n = A.ty.shape[0] # the symbolic length n, also a Var
+loop = add_one.body[0] # for i in range(n)
+print(loop.body[0].value) # A[i] + T.float32(1.0)
+# [inspect.end]
+# fmt: on
+
+# [transform.begin]
+add_one_specialized = tvm_ffi.structural_map(
+ add_one,
+ (tvm_tirx.ir.Var, lambda v: T.int32(128) if v.same_as(n) else v),
+)
+add_one_specialized.show()
+# [transform.end]
diff --git a/docs/get_started/examples/add_one_cpu.py
b/examples/quick_start/load_add_one_cpu.py
similarity index 65%
copy from docs/get_started/examples/add_one_cpu.py
copy to examples/quick_start/load_add_one_cpu.py
index bdbe8a1c5..9c7c07e41 100644
--- a/docs/get_started/examples/add_one_cpu.py
+++ b/examples/quick_start/load_add_one_cpu.py
@@ -13,28 +13,18 @@
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
-# under the License.
-"""Add one to each element on the CPU. Requires LLVM support."""
+# under the License."""Load add_one_cpu.so, written by add_one_cpu.py, and run
it on CPU."""
-# begin program
+# [load.begin]
import torch
+import tvm_ffi
-import tvm_tirx
-from tvm_tirx.script import tirx as T
+# Load the runtime libraries.
+import tvm_tirx # noqa: F401
-n = T.dynamic("n")
-
-
[email protected]
-def add_one(A: T.Tensor((n,), T.float32), B: T.Tensor((n,), T.float32)):
- for i in range(n):
- B[i] = A[i] + 1
-
-
-add_one_compiled = tvm_tirx.compile(add_one, target="llvm")
+loaded = tvm_ffi.load_module("./add_one_cpu.so")
a = torch.arange(10, dtype=torch.float32)
-b = torch.empty(a.shape, dtype=a.dtype)
-add_one_compiled(a, b)
+b = torch.empty_like(a)
+loaded.add_one(a, b)
torch.testing.assert_close(b, a + 1)
-print(b)
-# end program
+# [load.end]
diff --git a/docs/get_started/examples/add_one_cpu.py
b/examples/quick_start/load_add_one_cuda.py
similarity index 62%
copy from docs/get_started/examples/add_one_cpu.py
copy to examples/quick_start/load_add_one_cuda.py
index bdbe8a1c5..ea95523f1 100644
--- a/docs/get_started/examples/add_one_cpu.py
+++ b/examples/quick_start/load_add_one_cuda.py
@@ -13,28 +13,18 @@
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
-# under the License.
-"""Add one to each element on the CPU. Requires LLVM support."""
+# under the License."""Load add_one_cuda.so, written by add_one_cuda.py, and
run it on CUDA."""
-# begin program
+# [load.begin]
import torch
+import tvm_ffi
-import tvm_tirx
-from tvm_tirx.script import tirx as T
+# Load the runtime libraries.
+import tvm_tirx # noqa: F401
-n = T.dynamic("n")
-
-
[email protected]
-def add_one(A: T.Tensor((n,), T.float32), B: T.Tensor((n,), T.float32)):
- for i in range(n):
- B[i] = A[i] + 1
-
-
-add_one_compiled = tvm_tirx.compile(add_one, target="llvm")
-a = torch.arange(10, dtype=torch.float32)
-b = torch.empty(a.shape, dtype=a.dtype)
-add_one_compiled(a, b)
+loaded = tvm_ffi.load_module("./add_one_cuda.so")
+a = torch.arange(10, dtype=torch.float32, device="cuda")
+b = torch.empty_like(a)
+loaded.add_one(a, b)
torch.testing.assert_close(b, a + 1)
-print(b)
-# end program
+# [load.end]
diff --git a/examples/quick_start/load_cpp.cc b/examples/quick_start/load_cpp.cc
new file mode 100644
index 000000000..5ce19ff8f
--- /dev/null
+++ b/examples/quick_start/load_cpp.cc
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+// Load the add_one_cpu.so exported by add_one_cpu.py and run it from C++.
+// [main.begin]
+#include <tvm/ffi/extra/module.h>
+#include <tvm/ffi/tvm_ffi.h>
+
+#include <cstdlib>
+#include <iostream>
+
+namespace ffi = tvm::ffi;
+
+// TIRx kernels require 64-byte aligned tensor data for performance.
+struct CPUAllocator {
+ void AllocData(DLTensor* tensor) {
+ size_t bytes = (tensor->shape[0] * sizeof(float) + 63) / 64 * 64;
+ tensor->data = std::aligned_alloc(64, bytes);
+ }
+ void FreeData(DLTensor* tensor) { std::free(tensor->data); }
+};
+
+int main() {
+ DLDataType f32{kDLFloat, 32, 1};
+ DLDevice cpu{kDLCPU, 0};
+ ffi::Tensor a = ffi::Tensor::FromNDAlloc(CPUAllocator(), {10}, f32, cpu);
+ ffi::Tensor b = ffi::Tensor::FromNDAlloc(CPUAllocator(), {10}, f32, cpu);
+ float* a_data = static_cast<float*>(a.data_ptr());
+ for (int i = 0; i < 10; ++i) a_data[i] = static_cast<float>(i);
+
+ ffi::Module mod = ffi::Module::LoadFromFile("./add_one_cpu.so");
+ ffi::Function add_one = mod->GetFunction("add_one").value();
+ add_one(a, b);
+
+ const float* b_data = static_cast<const float*>(b.data_ptr());
+ for (int i = 0; i < 10; ++i) std::cout << b_data[i] << " ";
+ std::cout << std::endl;
+ return 0;
+}
+// [main.end]
diff --git a/examples/quick_start/run_all_cpu.bat
b/examples/quick_start/run_all_cpu.bat
new file mode 100644
index 000000000..11798399e
--- /dev/null
+++ b/examples/quick_start/run_all_cpu.bat
@@ -0,0 +1,31 @@
+@echo off
+rem Licensed to the Apache Software Foundation (ASF) under one
+rem or more contributor license agreements. See the NOTICE file
+rem distributed with this work for additional information
+rem regarding copyright ownership. The ASF licenses this file
+rem to you under the Apache License, Version 2.0 (the
+rem "License"); you may not use this file except in compliance
+rem with the License. You may obtain a copy of the License at
+rem
+rem http://www.apache.org/licenses/LICENSE-2.0
+rem
+rem Unless required by applicable law or agreed to in writing,
+rem software distributed under the License is distributed on an
+rem "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+rem KIND, either express or implied. See the License for the
+rem specific language governing permissions and limitations
+rem under the License.
+
+setlocal
+cd /d "%~dp0"
+
+rem Write, compile, and run add_one; export it to add_one_cpu.so
+python add_one_cpu.py || exit /b 1
+
+rem Load add_one_cpu.so in a new Python process
+python load_add_one_cpu.py || exit /b 1
+
+rem Inspect add_one and specialize it to 128 elements
+python inspect_and_transform.py || exit /b 1
+
+endlocal
diff --git a/docs/get_started/examples/add_one_cpu.py
b/examples/quick_start/run_all_cpu.sh
old mode 100644
new mode 100755
similarity index 59%
copy from docs/get_started/examples/add_one_cpu.py
copy to examples/quick_start/run_all_cpu.sh
index bdbe8a1c5..f3bcee8a2
--- a/docs/get_started/examples/add_one_cpu.py
+++ b/examples/quick_start/run_all_cpu.sh
@@ -1,3 +1,4 @@
+#!/bin/bash
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
@@ -14,27 +15,19 @@
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
-"""Add one to each element on the CPU. Requires LLVM support."""
+set -ex
+cd "$(dirname "$0")"
-# begin program
-import torch
+# Write, compile, and run add_one; export it to add_one_cpu.so
+python add_one_cpu.py
-import tvm_tirx
-from tvm_tirx.script import tirx as T
+# Load add_one_cpu.so in a new Python process
+python load_add_one_cpu.py
-n = T.dynamic("n")
+# Inspect add_one and specialize it to 128 elements
+python inspect_and_transform.py
-
[email protected]
-def add_one(A: T.Tensor((n,), T.float32), B: T.Tensor((n,), T.float32)):
- for i in range(n):
- B[i] = A[i] + 1
-
-
-add_one_compiled = tvm_tirx.compile(add_one, target="llvm")
-a = torch.arange(10, dtype=torch.float32)
-b = torch.empty(a.shape, dtype=a.dtype)
-add_one_compiled(a, b)
-torch.testing.assert_close(b, a + 1)
-print(b)
-# end program
+# Load add_one_cpu.so from C++ using only the runtime libraries
+cmake . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
+cmake --build build --config RelWithDebInfo
+build/load_cpp
diff --git a/docs/get_started/examples/add_one_cpu.py
b/examples/quick_start/run_all_cuda.sh
old mode 100644
new mode 100755
similarity index 59%
rename from docs/get_started/examples/add_one_cpu.py
rename to examples/quick_start/run_all_cuda.sh
index bdbe8a1c5..3483217ee
--- a/docs/get_started/examples/add_one_cpu.py
+++ b/examples/quick_start/run_all_cuda.sh
@@ -1,3 +1,4 @@
+#!/bin/bash
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
@@ -14,27 +15,11 @@
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
-"""Add one to each element on the CPU. Requires LLVM support."""
+set -ex
+cd "$(dirname "$0")"
-# begin program
-import torch
+# Write, compile, and run add_one on CUDA; export it to add_one_cuda.so
+python add_one_cuda.py
-import tvm_tirx
-from tvm_tirx.script import tirx as T
-
-n = T.dynamic("n")
-
-
[email protected]
-def add_one(A: T.Tensor((n,), T.float32), B: T.Tensor((n,), T.float32)):
- for i in range(n):
- B[i] = A[i] + 1
-
-
-add_one_compiled = tvm_tirx.compile(add_one, target="llvm")
-a = torch.arange(10, dtype=torch.float32)
-b = torch.empty(a.shape, dtype=a.dtype)
-add_one_compiled(a, b)
-torch.testing.assert_close(b, a + 1)
-print(b)
-# end program
+# Load add_one_cuda.so in a new Python process
+python load_add_one_cuda.py
diff --git a/include/tvm/runtime/base.h b/include/tvm/runtime/base.h
index 17c0bbefa..c79288d36 100644
--- a/include/tvm/runtime/base.h
+++ b/include/tvm/runtime/base.h
@@ -32,7 +32,7 @@
// passes the setuptools_scm-resolved version through CMake). The literal
below is the
// fallback for a bare build with no override.
#ifndef TVM_TIRX_VERSION
-#define TVM_TIRX_VERSION "0.1.0a4"
+#define TVM_TIRX_VERSION "0.1.0a5"
#endif
// Core runtime visibility is independent of TIRx compiler visibility.
diff --git a/pyproject.toml b/pyproject.toml
index 6ee2f77d2..54d6d5cf9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -17,7 +17,7 @@
[project]
name = "apache-tvm-tirx"
-version = "0.1.0a4"
+version = "0.1.0a5"
description = "TVM TIRx"
license = "Apache-2.0"
license-files = ["LICENSE"]
@@ -91,6 +91,7 @@ dev = [{ include-group = "test" }, { include-group = "lint" }]
docs = [
"sphinx>=7",
"sphinx-book-theme",
+ "sphinx-tabs",
"sphinx-autobuild",
"pytest",
"breathe!=5.0.0",
@@ -196,6 +197,7 @@ include = [
"python/**/*.py",
"tests/**/*.py",
"docs/**/*.py",
+ "examples/**/*.py",
"ci/**/*.py",
"conftest.py",
]
diff --git a/python/tvm_tirx/libinfo.py b/python/tvm_tirx/libinfo.py
index e3a49ed2b..46fa249ee 100644
--- a/python/tvm_tirx/libinfo.py
+++ b/python/tvm_tirx/libinfo.py
@@ -94,7 +94,7 @@ def find_include_path() -> str:
raise RuntimeError("Cannot find TVM include path.")
-__version__ = "0.1.0a4"
+__version__ = "0.1.0a5"
_LIBRARY_NAMES = ("tvm_tirx_compiler", "tvm_runtime")
