Tianqi Chen
96cba60464
This PR adds an autoload mechanism for out-of-tree backends, simplifies
TVM's Python library loading, and removes `TVMError` in favor of native
Python errors.
## Autoload out-of-tree backends
Out-of-tree packages can register an autoload callable under the
`tvm.backends` entry-point group (mirroring torch's device-backend
autoload). At `import tvm` startup each entry point is discovered and
its callable invoked once, after the core runtime and the `tvm`
namespace are fully initialized, so an extension can register
ops/targets/funcs or load extra libraries.
```toml
[project.entry-points."tvm.backends"]
tvm_foo = "tvm_foo:_autoload"
```
A failing extension is caught and surfaced via `warnings.warn` so it
cannot break `import tvm`. Autoload can be disabled with
`TVM_DEVICE_BACKEND_AUTOLOAD=0`.
## Simplify library loading
The library-loading path in `base.py` is consolidated around a single
`_LOADED_LIBS` dict (basename to ctypes handle) so downstream and
autoloaded extensions can skip already-loaded libraries; the per-backend
runtime DSO list is folded into `load_backend_libs`. Accumulated cruft
is removed: the Python-3.9 check, the readline shim, the `_FFI_MODE`
ctypes check, the `base.__version__` re-export, and `py_str` (call sites
inline `.decode("utf-8")`).
## Remove TVMError in favor of native Python errors
`TVMError` added a layer atop `RuntimeError` that downstream code had to
import and learn. It is removed; the registered FFI error kinds
(`InternalError`, `RPCError`, `OpError`, `DiagnosticError`,
`ScheduleError`) now subclass `RuntimeError` directly while staying
registered, so the FFI keeps throwing the right kinds. All `TVMError`
imports, `except`/`raise`/`isinstance` uses, and
`pytest.raises(tvm.TVMError)` sites move to the `RuntimeError` builtin.
111 lines
3.3 KiB
Python
111 lines
3.3 KiB
Python
# 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.
|
|
"""Util to invoke clang in the system."""
|
|
|
|
# pylint: disable=invalid-name
|
|
import subprocess
|
|
|
|
import tvm.target
|
|
|
|
from . import utils
|
|
|
|
|
|
def find_clang(required=True):
|
|
"""Find clang in system.
|
|
|
|
Parameters
|
|
----------
|
|
required : bool
|
|
Whether it is required,
|
|
runtime error will be raised if the compiler is required.
|
|
|
|
Returns
|
|
-------
|
|
valid_list : list of str
|
|
List of possible paths.
|
|
|
|
Note
|
|
----
|
|
This function will first search clang that
|
|
matches the major llvm version that built with tvm
|
|
"""
|
|
cc_list = []
|
|
major = tvm.target.codegen.llvm_version_major(allow_none=True)
|
|
if major is not None:
|
|
cc_list += [f"clang-{major}.0"]
|
|
cc_list += [f"clang-{major}"]
|
|
cc_list += ["clang"]
|
|
cc_list += ["clang.exe"]
|
|
valid_list = [utils.which(x) for x in cc_list]
|
|
valid_list = [x for x in valid_list if x]
|
|
if not valid_list and required:
|
|
raise RuntimeError("cannot find clang, candidates are: " + str(cc_list))
|
|
return valid_list
|
|
|
|
|
|
def create_llvm(inputs, output=None, options=None, cc=None):
|
|
"""Create llvm text ir.
|
|
|
|
Parameters
|
|
----------
|
|
inputs : list of str
|
|
List of input files name or code source.
|
|
|
|
output : str, optional
|
|
Output file, if it is none
|
|
a temporary file is created
|
|
|
|
options : list
|
|
The list of additional options string.
|
|
|
|
cc : str, optional
|
|
The clang compiler, if not specified,
|
|
we will try to guess the matched clang version.
|
|
|
|
Returns
|
|
-------
|
|
code : str
|
|
The generated llvm text IR.
|
|
"""
|
|
cc = cc if cc else find_clang()[0]
|
|
cmd = [cc]
|
|
cmd += ["-S", "-emit-llvm"]
|
|
temp = utils.tempdir()
|
|
output = output if output else temp.relpath("output.ll")
|
|
inputs = [inputs] if isinstance(inputs, str) else inputs
|
|
input_files = []
|
|
for i, code in enumerate(inputs):
|
|
if utils.is_source_path(code):
|
|
input_files.append(code)
|
|
else:
|
|
temp_path = temp.relpath(f"input{i}.cc")
|
|
with open(temp_path, "w") as output_file:
|
|
output_file.write(code)
|
|
input_files.append(temp_path)
|
|
if options:
|
|
cmd += options
|
|
cmd += ["-o", output]
|
|
cmd += input_files
|
|
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
|
(out, _) = proc.communicate()
|
|
if proc.returncode != 0:
|
|
msg = "Compilation error:\n"
|
|
msg += out.decode("utf-8", errors="replace")
|
|
raise RuntimeError(msg)
|
|
|
|
return open(output).read()
|