Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 6 additions & 3 deletions laya/tl_kernels.py
Original file line number Diff line number Diff line change
Expand Up @@ -2,9 +2,12 @@

GPU kernels take 16-bit activations (bf16 by default, fp16 with dtype="float16"), accumulate in fp32.
Row count M is a runtime symbol so one compiled kernel serves every batch/sequence bucket: the
caller in `laya.backends.base.pad_batch` pads the batch dim to the next power of two
(`bucket_rows`, so a single question stays one row) and the sequence dim to a 16-token bucket
up to `DYNAMIC_MAX_L` and a 64-token bucket beyond (`bucket_tokens`). M is the flattened
caller, `laya.fast.FastLaya._forward_unlocked`, pads the batch dim to the next power of two
(`laya.backends.base.bucket_rows`, so a single question stays one row) and the sequence dim to a
16-token bucket up to `DYNAMIC_MAX_L` and a 64-token bucket beyond -- the policy
`laya.backends.base.bucket_tokens` implements, which `_forward_unlocked` repeats against its own
`FastLaya.DYNAMIC_MAX_L`/`LONG_BUCKET` instead of calling it. `laya.backends.base.pad_batch` applies
that policy for the compile route, which never reaches these kernels. M is the flattened
`rows * tokens`, so the multiple-of-16 comes from the token dim, not the row dim; out-of-bounds
rows are predicated by TileLang's `T.ceildiv(M, bm)`, so the kernels themselves place no
constraint on M. Use compile_cpu for an explicit fp32 CPU specialization; the GPU defaults are unchanged.
Expand Down
142 changes: 141 additions & 1 deletion tests/test_confidence.py
Original file line number Diff line number Diff line change
Expand Up @@ -2041,9 +2041,149 @@ def test_bucket_rows_stays_a_power_of_two_below_16():
"expect 16 here" % (n, bucket_rows(n)))


# ------------------------------- and the caller it names has to be on the kernels' own route
# The attribution was the second half of the same defect. The docstring called
# `laya.backends.base.pad_batch` "the caller" of these kernels, but `pad_batch` serves the
# `backend="compile"` route: it has exactly one production call site, `laya/backends/compile.py:111`,
# and `laya/fast.py:10` is the only module in the package that imports `tl_kernels`. Those two sets
# being disjoint is what makes the sentence false, and nothing in the tree checked either one. The
# padding on the TileLang route happens in `FastLaya._forward_unlocked`, which takes its row bucket
# from `bucket_rows` (through `_bucket_n`) but *inlines* the token bucketing against its own
# `FastLaya.DYNAMIC_MAX_L`/`LONG_BUCKET` class attributes rather than calling `bucket_tokens`. So a
# maintainer who retuned `pad_batch` or `bucket_tokens` for TileLang padding changed nothing on the
# TileLang route, and no test said so. All three checks below read the call graph out of the AST --
# no `tilelang` import, so they run on a CPU-only box where the fast path cannot execute.

FAST_REL = "laya/fast.py"
COMPILE_REL = "laya/backends/compile.py"
_BAN_PAD_BATCH_CALLER = re.compile(r"caller(?:,| in) [`\w.]*pad_batch", re.I)


def _laya_trees():
"""`[(slash-relative path, parsed AST)]` for every module under `laya/`."""
out = []
for base, _dirs, files in os.walk(os.path.join(ROOT, "laya")):
for name in sorted(files):
if not name.endswith(".py") or "__pycache__" in base:
continue
path = os.path.join(base, name)
with open(path, encoding="utf-8") as fh:
out.append((path[len(ROOT) + 1:].replace(os.sep, "/"), ast.parse(fh.read(), filename=path)))
return out


def _modules_calling(trees, fname):
"""Paths of the `laya/` modules containing a call node for `fname`."""
hits = set()
for rel, tree in trees:
for node in ast.walk(tree):
func = node.func if isinstance(node, ast.Call) else None
if func is not None and ((isinstance(func, ast.Name) and func.id == fname)
or (isinstance(func, ast.Attribute) and func.attr == fname)):
hits.add(rel)
return hits


def _modules_importing(trees, mod):
"""Paths of the `laya/` modules that import `mod`, `from . import mod` included."""
hits = set()
for rel, tree in trees:
for node in ast.walk(tree):
if isinstance(node, ast.ImportFrom) and any(a.name == mod for a in node.names):
hits.add(rel)
elif isinstance(node, ast.Import):
if any(a.name.split(".")[-1] == mod for a in node.names):
hits.add(rel)
return hits


def _unparsed_function(rel, funcname):
"""One function's body, `ast.unparse`d, so the check reads the code rather than its comments."""
with open(os.path.join(ROOT, rel), encoding="utf-8") as fh:
tree = ast.parse(fh.read(), filename=rel)
for node in ast.walk(tree):
if isinstance(node, ast.FunctionDef) and node.name == funcname:
return ast.unparse(node)
raise AssertionError("%s has no function %s() -- the docstring cites a moved symbol" % (rel, funcname))


def _class_constant(rel, classname, const):
"""A class-level `CONST = <literal>`, read without importing the module (this one needs tilelang)."""
with open(os.path.join(ROOT, rel), encoding="utf-8") as fh:
tree = ast.parse(fh.read(), filename=rel)
for node in ast.walk(tree):
if isinstance(node, ast.ClassDef) and node.name == classname:
for stmt in node.body:
if isinstance(stmt, ast.Assign):
for target in stmt.targets:
if isinstance(target, ast.Name) and target.id == const:
if isinstance(stmt.value, ast.Constant):
return stmt.value.value
raise AssertionError("no `%s.%s = <literal>` in %s -- the docstring cites a moved constant"
% (classname, const, rel))


def test_tl_kernels_names_a_caller_that_is_on_the_kernels_route():
"""`pad_batch` never reaches these kernels, so it cannot be the caller the docstring names."""
trees = _laya_trees()
kernel_importers = _modules_importing(trees, "tl_kernels")
pad_batch_callers = _modules_calling(trees, "pad_batch")
assert kernel_importers == {FAST_REL}, (
"the `laya/` modules importing `tl_kernels` are now %s; the docstring describes one caller, "
"so a second route needs its own sentence" % sorted(kernel_importers))
assert pad_batch_callers == {COMPILE_REL}, (
"`pad_batch` is now called from %s, not only from `%s`; if a route from there reaches "
"`tl_kernels`, the docstring's caller may genuinely be `pad_batch` again -- re-read both "
"before editing" % (sorted(pad_batch_callers), COMPILE_REL))
assert not (kernel_importers & pad_batch_callers), (
"`pad_batch` is on the `tl_kernels` route after all, so this ban is stale -- re-read the "
"call graph rather than deleting the sentence it caught")
doc = _tl_docstring()
assert not _BAN_PAD_BATCH_CALLER.search(doc), (
"`laya/tl_kernels.py` again calls `laya.backends.base.pad_batch` the caller of these "
"kernels. Its one production call site is `laya/backends/compile.py:111`, and "
"`laya/fast.py:10` is the only module that imports `tl_kernels`; the padding these kernels "
"see happens in `FastLaya._forward_unlocked`.")
assert "laya.fast" in doc and "_forward_unlocked" in doc, (
"the docstring must name the caller the call graph actually gives these kernels")


def test_the_fast_path_still_inlines_the_token_bucket_the_docstring_says_it_repeats():
"""`_forward_unlocked` mirrors `bucket_tokens`'s arithmetic against its own constants."""
body = _unparsed_function(FAST_REL, "_forward_unlocked")
assert "self.DYNAMIC_MAX_L" in body and "self.LONG_BUCKET" in body, (
"`_forward_unlocked` no longer buckets tokens against the `FastLaya` class constants, so "
"the docstring's 'repeats against its own `FastLaya.DYNAMIC_MAX_L`/`LONG_BUCKET`' is stale")
assert "bucket_tokens(" not in body, (
"`_forward_unlocked` calls `bucket_tokens` directly now; then there is one policy rather "
"than two copies, and both the docstring and this check need re-reading")
assert "_bucket_n(" in body or "bucket_rows(" in body, (
"the row pad no longer comes from `laya.backends.base.bucket_rows`, through `_bucket_n` or "
"directly, so the docstring's attribution needs re-reading")


def test_the_two_bucket_policies_the_docstring_describes_are_still_the_same_numbers():
"""One sentence covers both routes only while the duplicated constants agree."""
from laya.backends.base import DYNAMIC_MAX_L, LONG_BUCKET
fast_max_l = _class_constant(FAST_REL, "FastLaya", "DYNAMIC_MAX_L")
fast_long = _class_constant(FAST_REL, "FastLaya", "LONG_BUCKET")
assert (fast_max_l, fast_long) == (DYNAMIC_MAX_L, LONG_BUCKET), (
"`FastLaya` buckets at (%s, %s) while `laya.backends.base` buckets at (%s, %s). "
"`laya/tl_kernels.py`'s docstring describes one policy for these kernels; once the two "
"copies differ it has to name both, and its `16`/`%d` numbers need re-reading."
% (fast_max_l, fast_long, DYNAMIC_MAX_L, LONG_BUCKET, LONG_BUCKET))
doc = _tl_docstring()
assert "16-token bucket" in doc, "the docstring no longer states the small token bucket"
assert "%d-token bucket" % LONG_BUCKET in doc, (
"the docstring no longer states the large token bucket the code uses (`%d`)" % LONG_BUCKET)


for _fn in (test_tl_kernels_drops_the_wrong_row_claim,
test_tl_kernels_names_the_real_padding_policy,
test_bucket_rows_stays_a_power_of_two_below_16):
test_bucket_rows_stays_a_power_of_two_below_16,
test_tl_kernels_names_a_caller_that_is_on_the_kernels_route,
test_the_fast_path_still_inlines_the_token_bucket_the_docstring_says_it_repeats,
test_the_two_bucket_policies_the_docstring_describes_are_still_the_same_numbers):
try:
_fn()
except AssertionError as e:
Expand Down
Loading