Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

9.8 KB
Raw Blame
#!/usr/bin/env python3

import json
import re
import subprocess
import sys
import tempfile
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
METAL = ROOT / "crates/uzu-engine/src/backends/metal/kernel"
SLANG = ROOT / "crates/uzu-engine/src/backends/slang/kernel"


def annotations(node):
    def strings(child):
        if child["kind"] == "StringLiteral":
            yield json.loads(child["value"])
        for nested in child.get("inner", []):
            yield from strings(nested)

    return [
        list(strings(child))
        for child in node.get("inner", [])
        if child["kind"] == "AnnotateAttr"
    ]


def generate(path, cache):
    source = path.read_bytes()
    result = subprocess.run(
        [
            "xcrun",
            "-sdk",
            "macosx",
            "metal",
            "-x",
            "metal",
            "-std=metal4.0",
            "-mmacosx-version-min=26.4",
            f"-fmodules-cache-path={cache}",
            "-I",
            str(METAL / "generated"),
            "-DDSL_ANALYZE",
            str(path),
            "-fsyntax-only",
            "-Xclang",
            "-ast-dump=json",
        ],
        check=True,
        capture_output=True,
        text=True,
    )
    ast = json.loads(result.stdout)
    imports = set()
    defines = {}
    visited = set()

    def read_constants(header):
        header = header.resolve()
        if header in visited:
            return
        visited.add(header)
        text = header.read_text(encoding="utf-8")
        for include in re.findall(r'^\s*#include "([^"\n]+)"', text, re.M):
            dependency = header.parent / include
            if not dependency.exists():
                dependency = METAL / "generated" / include
            if dependency.exists():
                read_constants(dependency)
        defines.update(re.findall(r"^\s*#define[ \t]+(\w+)[ \t]+([^\n]+)", text, re.M))
        defines.update(
            re.findall(
                r"(?:static constant constexpr|UZU_CONST)\s+\w+\s+(\w+)\s*=\s*([^;]+);",
                text,
            )
        )

    read_constants(path)

    def expression(value):
        for _ in range(len(defines) + 1):
            expanded = re.sub(r"\b\w+\b", lambda m: defines.get(m[0], m[0]), value)
            if expanded == value:
                return re.sub(r"\b(\d+)[uU]\b", r"\1", value)
            value = expanded
        raise ValueError(f"{path}: recursive macro in {value}")

    def slang_type(ty, generics=()):
        if ty in generics:
            return ty
        if match := re.fullmatch(
            r"(char|uchar|short|ushort|int|uint|float|half)([234])", ty
        ):
            return f"vector<{slang_type(match[1])}, {match[2]}>"
        if ty.startswith("uzu::"):
            _, module, name = ty.split("::")
            imports.add(f"import generated.{module};")
            return name
        types = {
            "float": "float",
            "half": "half",
            "bfloat": "BFloat16",
            "bfloat16_t": "BFloat16",
            "bool": "bool",
            "char": "int8_t",
            "signed char": "int8_t",
            "short": "int16_t",
            "int8_t": "int8_t",
            "uchar": "uint8_t",
            "unsigned char": "uint8_t",
            "uint8_t": "uint8_t",
            "ushort": "uint16_t",
            "uint16_t": "uint16_t",
            "int": "int32_t",
            "int32_t": "int32_t",
            "uint": "uint32_t",
            "uint32_t": "uint32_t",
            "unsigned int": "uint32_t",
            "uint64_t": "uint64_t",
            "unsigned long": "uint64_t",
            "_atomic<uint>": "uint32_t",
            "ThreadContext": "ThreadContext",
        }
        if ty not in types:
            raise ValueError(f"unsupported Metal type {ty!r}")
        return types[ty]

    kernels = []
    for node in ast["inner"]:
        template = []
        if node["kind"] == "FunctionTemplateDecl":
            template = [
                n
                for n in node["inner"]
                if n["kind"] in ("TemplateTypeParmDecl", "NonTypeTemplateParmDecl")
            ]
            node = next(n for n in node["inner"] if n["kind"] == "FunctionDecl")
        if node["kind"] != "FunctionDecl":
            continue
        attrs = annotations(node)
        if ["dsl.public"] not in attrs or ["dsl.kernel"] not in attrs:
            continue
        parameters = [n for n in node["inner"] if n["kind"] == "ParmVarDecl"]
        generic_names = {n["name"] for n in template}
        generics, lines, arguments = [], [], []
        variants = {a[1]: a[2] for a in attrs if a[0] == "dsl.variants"}
        for param in template:
            name = param["name"]
            is_type = param["kind"] == "TemplateTypeParmDecl"
            generics.append(
                name
                if is_type
                else f"let {name}: {slang_type(param['type']['qualType'])}"
            )
            if name not in variants:
                raise ValueError(f"{node['name']}: missing VARIANTS for {name}")
            values = [v.strip() for v in variants[name].split(",")]
            if is_type:
                values = [slang_type(v) for v in values]
            lines.append(
                f"[[Variants({json.dumps(name)}, {json.dumps(', '.join(values))})]]"
            )
        for param in parameters:
            name = param["name"]
            ty = param["type"].get("desugaredQualType", param["type"]["qualType"])
            if "threadgroup" in ty.split():
                # Scratch storage belongs to the implementation, not the public API.
                continue
            attrs = annotations(param)
            attr = attrs[0] if attrs else []
            if attr and attr[0] in ("dsl.axis", "dsl.groups", "dsl.threads"):
                annotation = attr[0].removeprefix("dsl.").capitalize()
                values = ", ".join(json.dumps(expression(v)) for v in attr[1:])
                arguments.append(f"  [[{annotation}({values})]] uint32_t {name},")
                continue
            element = re.sub(
                r"\b(const|device|constant|threadgroup)\b|[&*()]|\[[^]]*\]", "", ty
            ).strip()
            element = " ".join(element.split())
            element = slang_type(element, generic_names)
            begin, end = param["range"]["begin"], param["range"]["end"]
            begin, end = begin.get("spellingLoc", begin), end.get("spellingLoc", end)
            declaration = source[
                begin["offset"] : end["offset"] + end["tokLen"]
            ].decode("utf-8")
            array = re.search(r"\[([^]]+)\]", declaration)
            if "device" in ty.split():
                access = (
                    "StructuredBuffer"
                    if "const" in ty.split()
                    else "RWStructuredBuffer"
                )
                ty = f"{access}<{element}>"
            elif "constant" in ty.split() and "*" in ty:
                ty = (
                    f"{element}[{expression(array[1])}]"
                    if array
                    else f"[[Constant]] StructuredBuffer<{element}>"
                )
            else:
                ty = element
            prefix = ""
            if attr:
                if attr[0] == "dsl.optional":
                    prefix = f"[[Optional({json.dumps(expression(attr[1]))})]] "
                elif attr[0] in ("dsl.specialize", "dsl.specialize_if"):
                    prefix = "[[Specialize]] "
                    if attr[0] == "dsl.specialize_if":
                        prefix += f"[[Optional({json.dumps(expression(attr[1]))})]] "
                else:
                    raise ValueError(f"{path}: unsupported annotation {attr}")
            arguments.append(f"  {prefix}{ty} {name},")
        for attr in annotations(node):
            if attr[0] == "dsl.constraint":
                lines.append(f"[[Constraint({json.dumps(expression(attr[1]))})]]")
        generic = f"<{', '.join(generics)}>" if generics else ""
        lines.extend(
            [
                f"[[Public]] [[Kernel]] func {node['name']}{generic}(",
                *arguments,
                ") {",
                "  // TODO",
                "}",
            ]
        )
        kernels.append("\n".join(lines))
    if not kernels:
        return None
    return "\n".join(
        [
            "// Autogenerated stub",
            "import definitions;",
            *sorted(imports),
            "",
            "\n\n".join(kernels),
            "",
        ]
    )


def main():
    generated = {}
    skipped = 0
    with tempfile.TemporaryDirectory(prefix="uzu-slang-autogen-") as cache:
        for path in sorted(METAL.rglob("*.metal")):
            if not re.search(r"\bPUBLIC\b", path.read_text(encoding="utf-8")):
                continue
            destination = SLANG / path.relative_to(METAL).with_suffix(".slang")
            if destination.exists() and not destination.read_text(
                encoding="utf-8"
            ).startswith("// Autogenerated stub"):
                skipped += 1
                continue
            try:
                content = generate(path, cache)
            except subprocess.CalledProcessError as error:
                sys.exit(f"{path}: Metal analysis failed:\n{error.stderr}")
            except (OSError, ValueError) as error:
                sys.exit(f"{path}: {error}")
            if content:
                generated[destination] = content
    for path, content in generated.items():
        path.parent.mkdir(parents=True, exist_ok=True)
        if not path.exists() or path.read_text(encoding="utf-8") != content:
            path.write_text(content, encoding="utf-8")
    count = sum(s.count("[[Public]]") for s in generated.values())
    print(
        f"Generated {count} public kernel stubs in {len(generated)} files; "
        f"skipped {skipped} existing files."
    )


if __name__ == "__main__":
    main()