offtarget 0.1.0__py3-none-any.whl

offload/engine/confirm/model.py

@@ -0,0 +1,249 @@
+"""The confirmer's data types and the mapping of every stored result format
+to one set of outcome classes (docs/tooling/confirm.md, "Case" and "Evidence")."""
+from __future__ import annotations
+
+import dataclasses
+import hashlib
+import re
+from dataclasses import dataclass, field
+
+OUTCOMES = ("rejected", "ice", "crash", "run_error", "timeout",
+            "wrong_answer", "fell_back_to_host", "accepted_ignored",
+            "harness_error", "correct_on_device", "unobservable")
+PASSING = ("correct_on_device", "unobservable")
+COMPILE_FAILURES = ("rejected", "ice")
+RUN_FAILURES = ("crash", "run_error", "timeout", "wrong_answer",
+                "fell_back_to_host")
+
+
+def outcome_of_result(outcome: str, reason: str) -> str:
+    """The class of a harness row (offload.engine.harness.Result: matrix and
+    acc_matrix files)."""
+    reason = reason or ""
+    if outcome == "rejected":
+        return "ice" if reason.startswith("ice:") else "rejected"
+    if outcome == "wrong_answer":
+        head = reason.split(";")[0]
+        if head.startswith("timeout") or head.startswith("compile_timeout"):
+            return "timeout"
+        if head.startswith("crash:"):
+            return "crash"
+        if head.startswith(("exit_status", "no_result_line",
+                            "multiple_result_lines", "mandatory_failed")):
+            return "run_error"
+        return "wrong_answer"
+    if outcome == "harness_error" and reason.startswith("compile_timeout"):
+        return "timeout"
+    if outcome not in OUTCOMES:
+        raise ValueError(f"unknown outcome {outcome!r}")
+    return outcome
+
+
+def outcome_of_baseline(row: dict) -> str:
+    """The class of an omp_vv baseline row (offload.engine.baseline: exit code
+    only)."""
+    st, stage, reason = row["status"], row.get("stage"), row.get("reason", "")
+    if st == "pass":
+        return "correct_on_device"
+    if st == "harness_error":
+        return "harness_error"
+    if stage == "compile":
+        if reason.startswith("ice"):
+            return "ice"
+        if reason.startswith("compile_failed"):
+            # The harness found no known message; the output
+            # still tells a compiler failure from the environment's
+            err = row.get("stderr") or ""
+            if re.search(r"Segmentation fault|PLEASE submit a bug report|"
+                         r"INTERNAL COMPILER ERROR|verification of lowering"
+                         r"|failed to create the LLVM module", err):
+                return "ice"
+            if re.search(r"undefined (hidden )?symbol|undefined reference",
+                         err):
+                return "rejected"
+            return "harness_error"
+        if "timeout" in reason:
+            return "timeout"
+        return "rejected"
+    if reason.startswith("crash"):
+        return "crash"
+    if reason.startswith("timeout"):
+        return "timeout"
+    return "run_error"
+
+
+FUZZ_CLASS = {"agree": "correct_on_device", "compile_reject": "rejected",
+              "ice": "ice", "wrong_code": "wrong_answer",
+              "host_fallback": "fell_back_to_host", "run_error": "run_error",
+              "harness_error": "harness_error"}
+
+
+def outcome_of_fuzz(cls: str, reason: str = "") -> str:
+    """The class of a fuzz campaign's per-toolchain result."""
+    if cls == "timeout":
+        return "timeout"
+    if cls == "run_error" and (reason or "").startswith("crash"):
+        return "crash"
+    return FUZZ_CLASS[cls]
+
+
+def sha256(text: str) -> str:
+    return hashlib.sha256(text.encode()).hexdigest()
+
+
+@dataclass(frozen=True)
+class ProgramRef:
+    """A program: ``kind`` catalog (``ident`` = program id), ompvv
+    (``ident`` = corpus path), fuzz (``ident`` = "<run>:<seed>"), file
+    (``ident`` = path or label; ``text`` holds the files)."""
+    kind: str
+    ident: str
+    lang: str = "f90"
+    version: int = 0
+    model: str = "omp"
+    legal_claim: bool = True
+    needs: tuple = ()
+    evidence: str = "construct"
+    text: str = ""          # the program text (a set: FILE marks)
+    expected: str = ""      # a stated expected value (fuzz model, finding)
+    # Build flags the reproducer needs (its "build flags:" header
+    # line, e.g. "-O2 -flto"); the runners add them to every build
+    flags: str = ""
+
+    @property
+    def sha(self) -> str:
+        return sha256(self.text) if self.text else ""
+
+    def to_dict(self) -> dict:
+        d = dataclasses.asdict(self)
+        d["needs"] = list(self.needs)
+        d["sha256"] = self.sha
+        d.pop("text")
+        if not self.flags:
+            d.pop("flags")      # older rows had none
+        return d
+
+
+@dataclass(frozen=True)
+class Case:
+    program: ProgramRef
+    toolchain: str
+    machine: str
+    arch: str
+    mode: str
+    outcome: str
+    reason: str = ""
+    value: str | None = None
+    ran_on_host: int | None = None
+    flaky: bool = False
+    repeats: int = 1
+    opt: str = "-O2"
+    source: dict = field(default_factory=dict)
+
+    @property
+    def case_id(self) -> str:
+        ident = re.sub(r"[^A-Za-z0-9_.:-]", "_", self.program.ident)
+        return (f"{self.program.kind}:{ident}:{self.toolchain}:"
+                f"{self.arch}:{self.mode}")
+
+    @property
+    def failing(self) -> bool:
+        return self.outcome not in PASSING
+
+    def to_dict(self) -> dict:
+        d = {k: v for k, v in dataclasses.asdict(self).items()
+             if k != "program"}
+        d["program"] = self.program.to_dict()
+        d["case_id"] = self.case_id
+        return d
+
+
+@dataclass(frozen=True)
+class Provenance:
+    command: str = ""
+    host: str = ""
+    date: str = ""
+    modules: tuple = ()
+    origin: str = ""   # "run", or "<file>:<line>" of a stored row
+
+    def to_dict(self) -> dict:
+        d = dataclasses.asdict(self)
+        d["modules"] = list(self.modules)
+        return d
+
+
+@dataclass(frozen=True)
+class Run:
+    """One execution (or one stored row) of a program on a toolchain."""
+    outcome: str
+    value: str | None = None
+    ran_on_host: int | None = None
+    reason: str = ""
+    stdout_tail: str = ""
+
+
+@dataclass(frozen=True)
+class Evidence:
+    """What one collector found for one cell (docs/tooling/confirm.md). `status`:
+    value | no_value | inapplicable | not_applicable."""
+    collector: str
+    toolchain: str = ""
+    arch: str = ""
+    mode: str = ""
+    opt: str = "-O2"
+    offload: str = "mandatory"
+    variant: str = "original"
+    sha: str = ""
+    runs: tuple = ()
+    value: str | None = None
+    status: str = "value"
+    detail: str = ""
+    provenance: Provenance = Provenance()
+
+    def __post_init__(self):
+        if self.status not in ("value", "no_value", "inapplicable",
+                               "not_applicable"):
+            raise ValueError(f"unknown evidence status {self.status!r}")
+
+    @property
+    def key(self) -> tuple:
+        return (self.collector, self.sha, self.toolchain, self.arch,
+                self.mode, self.opt, self.offload, self.variant)
+
+    @property
+    def outcomes(self) -> tuple:
+        return tuple(r.outcome for r in self.runs)
+
+    def to_dict(self) -> dict:
+        d = dataclasses.asdict(self)
+        d["runs"] = [dataclasses.asdict(r) for r in self.runs]
+        d["provenance"] = self.provenance.to_dict()
+        return d
+
+    @staticmethod
+    def from_dict(d: dict) -> "Evidence":
+        d = dict(d)
+        d["runs"] = tuple(Run(**r) for r in d.get("runs", ()))
+        p = dict(d.get("provenance") or {})
+        p["modules"] = tuple(p.get("modules", ()))
+        d["provenance"] = Provenance(**p)
+        return Evidence(**d)
+
+
+VALUE_LINE = re.compile(r"^RESULT (?:ran_on_host=([01]) check=(pass|fail)|"
+                        r"checksum=(-?\d+) ran_on_host=([01]))\s*$", re.M)
+
+
+def value_of(stdout: str) -> tuple[str | None, int | None]:
+    """(value, ran_on_host) of a program's output: ``check=pass|fail`` or
+    ``checksum=<n>`` from its single RESULT line; else the output with
+    whitespace collapsed (a finding's free-form output); (None, None) for
+    no output."""
+    found = VALUE_LINE.findall(stdout or "")
+    if len(found) == 1:
+        h, chk, cs, h2 = found[0]
+        if chk:
+            return f"check={chk}", int(h)
+        return f"checksum={cs}", int(h2)
+    text = " ".join((stdout or "").split())
+    return (text or None), None

offload/engine/confirm/ports.py

@@ -0,0 +1,107 @@
+"""C/Fortran port equivalence for hand derivations (registry RUL-PORT-DERIVATION).
+
+A Fortran catalog program's hand derivation counts for its C port when
+the port computes and checks the same value from the same construct. The
+equivalence is recorded per port in catalog/omp/port_equivalence.yaml
+(``write``) and checked by a test (``problems``): the port is
+offload.engine.f2c's translation of that Fortran program (offload.engine.c_gen:
+same data, oracle and output contract), the atom has no C source edit
+(``c_gen.C_EDITS``) and no C relabelling (``c_gen.C_LABELS``), both
+programs are legal with the same primary atom, evidence and expectation,
+and the Fortran program carries a derivation. A port without an entry
+keeps its own sources (provisional or derived)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import functools
+
+import yaml
+
+from offload.engine.confirm import programs as P
+
+ROOT = Path(__file__).resolve().parent.parent.parent.parent
+DATA = ROOT / "catalog" / "omp" / "port_equivalence.yaml"
+
+
+def _derivation(src: str) -> str | None:
+    from offload.engine import expected as E
+    ev = E.derivation_evidence(src)
+    return ev.value if ev.status == "value" else None
+
+
+def candidates() -> list[dict]:
+    """Every C port that meets the equivalence conditions."""
+    from offload.engine import c_gen
+    out = []
+    for v in c_gen.C_VERSIONS:
+        for cid, cprog in sorted(P._catalog(v, "c").items()):
+            if not cprog.legal:
+                continue
+            fid = P.port_of(cid)
+            fprog = P.catalog_program(fid) if fid else None
+            if fprog is None or not fprog.legal:
+                continue
+            why = problems_of(cprog, fprog)
+            if why:
+                continue
+            out.append({"c": cid, "fortran": fid,
+                        "atom": cprog.primary_atom,
+                        "value": _derivation(fprog.source),
+                        "basis": "offload.engine.f2c translation of the Fortran "
+                                 "program (same data, oracle and output "
+                                 "contract); no C edit or relabel"})
+    return out
+
+
+def problems_of(cprog, fprog) -> list[str]:
+    from offload.engine import c_gen
+    errs = []
+    if cprog.primary_atom != fprog.primary_atom:
+        errs.append("primary atom differs")
+    if cprog.primary_atom in c_gen.C_EDITS:
+        errs.append("C source edit")
+    if cprog.primary_atom in c_gen.C_LABELS:
+        errs.append("C relabelling")
+    if cprog.evidence != fprog.evidence or cprog.expect != fprog.expect:
+        errs.append("evidence or expectation differs")
+    if _derivation(fprog.source) is None:
+        errs.append("the Fortran program has no derivation")
+    return errs
+
+
+def write(path: Path = DATA) -> int:
+    rows = candidates()
+    Path(path).write_text(
+        "# (ruling B): C ports whose Fortran "
+        "program's\n# hand derivation counts for them "
+        "(offload/engine/confirm/ports.py).\n"
+        "# Generated by `tools/confirm.py ports --write`; checked by "
+        "tests/confirm/test_confirm_ports.py.\n"
+        + yaml.safe_dump({"ports": rows}, sort_keys=False, width=100))
+    return len(rows)
+
+
+@functools.lru_cache(maxsize=None)
+def _entries(path: str, mtime: float) -> dict:
+    data = yaml.safe_load(Path(path).read_text()) or {}
+    return {e["c"]: e for e in data.get("ports") or []}
+
+
+def load(path: Path = DATA) -> dict:
+    """C id -> entry (read once per version of the file; do not change it)."""
+    if not Path(path).is_file():
+        return {}
+    return _entries(str(path), Path(path).stat().st_mtime)
+
+
+def derivation_for(c_id: str) -> tuple[str, str] | None:
+    """(value, Fortran id) of the derivation a recorded port inherits."""
+    e = load().get(c_id)
+    if e is None:
+        return None
+    f = P.catalog_program(e["fortran"])
+    if f is None:
+        return None
+    v = _derivation(f.source)
+    return (v, e["fortran"]) if v else None

offload/engine/confirm/programs.py

@@ -0,0 +1,222 @@
+"""Programs of every kind the confirmer handles: their text, files,
+generator Program, C/Fortran port and construct set.
+
+A program set (several files) is one text with a file mark per file:
+``!@file <name>.f90`` (offload.engine.fuzz_base.FILE_MARK, the fuzz bundles)
+or ``//@file <name>.c``; ``split_files`` returns the files in compile
+order. Catalog programs are regenerated by id (the same generator the
+matrix ran), fuzz programs from their seed, omp_vv tests are read from
+corpus/ (never edited: the confirmer works on copies)."""
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from pathlib import Path
+
+from offload.engine.confirm.model import ProgramRef
+
+from offload.engine.root import ROOT  # noqa: E402
+F_MARK = "!@file "
+C_MARK = "//@file "
+
+
+def split_files(text: str) -> list[tuple[str, str]] | None:
+    """[(name, text)] of a program set, None for a single file. Lines
+    before the first mark go to the first file."""
+    mark = F_MARK if F_MARK in text else C_MARK if C_MARK in text else None
+    if mark is None:
+        return None
+    files: list[list] = []
+    head: list[str] = []
+    for line in text.splitlines():
+        if line.startswith(mark):
+            files.append([line[len(mark):].strip(), []])
+        elif files:
+            files[-1][1].append(line)
+        else:
+            head.append(line)
+    files[0][1] = head + files[0][1]
+    return [(n, "\n".join(ls) + "\n") for n, ls in files]
+
+
+def join_files(files: list[tuple[str, str]]) -> str:
+    """One text of a program set (the inverse of ``split_files``)."""
+    if len(files) == 1:
+        return files[0][1]
+    mark = C_MARK if files[0][0].endswith(".c") else F_MARK
+    return "".join(f"{mark}{n}\n{t if t.endswith(chr(10)) else t + chr(10)}"
+                   for n, t in files)
+
+
+def lang_of_path(path: str) -> str:
+    return "c" if str(path).endswith(".c") else "f90"
+
+
+def version_of_id(pid: str) -> int:
+    m = re.match(r"(?:omp|acc)(\d\d)-", pid)
+    return int(m.group(1)) if m else 0
+
+
+def lang_of_id(pid: str) -> str:
+    return "c" if re.match(r"(?:omp|acc)\d\d-c-", pid) else "f90"  
+
+
+@lru_cache(maxsize=None)
+def _catalog(version: int, lang: str) -> dict:
+    from offload.engine.catalog import slice_atoms
+    from offload.engine.run_matrix import matrix_programs
+    atoms = slice_atoms(version, lang=lang)
+    return {p.id: p for _, p in matrix_programs(atoms, [version], lang)}
+
+
+def catalog_program(pid: str):
+    """The generator's Program of a catalog id (None if no longer
+    generated); a widened catalog program (offload.engine.widen,
+    ids ``<model><v>-[c-]w-<slug>``) is one too."""
+    from offload.engine import widen
+    if widen.is_wide(pid):
+        return widen.program(pid)
+    try:
+        return _catalog(version_of_id(pid), lang_of_id(pid)).get(pid)
+    except Exception:
+        return None
+
+
+def catalog_ref(pid: str, prog=None) -> ProgramRef:
+    prog = prog or catalog_program(pid)
+    if prog is None:
+        return ProgramRef("catalog", pid, lang_of_id(pid), version_of_id(pid),
+                          "acc" if pid.startswith("acc") else "omp")
+    return ProgramRef("catalog", pid, "c" if prog.lang == "c" else "f90",
+                      version_of_id(pid), prog.model, prog.legal,
+                      tuple(prog.needs), prog.evidence, prog.source,
+                      expected=("error_termination" if prog.expect ==
+                                "error_termination" else "check=pass"))
+
+
+def port_of(pid: str) -> str | None:
+    """The C port of a Fortran catalog id, or the Fortran program of a C
+    one (None for OpenACC)."""
+    m = re.match(r"(omp\d\d-)(c-)?(.*)$", pid)
+    if not m:
+        return None
+    return m.group(1) + (m.group(3) if m.group(2) else "c-" + m.group(3))
+
+
+def fuzz_ref(run: str, seed: int, gen_version: str, base=(),
+             expected: int | None = None) -> ProgramRef:
+    from offload.engine.fuzz import generate
+    g = generate(seed, gen_version, tuple(base or ()))
+    return ProgramRef("fuzz", f"{run}:{seed}", "f90", 52, "omp", True, (),
+                      "construct", g.source,
+                      expected=f"checksum={g.expected if expected is None else expected}")
+
+
+def ompvv_ref(path: str, repo: str = "omp_vv") -> ProgramRef:
+    src = ROOT / "corpus" / repo / path
+    text = src.read_text(errors="replace") if src.is_file() else ""
+    return ProgramRef("ompvv", path, lang_of_path(path), 0, "omp", True, (),
+                      "exit_code", text, expected="exit=0")
+
+
+def file_ref(paths: list[str], expected: str = "", label: str = "",
+             version: int = 52) -> ProgramRef:
+    """A program from files on the command line (one file, or a set in
+    compile order); header lines of offload.engine.harness.program_from_file
+    (``! legal:``, ``! needs:``) are read from the first file."""
+    files = [(Path(p).name, Path(p).read_text()) for p in paths]
+    text = join_files(files)
+    lang = lang_of_path(paths[0])
+    from offload.engine.harness import program_from_file
+    prog = program_from_file(paths[0])
+    m = re.search(r"^(?:!|//) expected(?: output)?: (.+)$", files[0][1], re.M)
+    # The build flags a reproducer needs ("// build flags: -O2
+    # -flto"), added by the runners to every build of it
+    fl = re.search(r"^(?:!|//)\s*(?:- )?build flags: *(.+?)\s*$",
+                   files[0][1], re.M)
+    model = prog.model
+    # A file of OpenACC directives only is an OpenACC program
+    # (its id need not start with accNN-)
+    kinds = {g.lower() for d in _DIRECTIVE.finditer(text)
+             for g in d.groups()[:2] if g}
+    if kinds == {"acc"}:
+        model = "acc"
+    return ProgramRef("file", label or str(paths[0]), lang, version,
+                      model, prog.legal, tuple(prog.needs),
+                      prog.evidence, text,
+                      expected=expected or (m.group(1).strip() if m else ""),
+                      flags=fl.group(1).strip("`") if fl else "")
+
+
+_DIRECTIVE = re.compile(r"^\s*(?:!\$(omp|acc)|#\s*pragma\s+(omp|acc))\s+(.*)$",
+                        re.I | re.M)
+_CLAUSE = re.compile(r"\b([a-z_]+)\s*(?=\(|\s|$)", re.I)
+_DIRECTIVE_WORDS = {
+    "target", "teams", "distribute", "parallel", "do", "for", "simd", "loop",
+    "data", "enter", "exit", "update", "declare", "task", "taskloop",
+    "taskgroup", "taskwait", "single", "masked", "master", "critical",
+    "atomic", "barrier", "ordered", "sections", "section", "workshare",
+    "scan", "requires", "mapper", "reduction", "kernels", "serial", "host_data",
+    "routine", "wait", "init", "shutdown", "set", "cache", "end", "metadirective",
+    "interop", "dispatch", "allocate", "allocators", "error", "nothing", "tile",
+    "unroll", "depobj", "flush", "cancel", "workdistribute", "scope",
+    "teams", "assume", "assumes"}
+
+
+_F_CONT = re.compile(r"^(\s*!\$(?:omp|acc)\b.*?)&\s*(?:!.*)?$", re.I)
+_F_NEXT = re.compile(r"^\s*!\$(?:omp|acc)\s*&?", re.I)
+
+
+def join_continuations(text: str) -> str:
+    """Directive lines with their continuations joined: Fortran's ``&``
+    at the end of a ``!$omp`` / ``!$acc`` line and the next line's
+    sentinel (``!$omp&`` or ``!$omp``), C's ``\\`` at the end of a pragma
+    line (item 10)."""
+    lines = text.split("\n")
+    out = []
+    k = 0
+    while k < len(lines):
+        ln = lines[k]
+        m = _F_CONT.match(ln)
+        while m and k + 1 < len(lines) and _F_NEXT.match(lines[k + 1]):
+            k += 1
+            ln = m.group(1).rstrip() + " " + _F_NEXT.sub("", lines[k], 1
+                                                         ).strip()
+            m = _F_CONT.match(ln)
+        if re.match(r"^\s*#\s*pragma\b", ln):
+            while ln.rstrip().endswith("\\") and k + 1 < len(lines):
+                k += 1
+                ln = ln.rstrip()[:-1].rstrip() + " " + lines[k].strip()
+        out.append(ln)
+        k += 1
+    return "\n".join(out)
+
+
+def constructs(text: str) -> frozenset[str]:
+    """The directive names (``dir:<name>``) and clause names
+    (``clause:<name>``) a program uses (end directives skipped): the
+    construct set of a failure signature. Continuation lines are joined
+    first (``join_continuations``)."""
+    out = set()
+    for m in _DIRECTIVE.finditer(join_continuations(text)):
+        body = m.group(3).split("!")[0].strip().lower()
+        if body.startswith("end"):
+            continue
+        body = re.sub(r"\([^()]*(?:\([^()]*\)[^()]*)*\)", "()", body)
+        words = body.replace(",", " ").split()
+        name = []
+        for w in words:
+            bare = w.split("(")[0]
+            if bare in _DIRECTIVE_WORDS and not name or (
+                    name and bare in _DIRECTIVE_WORDS and "(" not in w
+                    and len(name) < 4):
+                name.append(bare)
+            else:
+                break
+        if name:
+            out.add("dir:" + " ".join(name))
+        for w in words[len(name):]:
+            bare = w.split("(")[0].strip(":")
+            if re.fullmatch(r"[a-z_]+", bare):
+                out.add("clause:" + bare)
+    return frozenset(out)