[Feat] Add runtime monitor for post-warmup TileLang compilation (#46718)
Signed-off-by: LopezCastroRoberto <rocastro@redhat.com> Signed-off-by: Roberto L. Castro <38211239+LopezCastroRoberto@users.noreply.github.com>
This commit is contained in:
+212
-1
@@ -18,13 +18,16 @@ Currently monitors:
|
||||
- Triton ``@triton.autotune`` cache misses (via ``knobs.autotuning.print``)
|
||||
- Triton ``@triton.jit`` first-time compilations
|
||||
(via ``knobs.runtime.jit_post_compile_hook``)
|
||||
- TileLang ``@tilelang.jit`` first-time compilations
|
||||
"""
|
||||
|
||||
import contextlib
|
||||
import functools
|
||||
import importlib
|
||||
import os
|
||||
from collections.abc import Iterator, Mapping
|
||||
from typing import Literal
|
||||
from contextlib import suppress
|
||||
from typing import Any, Literal, cast
|
||||
|
||||
from vllm.logger import init_logger
|
||||
from vllm.triton_utils.importing import HAS_TRITON
|
||||
@@ -36,6 +39,8 @@ _active: bool = False
|
||||
_mode: JitMonitorMode = "warn"
|
||||
_verbose: bool = False
|
||||
_cutedsl_hook_installed: bool = False
|
||||
_tilelang_hook_installed: bool = False
|
||||
_tilelang_jitimpl_compile_depth: int = 0
|
||||
|
||||
|
||||
def is_active() -> bool:
|
||||
@@ -69,6 +74,7 @@ def activate(*, mode: JitMonitorMode = "warn", verbose: bool = False) -> None:
|
||||
_setup_triton_autotuning_print()
|
||||
_setup_triton_jit_hook()
|
||||
_setup_cutedsl_jit_hook()
|
||||
_setup_tilelang_jit_hook()
|
||||
|
||||
logger.info(
|
||||
"Kernel JIT monitor activated; monitored JIT compilations during "
|
||||
@@ -290,6 +296,211 @@ def _setup_cutedsl_jit_hook() -> None:
|
||||
_cutedsl_hook_installed = True
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# TileLang JIT compilation hook
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
|
||||
def _tilelang_arg(
|
||||
args: tuple[object, ...],
|
||||
kwargs: Mapping[str, object],
|
||||
index: int,
|
||||
name: str,
|
||||
default: object = None,
|
||||
) -> object:
|
||||
if len(args) > index:
|
||||
return args[index]
|
||||
return kwargs.get(name, default)
|
||||
|
||||
|
||||
def _tilelang_kernel_name(func: object) -> str:
|
||||
attrs = getattr(func, "attrs", None)
|
||||
global_symbol = None
|
||||
get_attr = getattr(attrs, "get", None)
|
||||
if callable(get_attr):
|
||||
try:
|
||||
global_symbol = get_attr("global_symbol")
|
||||
except Exception:
|
||||
global_symbol = None
|
||||
elif isinstance(attrs, Mapping):
|
||||
global_symbol = attrs.get("global_symbol")
|
||||
|
||||
if global_symbol is not None:
|
||||
return str(global_symbol)
|
||||
|
||||
name = getattr(func, "__name__", None)
|
||||
if name is not None:
|
||||
return str(name)
|
||||
return func.__class__.__name__ if func is not None else "<unknown>"
|
||||
|
||||
|
||||
def _tilelang_call_kwargs(kwargs: Mapping[str, object]) -> dict[str, object]:
|
||||
call_kwargs = dict(kwargs)
|
||||
tune_params = call_kwargs.pop("__tune_params", {})
|
||||
if isinstance(tune_params, Mapping):
|
||||
call_kwargs.update(tune_params)
|
||||
return call_kwargs
|
||||
|
||||
|
||||
def _tilelang_cache_miss_key(
|
||||
jit_impl: object,
|
||||
args: tuple[object, ...],
|
||||
kwargs: Mapping[str, object],
|
||||
) -> object | None:
|
||||
if kwargs.get("__return_compile_arguments", False):
|
||||
return None
|
||||
|
||||
call_kwargs = _tilelang_call_kwargs(kwargs)
|
||||
func = getattr(jit_impl, "func", None)
|
||||
parse_args = getattr(func, "parse_args", None)
|
||||
if not callable(parse_args):
|
||||
return None
|
||||
|
||||
try:
|
||||
if getattr(jit_impl, "mode", None) == "auto":
|
||||
impl = cast(Any, jit_impl)
|
||||
mode = impl._infer_jit_mode(*args, **call_kwargs)
|
||||
impl.mode = mode
|
||||
if func is not None:
|
||||
func.set_mode(mode)
|
||||
key, _ = parse_args(*args, **call_kwargs)
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
cache = getattr(jit_impl, "_kernel_cache", {})
|
||||
if isinstance(cache, Mapping):
|
||||
return key if key not in cache else None
|
||||
|
||||
get = getattr(cache, "get", None)
|
||||
if not callable(get):
|
||||
return key
|
||||
try:
|
||||
return key if get(key) is None else None
|
||||
except Exception:
|
||||
return key
|
||||
|
||||
|
||||
def _format_tilelang_runtime_shapes(
|
||||
jit_impl: object,
|
||||
args: tuple[object, ...],
|
||||
kwargs: Mapping[str, object],
|
||||
) -> str:
|
||||
signature = getattr(jit_impl, "signature", None)
|
||||
bind_partial = getattr(signature, "bind_partial", None)
|
||||
if not callable(bind_partial):
|
||||
return "{}"
|
||||
|
||||
try:
|
||||
bound = bind_partial(*args, **_tilelang_call_kwargs(kwargs))
|
||||
bound.apply_defaults()
|
||||
except Exception:
|
||||
return "{}"
|
||||
|
||||
items = []
|
||||
for name, value in bound.arguments.items():
|
||||
if str(name).startswith("__"):
|
||||
continue
|
||||
if not (hasattr(value, "shape") and hasattr(value, "dtype")):
|
||||
continue
|
||||
shape = getattr(value, "shape", None)
|
||||
if shape is not None:
|
||||
with suppress(TypeError):
|
||||
shape = tuple(shape)
|
||||
items.append(f"{name}={_safe_repr(shape, max_len=80)}")
|
||||
return "{" + ", ".join(items) + "}"
|
||||
|
||||
|
||||
def _format_verbose_tilelang_compile_details(
|
||||
jit_impl: object,
|
||||
args: tuple[object, ...],
|
||||
kwargs: Mapping[str, object],
|
||||
cache_key: object,
|
||||
) -> str:
|
||||
return (
|
||||
f"cache_key={_safe_repr(cache_key, max_len=400)}; "
|
||||
f"runtime_shapes={_format_tilelang_runtime_shapes(jit_impl, args, kwargs)}"
|
||||
)
|
||||
|
||||
|
||||
def _log_tilelang_jit_compile(
|
||||
fn_name: str,
|
||||
detail: str | None = None,
|
||||
) -> None:
|
||||
_handle_jit_event(
|
||||
backend="TileLang",
|
||||
event="JIT compilation",
|
||||
fn_name=fn_name,
|
||||
detail=detail,
|
||||
)
|
||||
|
||||
|
||||
def _setup_tilelang_jit_hook() -> None:
|
||||
"""Wrap TileLang JIT entry points to warn on compilation."""
|
||||
global _tilelang_hook_installed
|
||||
if _tilelang_hook_installed:
|
||||
return
|
||||
|
||||
try:
|
||||
tilelang_kernel = importlib.import_module("tilelang.jit.kernel")
|
||||
except Exception:
|
||||
logger.debug("TileLang is not available; skipping TileLang JIT monitor.")
|
||||
return
|
||||
|
||||
jit_kernel_cls = getattr(tilelang_kernel, "JITKernel", None)
|
||||
if jit_kernel_cls is None:
|
||||
logger.debug(
|
||||
"TileLang JITKernel is unavailable; skipping TileLang JIT monitor."
|
||||
)
|
||||
return
|
||||
|
||||
try:
|
||||
tilelang_jit = importlib.import_module("tilelang.jit")
|
||||
except Exception:
|
||||
tilelang_jit = None
|
||||
jit_impl_cls = getattr(tilelang_jit, "JITImpl", None)
|
||||
original_init = jit_kernel_cls.__init__
|
||||
|
||||
@functools.wraps(original_init)
|
||||
def _init_with_monitor(self, *args, **kwargs):
|
||||
from_database = bool(_tilelang_arg(args, kwargs, 7, "from_database", False))
|
||||
if not from_database and _tilelang_jitimpl_compile_depth == 0:
|
||||
func = _tilelang_arg(args, kwargs, 0, "func")
|
||||
_log_tilelang_jit_compile(_tilelang_kernel_name(func))
|
||||
return original_init(self, *args, **kwargs)
|
||||
|
||||
jit_kernel_cls.__init__ = _init_with_monitor
|
||||
|
||||
if jit_impl_cls is not None:
|
||||
original_call = jit_impl_cls.__call__
|
||||
|
||||
@functools.wraps(original_call)
|
||||
def _call_with_monitor(self, *args, **kwargs):
|
||||
global _tilelang_jitimpl_compile_depth
|
||||
cache_key = _tilelang_cache_miss_key(self, args, kwargs)
|
||||
if cache_key is None:
|
||||
return original_call(self, *args, **kwargs)
|
||||
|
||||
_tilelang_jitimpl_compile_depth += 1
|
||||
try:
|
||||
detail = None
|
||||
if _verbose:
|
||||
detail = _format_verbose_tilelang_compile_details(
|
||||
self, args, kwargs, cache_key
|
||||
)
|
||||
func = getattr(self, "func", None)
|
||||
orig_func = getattr(func, "orig_func", None)
|
||||
_log_tilelang_jit_compile(
|
||||
_tilelang_kernel_name(orig_func or func), detail
|
||||
)
|
||||
return original_call(self, *args, **kwargs)
|
||||
finally:
|
||||
_tilelang_jitimpl_compile_depth -= 1
|
||||
|
||||
jit_impl_cls.__call__ = _call_with_monitor
|
||||
|
||||
_tilelang_hook_installed = True
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def numba_workqueue_threading_layer() -> Iterator[None]:
|
||||
"""Force numba's fork-safe `workqueue` threading layer for this block.
|
||||
|
||||
Reference in New Issue
Block a user