offtarget 0.1.0__py3-none-any.whl

offload/engine/clang_oracle.py

@@ -0,0 +1,208 @@
+"""Cross-check C programs and directives against AFAR amdclang's frontend
+(the C analogue of ``offload.engine.flang_oracle``).
+
+amdclang (ROCm/llvm-project, 24.0.0git, the AFAR drop under test) is an
+OPINION, never the authority: the spec wins when the two disagree, and
+``compare`` reports the disagreement instead of hiding it.
+
+Invocation: ``amdclang -fopenmp -fopenmp-version=<52|60> -fsyntax-only``
+on the whole C source (host-side semantic analysis of the OpenMP
+directives; no device compilation, no code generation), and with
+``-Xclang -ast-dump`` for the clause lists of each OpenMP directive
+(``OMP<Name>Directive`` nodes and their ``OMP<Name>Clause`` children).
+The OpenMP version flag is explicit for both versions (clang's default is
+5.1 in this build's documentation; 5.2 syntax is diagnosed under it), so
+a 5.2 program is checked as 5.2.
+"""
+from __future__ import annotations
+
+import re
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from shlex import quote
+
+from offload.engine.catalog import default_skeleton
+from offload.engine.flang_oracle import Agreement, verdict_of  # noqa: F401
+from offload.engine.grammar import GrammarError, parse_directive
+from offload.engine.toolchains import TOOLCHAINS
+
+_TC = TOOLCHAINS["afar"]
+_TIMEOUT = 180
+
+
+class ClangError(Exception):
+    """clang could not be run (`stage` "run"), did not finish ("timeout":
+    a frontend hang is a finding, e.g. requires device_safesync), or an AST
+    clause node has no known spelling ("map")."""
+
+    def __init__(self, stage: str, message: str):
+        super().__init__(f"{stage}: {message}")
+        self.stage = stage
+        self.message = message
+
+
+@dataclass(frozen=True)
+class Check:
+    ok: bool
+    errors: tuple[str, ...]   # the "error:" lines (file name masked)
+    output: str
+
+
+def _run(source: str, version: int | None, extra: str = "") -> tuple[int,
+                                                                       str,
+                                                                       str]:
+    from offload.engine.harness import _execute
+    vflag = f" -fopenmp-version={version}" if version else ""
+    with tempfile.TemporaryDirectory(prefix="clang_oracle_") as d:
+        src = Path(d) / "t.c"
+        src.write_text(source)
+        script = (f"{_TC.prelude}\n" if _TC.prelude else "") + (
+            f"{_TC.cc} -fopenmp{vflag} -fsyntax-only {extra} "
+            f"{quote(str(src))}")
+        # its own process group, killed at the timeout (a hanging clang
+        # frontend must not outlive the call: found two hangs)
+        res = _execute(script, Path(d), _TIMEOUT)
+        if res.timed_out:
+            raise ClangError("timeout", f"clang did not finish in "
+                                        f"{_TIMEOUT}s")
+        err = res.stderr.replace(str(src), "t.c")
+    if res.rc != 0 and "error:" not in err:
+        raise ClangError("run", f"rc={res.rc}: {err.strip()}")
+    return res.rc, res.stdout, err
+
+
+def syntax_check(source: str, version: int) -> Check:
+    """amdclang's frontend verdict on a whole C program."""
+    rc, _, err = _run(source, version)
+    errors = tuple(ln.strip() for ln in err.splitlines()
+                   if re.search(r"\berror:", ln))
+    return Check(rc == 0, errors, err)
+
+
+_DIRECTIVE = re.compile(r"^(?P<ind>[\s|`-]*)OMP(?P<name>\w+)Directive ")
+_CLAUSE = re.compile(r"^(?P<ind>[\s|`-]*)OMP(?P<name>\w+)Clause ")
+# AST clause node -> clause spelling where snake_casing the node name is not
+# the spelling
+CLAUSE_NODE_SPELLING = {"DeviceType": "device_type",
+                        "Dynamic_allocators": "dynamic_allocators"}
+
+
+def _spelling(node: str) -> str:
+    sp = CLAUSE_NODE_SPELLING.get(node) or re.sub(
+        r"(?<=[a-z0-9])(?=[A-Z])", "_", node).lower()
+    if sp not in default_skeleton().clauses:
+        raise ClangError("map", f"clang clause node {node!r} maps to {sp!r}, "
+                                "which is not a catalog clause")
+    return sp
+
+
+def clang_clauses(source: str, version: int) -> list[list[str]]:
+    """One clause list per OpenMP executable directive of the AST, in
+    source order (declarative directives have other node kinds)."""
+    rc, out, err = _run(source, version, "-Xclang -ast-dump")
+    if rc != 0:
+        raise ClangError("run", f"ast dump failed: {err.strip()[:400]}")
+    groups: list[list[str]] = []
+    depth = None
+    for line in out.splitlines():
+        m = _DIRECTIVE.match(line)
+        if m:
+            groups.append([])
+            depth = len(m.group("ind"))
+            continue
+        m = _CLAUSE.match(line)
+        if m and groups and depth is not None and \
+                len(m.group("ind")) == depth + 2:
+            groups[-1].append(_spelling(m.group("name")))
+    return groups
+
+
+# --- one directive -----------------------------------------------------------------
+
+_STANDALONE = {"target enter data", "target exit data", "target update"}
+_FILE_SCOPE = {"declare target", "requires", "begin declare target"}
+
+
+def wrap_directive(text: str, version: int) -> str | None:
+    """A minimal C program around one directive (``#pragma omp ...``): the
+    declarations its list items may name (scalars x, y, s; arrays a, b of
+    64 ints; pointer p), a structured block or a canonical for loop nest
+    as its association needs; None for a directive this wrapper does not
+    place."""
+    from offload.engine.rules import association
+    try:
+        d = parse_directive(text, "c", version)
+        key = d.name
+    except GrammarError:
+        m = re.match(r"^\s*#\s*pragma\s+omp\s+((?:\w+\s*)+)", text)
+        key = None
+        if m:
+            words = m.group(1).split()
+            for k in range(len(words), 0, -1):
+                cand = " ".join(words[:k])
+                if cand in default_skeleton().directives:
+                    key = cand
+                    break
+        if key is None:
+            return None
+    decls = ["int x = 0, y = 0, s = 0, n = 64, i, j;", "int a[64], b[64];",
+             "int *p = a;"]
+    if key in _FILE_SCOPE:
+        if key == "begin declare target":
+            return (text + "\nint g;\n#pragma omp end declare target\n"
+                    "int main(void) { return g; }\n")
+        return ("int x = 0, y = 0;\nint f(int v) { return v; }\n" + text
+                + "\nint main(void) { return x; }\n")
+    how = association(key)
+    body = ["int main(void) {"] + ["  " + x for x in decls]
+    if how == "loop":
+        n = 1
+        m = re.search(r"\bcollapse\s*\(\s*(\d+)", text)
+        if m:
+            n = int(m.group(1))
+        body.append("  " + text)
+        for k in range(n):
+            v = "ij"[k] if k < 2 else f"k{k}"
+            body.append("  " * (k + 1) + f"for ({'int ' if k > 1 else ''}"
+                        f"{v} = 0; {v} < 8; {v}++)")
+        body.append("  " * (n + 1) + "b[0] = a[0];")
+    elif how in ("block", "statement"):
+        body += ["  " + text, "  {", "    b[0] = a[0];", "  }"]
+    elif key in _STANDALONE or how == "standalone":
+        body.append("  " + text)
+    else:
+        return None
+    body += ["  return 0;", "}"]
+    return "\n".join(body) + "\n"
+
+
+def compare(directive_text: str, version: int) -> Agreement:
+    """Do the spec grammar and amdclang agree about one ``#pragma omp``
+    directive? (``Agreement`` of offload.engine.flang_oracle; flang_* fields
+    hold clang's answer.)"""
+    try:
+        d = parse_directive(directive_text, "c", version)
+        grammar_ok, mine, gnote = True, sorted(c.name for c in d.clauses), ""
+    except GrammarError as e:
+        grammar_ok, mine, gnote = False, None, str(e)
+    src = wrap_directive(directive_text, version)
+    if src is None:
+        return Agreement(grammar_ok, False, None,
+                         note=f"no wrapper for this directive; clang not "
+                              f"consulted. {gnote}".strip(),
+                         consulted=False, flang_stage="skipped")
+    chk = syntax_check(src, version)
+    theirs = None
+    if chk.ok:
+        try:
+            theirs = clang_clauses(src, version)
+        except ClangError as e:
+            if e.stage == "map":
+                raise
+    same = None
+    if mine is not None and theirs is not None and theirs:
+        same = sorted(c for g in theirs[:1] for c in g) == mine
+    return Agreement(grammar_ok, chk.ok, same,
+                     "; ".join(chk.errors) if not chk.ok else None, gnote,
+                     True, "ok" if chk.ok else "semantics")

offload/engine/combos.py

@@ -0,0 +1,234 @@
+"""Directive combination matrix.
+
+For every ordering of two or three distinct leaf directives of ``LEAVES``
+(target, teams, distribute, parallel, do, simd, loop, and at 6.0
+workdistribute) this module builds two small free-form programs: ``combined``,
+one compound directive naming the leaves in that order (``!$omp teams target``),
+and ``nested``, the leaves as separate constructs, each inside the previous.
+
+Each is classified by the spec, independently of ``offload.engine.rules``.
+``spec_combined`` says whether the name is a conforming compound directive
+(5.2: section 17.3; 6.0: the Appendix D grammar). ``spec_nested`` says whether
+the nesting conforms, from the ``DIRECT`` table and the region-wide rules.
+``ours`` is the catalog's answer (the grammar parses every directive and
+``offload.engine.rules.violations`` is empty). ``flang`` (tools/
+combination_matrix.py) is AFAR amdflang's check of the same program.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from itertools import permutations
+
+from offload.engine.grammar import GrammarError
+from offload.engine.rules import ProgramError, parse_program, violations
+
+BASE = ("target", "teams", "distribute", "parallel", "do", "simd", "loop")
+LEAVES = {52: BASE, 60: BASE + ("workdistribute",)}
+LOOP_LEAVES = {"distribute", "do", "simd", "loop"}
+SIZES = (2, 3)
+
+
+def orders(version: int, sizes=SIZES) -> list[tuple[str, ...]]:
+    return [p for k in sizes for p in permutations(LEAVES[version], k)]
+
+
+# --- programs ----------------------------------------------------------------------
+
+_HEAD = ["program p", "  implicit none", "  integer, parameter :: n = 8",
+         "  integer :: i, j, k", "  real :: a(n), b(n)", "  a = 1.0",
+         "  b = 0.0"]
+_TAIL = ["  print *, b(1)", "end program p"]
+
+
+def combined_source(seq: tuple) -> str:
+    name = " ".join(seq)
+    if set(seq) & LOOP_LEAVES:
+        body = ["do i = 1, n", "  b(i) = a(i)", "end do"]
+    elif "workdistribute" in seq:
+        body = ["b = a"]
+    else:
+        body = ["b(1) = a(1)"]
+    lines = [f"!$omp {name}"] + body + [f"!$omp end {name}"]
+    return "\n".join(_HEAD + ["  " + x for x in lines] + _TAIL) + "\n"
+
+
+def _nest(seq: tuple, loops: int) -> list[str]:
+    var = "ijk"[loops - 1] if loops else None
+    if not seq:
+        return [f"b({var}) = a({var})" if var else "b(1) = a(1)"]
+    leaf, rest = seq[0], seq[1:]
+    if leaf in LOOP_LEAVES:
+        v = "ijk"[loops]
+        inner = _nest(rest, loops + 1)
+        return [f"!$omp {leaf}", f"do {v} = 1, n"] + ["  " + x for x in inner] \
+            + ["end do", f"!$omp end {leaf}"]
+    inner = _nest(rest, loops) if rest or leaf != "workdistribute" \
+        else ["b = a"]
+    return [f"!$omp {leaf}"] + ["  " + x for x in inner] + [f"!$omp end {leaf}"]
+
+
+def nested_source(seq: tuple) -> str:
+    return "\n".join(_HEAD + ["  " + x for x in _nest(seq, 0)] + _TAIL) + "\n"
+
+
+def source(seq: tuple, form: str) -> str:
+    return combined_source(seq) if form == "combined" else nested_source(seq)
+
+
+def ours(seq: tuple, form: str, version: int) -> tuple[bool, str]:
+    """(accepted, why not): the grammar parses every directive and no
+    static rule is violated."""
+    try:
+        found = violations(parse_program(source(seq, form), version), version)
+    except (GrammarError, ProgramError) as err:
+        return False, str(err).split("\n")[0]
+    return not found, ", ".join(found)
+
+
+# --- the spec, independently of offload.engine.rules -------------------------------------
+
+# the constructs that may be the closest enclosing construct of another
+# (lexically, nothing in between): 5.2 §17.1, §10.2, §10.4, §11.6, §11.7,
+# §13.8 and §17.1's worksharing rule; 6.0 §12.2 (teams-nestable), §12.3,
+# §12.4 (SIMDizable), §13 (a worksharing region encountered by all
+# threads of its team, Appendix C), §13.5, §13.7, §15.8
+DIRECT = {
+    "target": {"teams", "parallel", "do", "simd", "loop"},
+    "teams": {"distribute", "parallel", "loop"},
+    "distribute": {"target", "parallel", "do", "simd", "loop"},
+    "parallel": {"target", "parallel", "do", "simd", "loop"},
+    "do": {"target", "parallel", "simd", "loop"},
+    "simd": {"simd", "loop"},
+    "loop": {"parallel", "simd", "loop"},
+    "workdistribute": set(),
+}
+# outermost construct of a main program (the implicit parallel region)
+TOP = {"target", "teams", "parallel", "do", "simd"}
+
+
+def spec_nested(seq: tuple, version: int) -> bool:
+    if seq[0] not in TOP:
+        return False  # distribute/workdistribute need teams; loop needs bind
+    for k in range(1, len(seq)):
+        parent, child = seq[k - 1], seq[k]
+        ok = DIRECT[parent] | ({"workdistribute"} if parent == "teams"
+                               and version >= 60 else set())
+        if child not in ok:
+            return False
+        for anc in seq[:k]:
+            if anc == "simd" and child not in ("simd", "loop"):
+                return False
+            if anc == "workdistribute":
+                return False
+            if anc == "target" and child == "target":
+                return False
+            if anc == "loop" and version < 60 and child not in (
+                    "loop", "parallel", "simd"):
+                return False
+    return True
+
+
+def _name_52(seq: tuple) -> bool:
+    """5.2 §17.3, restricted to LEAVES."""
+    if len(seq) == 1:
+        return True
+    a, b = seq[0], seq[1:]
+    if not _name_52(b):
+        return False
+    if a == "do":
+        return b == ("simd",)
+    if a == "parallel":
+        return b in (("loop",), ("do",), ("do", "simd"))
+    if a == "distribute":
+        return b == ("simd",) or (b[0] == "parallel" and "do" in b)
+    if a == "teams":
+        return b in (("loop",), ("distribute",)) or b[0] == "distribute"
+    if a == "target":
+        return b in (("simd",), ("parallel",), ("teams",)) \
+            or b[0] == "teams" \
+            or (b[0] == "parallel" and bool({"loop", "do"} & set(b)))
+    return False
+
+
+# 6.0 Appendix D productions restricted to LEAVES (task, taskloop, masked,
+# single, sections, workshare, target_data and the data-motion directives
+# are outside the matrix)
+def _composite(s):
+    return s in (("distribute", "parallel", "do"),
+                 ("distribute", "parallel", "do", "simd"),
+                 ("distribute", "simd"), ("do", "simd"))
+
+
+def _parallel_dir(s):
+    return s == ("parallel",) or _par_comb(s)
+
+
+def _teams_dir(s):
+    return s == ("teams",) or _teams_comb(s)
+
+
+def _target_dir(s):
+    return s == ("target",) or _target_comb(s)
+
+
+def _par_comb(s):
+    if len(s) < 2 or s[0] != "parallel":
+        return False
+    r = s[1:]
+    return r in (("loop",), ("do",), ("do", "simd"), ("simd",)) \
+        or _target_dir(r)
+
+
+def _target_comb(s):
+    if len(s) < 2 or s[0] != "target":
+        return False
+    r = s[1:]
+    return r in (("loop",), ("simd",)) or _parallel_dir(r) or _teams_dir(r)
+
+
+def _teams_comb(s):
+    if len(s) < 2 or s[0] != "teams":
+        return False
+    r = s[1:]
+    pnw = r in (("distribute",), ("loop",), ("workdistribute",)) or (
+        r[0] == "distribute" and _composite(r))
+    return pnw or r == ("simd",) or _parallel_dir(r) or _target_dir(r)
+
+
+def _name_60(seq: tuple) -> bool:
+    return len(set(seq)) == len(seq) and (
+        _composite(seq) or _par_comb(seq) or _target_comb(seq)
+        or _teams_comb(seq)) and spec_nested(seq, 60)
+
+
+def spec_combined(seq: tuple, version: int) -> bool:
+    """Whether the leaves in this order form a conforming compound name
+    and the construct may appear outermost in a main program (an orphaned
+    compound starting with distribute or loop is not)."""
+    ok = _name_52(seq) if version < 60 else _name_60(seq)
+    return ok and seq[0] in TOP
+
+
+def spec(seq: tuple, form: str, version: int) -> bool:
+    return spec_combined(seq, version) if form == "combined" \
+        else spec_nested(seq, version)
+
+
+@dataclass(frozen=True)
+class Cell:
+    version: int
+    form: str  # combined | nested
+    order: tuple
+    spec: bool
+    ours: bool
+    why: str  # our grammar error or violated rules
+
+
+def cells(versions=(52, 60)) -> list[Cell]:
+    out = []
+    for v in versions:
+        for seq in orders(v):
+            for form in ("combined", "nested"):
+                ok, why = ours(seq, form, v)
+                out.append(Cell(v, form, seq, spec(seq, form, v), ok, why))
+    return out

offload/engine/confirm/__init__.py

@@ -0,0 +1,2 @@
+"""The automated bug confirmer: evidence -> rule verdict,
+minimize, dedupe, draft. Design and data formats: docs/tooling/confirm.md."""

offload/engine/confirm/backlog.py

@@ -0,0 +1,159 @@
+"""Confirmed catalog bugs without a finding.
+
+A catalog cell the confirmer calls a bug (``engine.BUG_VERDICTS``) whose
+dedupe found no finding, duplicate or related ("dedupe: new failure
+signature"), is backlog: the support tables and the dashboard count it as
+a confirmed failure, but no reproducer was reported. ``groups`` groups
+such cells by the confirmer's failure signature (front end, outcome group
+and the cause: an ICE's message, a rejection's diagnostic key or link
+symbol, or, for a run-time failure and a generic ICE message, the
+catalog program across versions); ``catalog/unlinked_bugs.yaml`` records
+why each remaining group has no finding, and the test
+(tests/confirm/test_confirm_backlog.py) fails when a group without a recorded
+reason appears or a recorded group changes size, so the backlog cannot
+grow silently. ``render`` writes data/reports/unlinked-bugs.md."""
+from __future__ import annotations
+
+import json
+import re
+from collections import Counter
+from pathlib import Path
+
+import yaml
+
+ROOT = Path(__file__).resolve().parent.parent.parent.parent
+BATCH = ROOT / "results" / "confirm" / "batch_full.jsonl"
+DATA = ROOT / "catalog" / "unlinked_bugs.yaml"
+DOC = ROOT / "data" / "reports" / "unlinked-bugs.md"
+BUG = ("compiler_bug", "copy_mode_failure", "unified_memory_failure",
+       "arch_specific")
+GENERIC_ICE = re.compile(r"PLEASE submit a bug report|clang frontend "
+                         r"command failed|stack dump", re.I)
+
+
+def unlinked(batch: Path = BATCH) -> list[dict]:
+    """The catalog results with a bug verdict and no finding (duplicate
+    or related)."""
+    out = []
+    for line in Path(batch).read_text().splitlines():
+        d = json.loads(line)
+        if d["case"]["program"]["kind"] != "catalog" or \
+                d["verdict"] not in BUG:
+            continue
+        if d.get("findings") or d.get("related"):
+            continue
+        out.append(d)
+    return out
+
+
+def _n(text: str) -> str:
+    return re.sub(r"0x[0-9a-fA-F]+|\d+", "N", text)
+
+
+def key(d: dict) -> str:
+    """family | lang | outcome group | cause."""
+    from offload.engine.confirm import findings as FI
+    from offload.engine.confirm.facts import diagnostic_key
+    from offload.engine.confirm.machines import family_of
+    c = d["case"]
+    pid = c["program"]["ident"]
+    prog = re.sub(r"^(omp|acc)\d\d-", r"\1*-", pid)
+    g = FI.group(c["outcome"], c["reason"])
+    r = c.get("reason") or ""
+    if g == "rejected":
+        m = re.search(r"undefined (?:symbol:|reference to) ?`?([^\s']+)", r)
+        u = re.search(r"undeclared function '(\w+)'", r)
+        if m and r.startswith("link"):
+            cause = "link " + m.group(1)
+        elif u:
+            cause = f"undeclared function {u.group(1)}"
+        else:
+            k = diagnostic_key(r)
+            cause = k if re.fullmatch(r"ftn-\d+", k) else _n(k)
+    elif g == "ice" and not GENERIC_ICE.search(r):
+        cause = _n(FI.strip_site(FI.normalize(r)))[:100]
+    else:
+        cause = prog
+    return f"{family_of(c['toolchain'])}|{c['program']['lang']}|{g}|{cause}"
+
+
+def groups(results: list[dict]) -> dict[str, list[dict]]:
+    out: dict[str, list[dict]] = {}
+    for d in results:
+        out.setdefault(key(d), []).append(d)
+    return dict(sorted(out.items()))
+
+
+def load(path: Path = DATA) -> dict:
+    d = yaml.safe_load(Path(path).read_text()) or {}
+    if d.get("version") != 1:
+        raise ValueError(f"{path}: unknown version")
+    return d
+
+
+def check(gs: dict[str, list[dict]], data: dict) -> list[str]:
+    """Problems: a group with no recorded reason, a recorded group whose
+    cell count changed, a recorded group that no longer exists."""
+    rec = {g["key"]: g for g in data.get("groups") or []}
+    out = []
+    for k, ds in gs.items():
+        if k not in rec:
+            out.append(f"new backlog group (no finding, no recorded "
+                       f"reason): {k} ({len(ds)} cells)")
+        elif rec[k]["cells"] != len(ds):
+            out.append(f"{k}: {len(ds)} cells, recorded {rec[k]['cells']}")
+    for k in rec:
+        if k not in gs:
+            out.append(f"recorded group no longer in the backlog: {k}")
+    return out
+
+
+def summary(ds: list[dict]) -> dict:
+    c = ds[0]["case"]
+    return {"cells": len(ds),
+            "programs": sorted({d["case"]["program"]["ident"] for d in ds}),
+            "toolchains": sorted({d["case"]["toolchain"] for d in ds}),
+            "verdicts": dict(Counter(d["verdict"] for d in ds)),
+            "rules": dict(Counter(d["rule"] for d in ds)),
+            "example": c["case_id"], "reason": (c.get("reason") or "")[:200]}
+
+
+def render(gs: dict[str, list[dict]], data: dict) -> str:
+    rec = {g["key"]: g for g in data.get("groups") or []}
+    n = sum(map(len, gs.values()))
+    lines = [
+        "# Confirmed catalog bugs without a finding",
+        "",
+        "Generated by `python3 -I tools/confirm.py backlog --write` from "
+        "results/confirm/batch_full.jsonl and catalog/unlinked_bugs.yaml "
+        "(offload/engine/confirm/backlog.py). A cell is listed when the "
+        "confirmer calls it a bug (compiler_bug, unified_memory_failure, "
+        "copy_mode_failure, arch_specific) and its dedupe found no finding, "
+        "duplicate or related. tests/confirm/test_confirm_backlog.py fails when a "
+        "group appears without a recorded reason or a group's size changes.",
+        "",
+        "## How the backlog was closed",
+        "",
+        data.get("history", "").strip(),
+        "",
+        "## Promoted and linked groups",
+        "",
+        "| group (family, lang, outcome, cause) | cells | outcome |",
+        "|---|---|---|",
+        *[f"| `{g['key']}` | {g['cells']} | {g['outcome']} |"
+          for g in data.get("closed") or []],
+        "",
+        f"## Remaining: {n} cells in {len(gs)} groups",
+        "",
+        "| group | cells | verdicts | programs | example | why no finding |",
+        "|---|---|---|---|---|---|",
+    ]
+    for k, ds in gs.items():
+        s = summary(ds)
+        why = (rec.get(k) or {}).get("why", "**no recorded reason**")
+        lines.append(
+            f"| `{k}` | {s['cells']} | "
+            + ", ".join(f"{v} {c}" for v, c in s["verdicts"].items())
+            + f" | {', '.join(s['programs'])} | `{s['example']}` | "
+            f"{why} |")
+    return "\n".join(lines) + "\n"