Fix clean release verification inputs
FemLite CI / build-test (push) Has been cancelled

This commit is contained in:
shenw
2026-06-26 13:14:38 +08:00
parent f54d7345d9
commit 9f577c0675
8 changed files with 642 additions and 2 deletions
+74
View File
@@ -0,0 +1,74 @@
from __future__ import annotations
import argparse
import re
import sys
from pathlib import Path
DOC_SUFFIXES = {".md", ".pdf", ".ppt", ".pptx", ".txt", ".rst"}
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Check FemLite example folder layout.")
parser.add_argument("repo_root")
return parser.parse_args()
def main() -> int:
args = parse_args()
repo_root = Path(args.repo_root).resolve()
examples_dir = repo_root / "examples"
violations: list[str] = []
if not examples_dir.exists():
print(f"examples directory does not exist: {examples_dir}")
return 1
for folder in sorted(path for path in examples_dir.iterdir() if path.is_dir()):
files = [path for path in folder.iterdir() if path.is_file()]
inputs = sorted(path.name for path in files if path.suffix.lower() == ".inp")
docs = sorted(path.name for path in files if path.suffix.lower() in DOC_SUFFIXES)
run_case = folder / "run_case.bat"
if docs and not inputs:
violations.append(
f"{folder.relative_to(repo_root)} has documentation but no .inp case"
)
if inputs and not run_case.exists():
violations.append(
f"{folder.relative_to(repo_root)} has .inp cases but no run_case.bat"
)
if run_case.exists():
text = run_case.read_text(encoding="utf-8", errors="replace").lower()
if "femlite" not in text and "run_example_case.bat" not in text:
violations.append(
f"{run_case.relative_to(repo_root)} does not appear to launch FemLite"
)
for raw_line in text.splitlines():
if "run_example_case.bat" not in raw_line:
continue
quoted = re.findall(r'"([^"]+)"', raw_line)
if len(quoted) < 5:
violations.append(
f"{run_case.relative_to(repo_root)} has a malformed helper call"
)
continue
input_name = quoted[4]
if not (folder / input_name).exists():
violations.append(
f"{run_case.relative_to(repo_root)} points to missing input {input_name}"
)
if violations:
print("Example layout violations:")
for violation in violations:
print(f" {violation}")
return 1
print("Example layout passed: documented folders have .inp cases and runnable scripts.")
return 0
if __name__ == "__main__":
sys.exit(main())
@@ -0,0 +1,99 @@
#!/usr/bin/env python3
"""Check contact pair performance smoke stats across OpenMP thread counts."""
from __future__ import annotations
import os
import re
import subprocess
import sys
from pathlib import Path
METRICS = (
"active_count",
"search_facets",
"search_masters",
"search_broad",
"search_active",
"bvh_nodes",
"cache_used",
)
def run_case(source_root: Path, executable: Path, threads: int) -> dict[str, int]:
env = os.environ.copy()
env["OMP_NUM_THREADS"] = str(threads)
proc = subprocess.run(
[str(executable), "32", "1"],
cwd=source_root,
env=env,
text=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
check=False,
)
if proc.returncode != 0:
print(proc.stdout, end="")
raise SystemExit(
f"perf_contact_pair failed for OMP_NUM_THREADS={threads}: "
f"exit {proc.returncode}"
)
return parse_metrics(proc.stdout, threads)
def parse_metrics(output: str, threads: int) -> dict[str, int]:
values: dict[str, int] = {}
for line in output.splitlines():
match = re.match(r"\s*([A-Za-z_]+):\s+([-+]?\d+)\s*$", line)
if match and match.group(1) in METRICS:
values[match.group(1)] = int(match.group(2))
missing = [metric for metric in METRICS if metric not in values]
if missing:
print(output, end="")
raise SystemExit(
f"missing metrics for OMP_NUM_THREADS={threads}: {', '.join(missing)}"
)
if values["active_count"] <= 0:
raise SystemExit(f"no active contact for OMP_NUM_THREADS={threads}")
if values["cache_used"] <= 0:
raise SystemExit(f"no BVH cache use for OMP_NUM_THREADS={threads}")
return values
def main(argv: list[str]) -> int:
if len(argv) != 3:
print(
"usage: check_perf_contact_pair_omp.py <source-root> "
"<perf_contact_pair-exe>"
)
return 2
source_root = Path(argv[1]).resolve()
executable = Path(argv[2]).resolve()
serial = run_case(source_root, executable, 1)
parallel = run_case(source_root, executable, 4)
mismatches = [
metric
for metric in METRICS
if serial[metric] != parallel[metric]
]
if mismatches:
print("OpenMP contact performance statistics differ:")
for metric in mismatches:
print(
f" {metric}: OMP=1 {serial[metric]}, "
f"OMP=4 {parallel[metric]}"
)
return 1
print("perf_contact_pair OpenMP consistency: PASS")
for metric in METRICS:
print(f" {metric}: {serial[metric]}")
return 0
if __name__ == "__main__":
raise SystemExit(main(sys.argv))
+212
View File
@@ -0,0 +1,212 @@
from __future__ import annotations
import argparse
import re
import sys
from pathlib import Path
SOURCE_SUFFIXES = {".f90", ".c", ".h", ".py"}
FORTRAN_ROUTINE = re.compile(
r"^\s*(?:recursive\s+)?(?:subroutine|function|integer\s+function|"
r"logical\s+function|real\s*\([^)]*\)\s+function)\s+([a-zA-Z_]\w*)",
re.IGNORECASE,
)
PYTHON_FUNCTION = re.compile(r"^(?P<indent>\s*)def\s+(?P<name>[a-zA-Z_]\w*)\s*\(")
C_FUNCTION = re.compile(
r"^\s*(?:static\s+)?(?:int|void|double|float|char|long|short|size_t|"
r"bool)\s+([a-zA-Z_]\w*)\s*\([^;]*\)\s*\{?\s*$"
)
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Check FemLite source size limits.")
parser.add_argument("repo_root")
parser.add_argument("--warn-file-lines", type=int, default=1500)
parser.add_argument("--max-file-lines", type=int, default=2000)
parser.add_argument("--warn-routine-lines", type=int, default=100)
parser.add_argument("--max-routine-lines", type=int, default=128)
parser.add_argument("--exceptions", default="")
return parser.parse_args()
def source_files(repo_root: Path) -> list[Path]:
files: list[Path] = []
for folder in ("src", "tests", "tools"):
root = repo_root / folder
if not root.exists():
continue
for path in root.rglob("*"):
if path.is_file() and path.suffix.lower() in SOURCE_SUFFIXES:
files.append(path)
return sorted(files)
def fortran_routines(lines: list[str]) -> list[tuple[str, int, int]]:
starts: list[tuple[str, int]] = []
for line_no, line in enumerate(lines, start=1):
match = FORTRAN_ROUTINE.match(line)
if match:
starts.append((match.group(1), line_no))
routines: list[tuple[str, int, int]] = []
for index, (name, start) in enumerate(starts):
end = starts[index + 1][1] - 1 if index + 1 < len(starts) else len(lines)
routines.append((name, start, end - start + 1))
return routines
def python_functions(lines: list[str]) -> list[tuple[str, int, int]]:
routines: list[tuple[str, int, int]] = []
for line_no, line in enumerate(lines, start=1):
match = PYTHON_FUNCTION.match(line)
if not match:
continue
indent = len(match.group("indent"))
end = len(lines)
for next_no in range(line_no + 1, len(lines) + 1):
next_line = lines[next_no - 1]
if len(next_line.strip()) == 0:
continue
next_indent = len(next_line) - len(next_line.lstrip())
if next_indent <= indent:
end = next_no - 1
break
routines.append((match.group("name"), line_no, end - line_no + 1))
return routines
def c_functions(lines: list[str]) -> list[tuple[str, int, int]]:
routines: list[tuple[str, int, int]] = []
line_no = 1
while line_no <= len(lines):
match = C_FUNCTION.match(lines[line_no - 1])
if not match:
line_no += 1
continue
depth = lines[line_no - 1].count("{") - lines[line_no - 1].count("}")
end = line_no
while end < len(lines) and depth > 0:
end += 1
depth += lines[end - 1].count("{") - lines[end - 1].count("}")
routines.append((match.group(1), line_no, end - line_no + 1))
line_no = end + 1
return routines
def routines_for(path: Path, lines: list[str]) -> list[tuple[str, int, int]]:
suffix = path.suffix.lower()
if suffix == ".f90":
return fortran_routines(lines)
if suffix == ".py":
return python_functions(lines)
if suffix in {".c", ".h"}:
return c_functions(lines)
return []
def load_exceptions(repo_root: Path, relpath: str) -> dict[tuple[str, str, str], str]:
exceptions: dict[tuple[str, str, str], str] = {}
if not relpath:
return exceptions
path = repo_root / relpath
if not path.exists():
return exceptions
for raw_line in path.read_text(encoding="utf-8").splitlines():
line = raw_line.strip()
if not line or line.startswith("#"):
continue
parts = line.split("|", 3)
if len(parts) != 4:
raise ValueError(f"bad exception line in {path}: {raw_line}")
kind, source_path, name, reason = (part.strip() for part in parts)
if not reason:
raise ValueError(f"missing exception reason in {path}: {raw_line}")
exceptions[(kind, source_path.replace("\\", "/"), name)] = reason
return exceptions
def exception_reason(
exceptions: dict[tuple[str, str, str], str],
kind: str,
relative: Path,
name: str = "",
) -> str:
return exceptions.get((kind, relative.as_posix(), name), "")
def main() -> int:
args = parse_args()
repo_root = Path(args.repo_root).resolve()
violations: list[str] = []
warnings: list[str] = []
exceptions = load_exceptions(repo_root, args.exceptions)
used_exceptions: set[tuple[str, str, str]] = set()
for path in source_files(repo_root):
lines = path.read_text(encoding="utf-8").splitlines()
relative = path.relative_to(repo_root)
file_reason = exception_reason(exceptions, "file", relative)
if len(lines) > args.max_file_lines:
message = f"{relative}: file has {len(lines)} lines, hard limit is {args.max_file_lines}"
if file_reason:
used_exceptions.add(("file", relative.as_posix(), ""))
warnings.append(f"{message}; exception: {file_reason}")
else:
violations.append(message)
elif len(lines) > args.warn_file_lines:
warnings.append(
f"{relative}: file has {len(lines)} lines, review target is "
f"{args.warn_file_lines}"
)
for name, start, count in routines_for(path, lines):
routine_reason = exception_reason(exceptions, "routine", relative, name)
if count > args.max_routine_lines:
message = (
f"{relative}:{start}: {name} has {count} lines, "
f"hard limit is {args.max_routine_lines}"
)
if routine_reason:
used_exceptions.add(("routine", relative.as_posix(), name))
warnings.append(f"{message}; exception: {routine_reason}")
else:
violations.append(message)
elif count > args.warn_routine_lines:
warnings.append(
f"{relative}:{start}: {name} has {count} lines, review target "
f"is {args.warn_routine_lines}"
)
for kind, source_path, name in sorted(set(exceptions) - used_exceptions):
violations.append(
f"stale source size exception: {kind}|{source_path}|{name} "
"does not match a current hard-threshold item"
)
if violations:
print("Source size limit violations:")
for violation in violations:
print(f" {violation}")
if warnings:
print("Source size warnings:")
for warning in warnings:
print(f" {warning}")
return 1
print(
"Source size limits passed: "
f"files require review above {args.warn_file_lines} lines and "
f"exceptions above {args.max_file_lines}; "
f"routines target {args.warn_routine_lines} lines and require "
f"exceptions above {args.max_routine_lines}"
)
if warnings:
print("Source size warnings:")
for warning in warnings:
print(f" {warning}")
return 0
if __name__ == "__main__":
sys.exit(main())
+205
View File
@@ -0,0 +1,205 @@
from __future__ import annotations
import argparse
import csv
import re
import subprocess
import sys
from pathlib import Path
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Run a lightweight FemLite example smoke test.")
parser.add_argument("repo_root")
parser.add_argument("femlite_exe")
parser.add_argument("build_dir")
parser.add_argument("case_name")
parser.add_argument("input_relpath")
parser.add_argument("mode", choices=("run", "static-linear"))
parser.add_argument("--dynamic-steps", type=int, default=0)
parser.add_argument("--output-interval", type=int, default=0)
parser.add_argument("--require-contact", action="store_true")
parser.add_argument("--require-friction", action="store_true")
parser.add_argument("--probe-node", type=int)
parser.add_argument("--probe-field", choices=("ux", "uy", "uz"))
parser.add_argument("--min-abs-displacement", type=float, default=0.0)
parser.add_argument("--sign", choices=("negative", "positive", "either"), default="either")
parser.add_argument(
"--check-script",
help="Optional repo-relative Python checker called with the example output directory.",
)
return parser.parse_args()
def shortened_dynamic_input(source: Path, destination: Path, steps: int) -> Path:
lines = source.read_text(encoding="utf-8").splitlines()
for index, line in enumerate(lines):
if line.strip().upper().startswith("*DYNAMIC"):
data_index = index + 1
if data_index >= len(lines):
raise ValueError(f"{source} has *DYNAMIC without a data line")
parts = lines[data_index].split(",")
if not parts:
raise ValueError(f"{source} has an empty *DYNAMIC data line")
dt = float(parts[0])
lines[data_index] = f"{dt:.10E}, {dt * steps:.10E}"
destination.write_text("\n".join(lines) + "\n", encoding="utf-8")
return destination
raise ValueError(f"{source} does not contain *DYNAMIC")
def run_case(args: argparse.Namespace) -> tuple[str, int]:
repo_root = Path(args.repo_root).resolve()
femlite_exe = Path(args.femlite_exe).resolve()
build_dir = Path(args.build_dir).resolve()
source_inp = repo_root / args.input_relpath
case_dir = build_dir / "example_smoke" / args.case_name
case_dir.mkdir(parents=True, exist_ok=True)
inp = source_inp
expected_steps = 1 if args.mode == "static-linear" else None
if args.dynamic_steps > 0:
inp = shortened_dynamic_input(source_inp, case_dir / source_inp.name, args.dynamic_steps)
expected_steps = args.dynamic_steps
command = [str(femlite_exe), str(inp)]
if args.mode == "run":
command.append("--run")
elif args.mode == "static-linear":
command.append("--static-linear")
command.extend(["--output-dir", str(case_dir)])
command.extend(["--output-interval", str(args.output_interval)])
completed = subprocess.run(
command,
cwd=repo_root,
text=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
)
print(completed.stdout)
if completed.returncode != 0:
raise RuntimeError(f"FemLite exited with code {completed.returncode}")
match = re.search(r"steps:\s*(\d+)", completed.stdout)
if not match:
raise RuntimeError("FemLite output did not contain a step count")
steps = int(match.group(1))
if expected_steps is not None and steps != expected_steps:
raise RuntimeError(f"expected {expected_steps} steps, got {steps}")
return completed.stdout, steps
def check_contact_output(build_dir: Path, case_name: str, step: int) -> None:
contact_file = build_dir / "example_smoke" / case_name / f"contact_{step:08d}.csv"
if not contact_file.exists():
raise RuntimeError(f"missing contact output: {contact_file}")
with contact_file.open(newline="", encoding="utf-8") as handle:
rows = list(csv.DictReader(handle))
summary = next((row for row in rows if row.get("kind") == "SUMMARY"), None)
if summary is None:
raise RuntimeError(f"{contact_file} does not contain a SUMMARY row")
active = int(summary["active_count"])
if active <= 0:
raise RuntimeError(f"{contact_file} did not record active contact")
def check_friction_output(build_dir: Path, case_name: str, step: int) -> None:
contact_file = build_dir / "example_smoke" / case_name / f"contact_{step:08d}.csv"
if not contact_file.exists():
raise RuntimeError(f"missing contact output: {contact_file}")
with contact_file.open(newline="", encoding="utf-8") as handle:
rows = [row for row in csv.DictReader(handle) if row.get("kind") == "PAIR"]
if not rows:
raise RuntimeError(f"{contact_file} does not contain contact pair rows")
max_slip = max(float(row["accumulated_slip"]) for row in rows)
max_work = max(float(row["friction_work_total"]) for row in rows)
min_work = min(float(row["friction_work_total"]) for row in rows)
max_reg = max(float(row["friction_regularization"]) for row in rows)
max_ft = max(
max(abs(float(row["ftx"])), abs(float(row["fty"])), abs(float(row["ftz"])))
for row in rows
)
if max_reg <= 0.0:
raise RuntimeError(f"{contact_file} did not report friction regularization")
if max_slip <= 0.0 or max_ft <= 0.0:
raise RuntimeError(f"{contact_file} did not record frictional slip")
if min_work < -1.0e-12 or max_work <= 0.0:
raise RuntimeError(f"{contact_file} did not record positive friction work")
def check_node_probe(args: argparse.Namespace, step: int) -> None:
if args.probe_node is None:
return
if args.probe_field is None:
raise RuntimeError("--probe-field is required when --probe-node is set")
build_dir = Path(args.build_dir).resolve()
node_file = build_dir / "example_smoke" / args.case_name / f"nodes_{step:08d}.csv"
if not node_file.exists():
raise RuntimeError(f"missing node output: {node_file}")
with node_file.open(newline="", encoding="utf-8") as handle:
rows = list(csv.DictReader(handle))
row = next(
(item for item in rows if int(item["node_id"]) == args.probe_node),
None,
)
if row is None:
raise RuntimeError(f"{node_file} does not contain node {args.probe_node}")
value = float(row[args.probe_field])
if abs(value) < args.min_abs_displacement:
raise RuntimeError(
f"{args.probe_field} at node {args.probe_node} is too small: {value}"
)
if args.sign == "negative" and value >= 0.0:
raise RuntimeError(
f"{args.probe_field} at node {args.probe_node} is not negative: {value}"
)
if args.sign == "positive" and value <= 0.0:
raise RuntimeError(
f"{args.probe_field} at node {args.probe_node} is not positive: {value}"
)
def run_custom_checker(args: argparse.Namespace) -> None:
if not args.check_script:
return
repo_root = Path(args.repo_root).resolve()
build_dir = Path(args.build_dir).resolve()
case_dir = build_dir / "example_smoke" / args.case_name
check_script = repo_root / args.check_script
if not check_script.exists():
raise RuntimeError(f"missing check script: {check_script}")
completed = subprocess.run(
[sys.executable, str(check_script), str(case_dir)],
cwd=repo_root,
text=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
)
print(completed.stdout)
if completed.returncode != 0:
raise RuntimeError(f"{check_script} exited with code {completed.returncode}")
def main() -> int:
args = parse_args()
_, steps = run_case(args)
if args.require_contact:
check_contact_output(Path(args.build_dir).resolve(), args.case_name, steps)
if args.require_friction:
check_friction_output(Path(args.build_dir).resolve(), args.case_name, steps)
check_node_probe(args, steps)
run_custom_checker(args)
return 0
if __name__ == "__main__":
raise SystemExit(main())
+44
View File
@@ -0,0 +1,44 @@
from pathlib import Path
import sys
def main() -> int:
if len(sys.argv) != 4:
print("usage: test_python_debug.py <repo-root> <femlite-exe> <build-dir>")
return 2
repo_root = Path(sys.argv[1]).resolve()
femlite_exe = Path(sys.argv[2]).resolve()
build_dir = Path(sys.argv[3]).resolve()
sys.path.insert(0, str(repo_root / "Python"))
from femlite_debug import FemLiteRunner
runner = FemLiteRunner(femlite_exe)
summary = runner.inspect_model(repo_root / "examples" / "c3d4_one_element.inp")
summary.check()
fields = summary.fields()
if int(fields["nodes"]) != 4:
return 10
if int(fields["elements"]) != 1:
return 11
if int(fields["dofs"]) != 12:
return 12
solved = runner.solve_implicit_linear(
repo_root / "tests" / "data" / "c3d4_implicit_pull.inp"
)
solved.check()
if solved.int_field("steps") != 1:
return 20
if solved.float_field("residual") > 1.0e-8:
return 21
marker = build_dir / "python_debug_checked.txt"
marker.write_text("python debug interface ok\n", encoding="utf-8")
return 0
if __name__ == "__main__":
raise SystemExit(main())