mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-20 00:29:57 -04:00
Triforce v0.2.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
213
tests/test_fpx_sticky.py
Normal file
213
tests/test_fpx_sticky.py
Normal file
@@ -0,0 +1,213 @@
|
||||
"""FPX1's sticky-flag rescue for single-precision FMUL/FNMUL/FMLA, game-free: bit-exact with the exact body.
|
||||
|
||||
a64_lift.py's a64_fpx_mul32_fma32 and a64_fpx_fma32_fma32 (the cold wrappers lifted code calls when the inline fast path
|
||||
cannot prove its result) try a64_fpx_sticky32 before the exact body recomp_fpe_fma32: when every FPSR flag the Arm op
|
||||
could raise is already set, one hardware FMA (or multiply) is the Arm result. This builds what the real build builds,
|
||||
a64_fpx.h from a64_lift.fpx_header() and a64_suyu.h / a64_suyu.c from a64_rtgen.py (through suyu's translator,
|
||||
a64emit.cpp, built here at -O0 into a temporary folder), and compiles tests/fpx_sticky_test.c against the real rt/a64.h
|
||||
at the build's FP flags (-ffp-contract=off -O2) twice: at -march=x86-64-v3 (RECOMP_FPX_FMA64: both ops rescued) and at
|
||||
-march=x86-64-v2 (what host_march() gives a CPU without AVX2: FMUL's rescue is a plain multiply and FMLA's must decline
|
||||
every case). The v2 build runs on any x86-64-v2 CPU, whether or not it has AVX2. In each build:
|
||||
- the lifted route: guest FMUL, FNMUL, FMADD and FMLA (by element) S words, hand-encoded, through a64emit.translate and
|
||||
a64_lift.op_text (the lifter's per-instruction pipeline, so the C calls the outlined wrapper as lifted code does) and
|
||||
hot_text (the hot functions' form), against the same words translated with FPX off (the exact body inline): the
|
||||
whole Ctx and the rescue count must match, on 5 inputs that must be rescued and 7 that must not (96 runs);
|
||||
and each wrapper's value and FPSR must equal recomp_fpe_fma32's for:
|
||||
- 8M random operand triples (16M checks, seeded): zeros, subnormals, inf, NaN (quiet and signalling), the extreme
|
||||
normals, products near the underflow and overflow edges, exact and near cancellations, under random FPCR (FZ,
|
||||
DN, RMode, FIZ/AH/NEP alone or with other bits, the kill switch) and FPSR states;
|
||||
- an edge sweep (~150M checks): every a with biased exponent <= 4 or >= 250 whose fraction is below 2^12, above
|
||||
2^23 - 2^12 or a multiple of 97, against 12 fixed b and 4 addend kinds, each under FZ on and off with the flags
|
||||
all set or IXC only, and under one more state (by a): partial flags (UFC set and IDC clear, IDC set and UFC clear,
|
||||
OFC only, every bit but one of IDC/UFC/OFC, ...), IXC clear, or FIZ/AH/NEP set.
|
||||
The rescues are counted inside the generated wrappers (an A64_FPX_STICKY_PROBE() the driver defines; empty in the real
|
||||
build): both builds must see FMUL rescues, v3 FMLA rescues and v2 none, and a rescue under a closed gate (an FPCR
|
||||
control bit but FZ set, or IXC clear) fails. That last check is what guards FIZ/AH/NEP: the exact body models none of
|
||||
them, so comparing values could not tell. About 35-50 s here.
|
||||
|
||||
It has teeth (each by hand, then restored):
|
||||
- the emitter no longer outlining FMUL/FNMUL S (arm64_to_c.h's EmitFPMulAddValue: `FpxOutline()` made
|
||||
`FpxOutline() && !mul`, so the guest FMUL keeps suyu's inline guard): the lifted case fails in both builds (20
|
||||
FMUL/FNMUL runs with no rescue), while the random and sweep runs, which call the wrappers by name, still pass;
|
||||
- the wrappers' route to the rescue removed (fpx_header's `(fast, exact) in (("mul32", "fma32"), ("fma32", "fma32"))`
|
||||
made never true): every run fails with no rescue counted, though every value still matches;
|
||||
- FMUL's wrapper passing mul=0 (an FMA with the zero addend, the same value with a hardware FMA): v2 fails (exit 4);
|
||||
- FPCR bits 0-2 dropped from RECOMP_FPX_FPCR_MASK (0x06C8FF07 -> 0x06C8FF00): every value still matches, but 190k of
|
||||
v3's random checks and 6.1M of its sweep's are rescues under FIZ/AH/NEP (v2: 99k and 2.6M);
|
||||
- the helper's UFC test removed (a64_fpx_sticky32's `if (!(s & 8u))` made `if (0)`, so a tiny result is kept with
|
||||
UFC clear): 486k and 3.5M mismatch at v3 (FPSR without UFC), 258k and 475k at v2;
|
||||
- its IDC test dropped (a flushed subnormal operand with IDC clear): 383k and 10.0M at v3, 146k and 3.8M at v2.
|
||||
|
||||
python -I -B tests/test_fpx_sticky.py [--cc clang] [--cxx clang++]
|
||||
|
||||
Skipped (exit 0) on a host that is not x86-64 or has no C/C++ compiler (PATH, $CC/$CXX, or the build's own emsdk /
|
||||
HOOKSHOT_MINGW toolchain), or on a CPU without x86-64-v2; the v3 build alone is skipped on a CPU without x86-64-v3.
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import platform
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
|
||||
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
KIT = os.path.join(ROOT, "third_party", "a64-kit")
|
||||
sys.path.insert(0, os.path.join(KIT, "lift"))
|
||||
sys.path.insert(0, os.path.join(KIT, "tools"))
|
||||
import toolchain # noqa: E402
|
||||
|
||||
RANDOM_TRIPLES, SEED, SWEEP_STRIDE = 8000000, 20261109, 97
|
||||
FLAGS = ["-ffp-contract=off", "-fno-strict-aliasing", "-O2"] # (nx2/build.py's lifted-code FP flags, with -march=)
|
||||
BUILDS = (("x86-64-v3", 1), ("x86-64-v2", 0)) # (-march, EXPECT_FMA: whether RECOMP_FPX_FMA64 holds there)
|
||||
|
||||
|
||||
def skip(why):
|
||||
print("fpx sticky: skipped (%s)" % why)
|
||||
sys.exit(0)
|
||||
|
||||
|
||||
def compiler(given, env, names, build_name):
|
||||
"""--cc/--cxx, else $CC/$CXX, else HOOKSHOT_MINGW's when it is set (target_flags gives its target and runtime, which
|
||||
another clang on PATH cannot use), else PATH, else the toolchain the build itself uses (emsdk)"""
|
||||
for c in (given, os.environ.get(env)):
|
||||
if c:
|
||||
return shutil.which(c) or (c if os.path.isfile(c) else None)
|
||||
if toolchain.mingw(host=True):
|
||||
c = toolchain.find(build_name, host=True)
|
||||
if os.path.isfile(c):
|
||||
return c
|
||||
for n in names:
|
||||
if shutil.which(n):
|
||||
return shutil.which(n)
|
||||
c = toolchain.find(build_name, host=True)
|
||||
return c if os.path.isfile(c) else None
|
||||
|
||||
|
||||
def target_flags(cc, tmp):
|
||||
"""clang on Windows: the build's target and lld (as tools/toolchain.py, with its lld-link copy in tmp, not in tools/)"""
|
||||
if os.name != "nt" or "clang" not in os.path.basename(cc).lower():
|
||||
return []
|
||||
flags = toolchain.native_target(host=True)
|
||||
if toolchain.mingw(host=True):
|
||||
return flags + toolchain.native_link(host=True)
|
||||
here = os.path.dirname(cc)
|
||||
link = shutil.which("lld-link", path=here) or shutil.which("lld-link")
|
||||
if not link:
|
||||
lld = shutil.which("lld", path=here) or shutil.which("lld")
|
||||
if not lld:
|
||||
return flags
|
||||
link = os.path.join(tmp, "lld-link.exe")
|
||||
if not os.path.exists(link):
|
||||
shutil.copyfile(lld, link)
|
||||
return flags + ["-fuse-ld=lld", "-B" + os.path.dirname(link), "-Wl,/nodefaultlib:oldnames"]
|
||||
|
||||
|
||||
def run(cmd, timeout=600):
|
||||
kw = {"creationflags": subprocess.BELOW_NORMAL_PRIORITY_CLASS | subprocess.CREATE_NO_WINDOW} if os.name == "nt" \
|
||||
else {"preexec_fn": lambda: os.nice(10)}
|
||||
return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, errors="replace",
|
||||
timeout=timeout, **kw)
|
||||
|
||||
|
||||
def build(cmd, what):
|
||||
r = run(cmd)
|
||||
if r.returncode:
|
||||
print(r.stdout)
|
||||
raise SystemExit("fpx sticky: building %s failed" % what)
|
||||
|
||||
|
||||
# Guest instructions for the lifted-route case (hand-written encodings): each runs as the lifter emits it, through
|
||||
# a64emit.translate and a64_lift.op_text (and hot_text), against the same word translated with FPX off.
|
||||
GUEST = (("FMUL s0, s1, s2", 0x1E220820, 1), ("FNMUL s0, s1, s2", 0x1E228820, 1),
|
||||
("FMADD s0, s1, s2, s3", 0x1F020C20, 0), ("FMLA s0, s1, v2.s[0]", 0x5F821020, 0)) # (name, word, FMUL)
|
||||
|
||||
|
||||
def lifted_cases(a64emit, a64_lift, used):
|
||||
"""fpx_lifted.h: per guest word its lifted, hot and exact-only (FPX off) C as functions, and the GUEST table"""
|
||||
words = [(0x1000, w) for _, w, _ in GUEST]
|
||||
lifted, fl = a64emit.translate(words)
|
||||
if any(fl):
|
||||
raise SystemExit("fpx sticky: a64emit did not translate the guest words: %s" % fl)
|
||||
lifted = [a64_lift.op_text(t, used) for t in lifted]
|
||||
a64emit.lib().a64_config(1, 0) # (FPX off: the exact body inline, the reference)
|
||||
try:
|
||||
exact, _ = a64emit.translate(words)
|
||||
finally:
|
||||
a64emit.lib().a64_config(1, 1)
|
||||
out = ["/* Generated by tests/test_fpx_sticky.py from guest words, as a64_lift.py lifts them. */"]
|
||||
for i, (lt, ex) in enumerate(zip(lifted, exact)):
|
||||
out.append("static void g_lifted%d(Ctx *__restrict c) { %s }" % (i, lt))
|
||||
out.append("static void g_hot%d(Ctx *__restrict c) { %s }" % (i, a64_lift.hot_text(lt)))
|
||||
out.append("static void g_exact%d(Ctx *__restrict c) { %s }" % (i, ex))
|
||||
out.append("static const struct { const char *name; int mul; void (*lifted)(Ctx *), (*hot)(Ctx *), (*exact)(Ctx *); }"
|
||||
" GUEST[] = {%s};" % ", ".join('{"%s", %d, g_lifted%d, g_hot%d, g_exact%d}' % (n, m, i, i, i)
|
||||
for i, (n, _, m) in enumerate(GUEST)))
|
||||
return "\n".join(out) + "\n"
|
||||
|
||||
|
||||
def generate(cxx, tmp, flags):
|
||||
"""a64_fpx.h, a64_suyu.h, a64_suyu.c and fpx_lifted.h, by the generators the lift runs (a64emit built into tmp)"""
|
||||
dll = os.path.join(tmp, "a64emit.dll" if os.name == "nt" else "liba64emit.so")
|
||||
build([cxx, "-std=c++20", "-O0", "-shared", "-Wno-everything", "-o", dll, os.path.join(KIT, "lift", "a64emit.cpp")]
|
||||
+ flags + ([] if os.name == "nt" else ["-fPIC"]), "a64emit")
|
||||
import build_emit
|
||||
build_emit.build = lambda force=False: dll # (not a64emit.dll beside the source)
|
||||
import a64_lift
|
||||
import a64_rtgen
|
||||
import a64emit
|
||||
used = set()
|
||||
try:
|
||||
a64_rtgen.write(tmp)
|
||||
lifted = lifted_cases(a64emit, a64_lift, used)
|
||||
finally:
|
||||
if a64emit._lib is not None: # (unloaded, so the folder can go)
|
||||
import _ctypes
|
||||
(_ctypes.FreeLibrary if os.name == "nt" else _ctypes.dlclose)(a64emit._lib._handle)
|
||||
a64emit._lib = None
|
||||
with open(os.path.join(tmp, "fpx_lifted.h"), "w", newline="\n") as f:
|
||||
f.write(lifted)
|
||||
with open(os.path.join(tmp, "a64_fpx.h"), "w", newline="\n") as f: # (the guest words' shapes, and the two the
|
||||
f.write(a64_lift.fpx_header(used | {("mul32", "fma32", 2, 3), ("fma32", "fma32", 3, 3)})) # runs call by name)
|
||||
|
||||
|
||||
def main():
|
||||
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
p.add_argument("--cc")
|
||||
p.add_argument("--cxx")
|
||||
a = p.parse_args()
|
||||
if platform.machine().lower() not in ("x86_64", "amd64"):
|
||||
skip("not an x86-64 host: %s" % platform.machine())
|
||||
cc = compiler(a.cc, "CC", ("clang", "gcc", "cc"), "clang")
|
||||
cxx = compiler(a.cxx, "CXX", ("clang++", "g++", "c++"), "clang++")
|
||||
if not cc or not cxx:
|
||||
skip("no C compiler" if not cc else "no C++ compiler")
|
||||
t0 = time.time()
|
||||
failed, ran = [], []
|
||||
with tempfile.TemporaryDirectory(prefix="hookshot-fpx-sticky-") as tmp:
|
||||
generate(cxx, tmp, target_flags(cxx, tmp))
|
||||
for march, fma in BUILDS:
|
||||
exe = os.path.join(tmp, "fpx_sticky_test_%s.exe" % march)
|
||||
build([cc] + target_flags(cc, tmp) + ["-march=" + march] + FLAGS +
|
||||
["-DEXPECT_FMA=%d" % fma, "-D_CRT_SECURE_NO_WARNINGS", "-I" + os.path.join(KIT, "rt"), "-I" + tmp,
|
||||
os.path.join(ROOT, "tests", "fpx_sticky_test.c"), os.path.join(tmp, "a64_suyu.c"), "-o", exe],
|
||||
"the driver at " + march)
|
||||
for args in (["lifted"], ["random", str(RANDOM_TRIPLES), str(SEED)], ["sweep", str(SWEEP_STRIDE)]):
|
||||
r = run([exe] + args)
|
||||
print(r.stdout.rstrip())
|
||||
if r.returncode == 3:
|
||||
print("fpx sticky: %s skipped (this CPU is not %s)" % (march, march))
|
||||
break
|
||||
ran.append(march)
|
||||
if r.returncode:
|
||||
failed.append("%s %s" % (march, args[0]))
|
||||
if not ran:
|
||||
skip("this CPU is not x86-64-v2")
|
||||
if failed:
|
||||
raise SystemExit("fpx sticky: FAIL (%s) in %.1f s" % (", ".join(failed), time.time() - t0))
|
||||
print("fpx sticky: pass in %.1f s" % (time.time() - t0))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user