| |
| """Build the pinned macOS pilot cells; preserve commands, .ii, dSYM and inputs.""" |
|
|
| import argparse, hashlib, json, shutil, subprocess, tarfile, time |
| from pathlib import Path |
|
|
|
|
| def sha(p): |
| h = hashlib.sha256() |
| with p.open("rb") as f: |
| for block in iter(lambda: f.read(1024 * 1024), b""): |
| h.update(block) |
| return h.hexdigest() |
|
|
|
|
| def run(cmd, cwd, log): |
| log.write(json.dumps({"command": cmd, "cwd": str(cwd)}) + "\n") |
| log.flush() |
| subprocess.run(cmd, cwd=cwd, stdout=log, stderr=log, check=True) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--root", type=Path, required=True) |
| ap.add_argument("--plan", type=Path, required=True) |
| a = ap.parse_args() |
| root = a.root.resolve() |
| plan = json.loads(a.plan.read_text()) |
| base = root / "staged/qualification-v2" |
| for c in plan["cells"]: |
| if c["platform"] != "macos": |
| continue |
| src = root / "sources" / c["project"] |
| assert ( |
| subprocess.check_output( |
| ["git", "-C", str(src), "rev-parse", "HEAD"], text=True |
| ).strip() |
| == c["source_revision"] |
| ) |
| owned = base / "sources" / c["project"] |
| owned.mkdir(parents=True, exist_ok=True) |
| subprocess.run( |
| [ |
| "git", |
| "-C", |
| str(src), |
| "archive", |
| "--format=tar.gz", |
| "--output", |
| str(owned / "original.tar.gz"), |
| "HEAD", |
| ], |
| check=True, |
| ) |
| for mode, opt in [ |
| ("O0", "-O0"), |
| ("O2", "-O2"), |
| ("O2-noinline", "-O2 -fno-inline"), |
| ]: |
| build = root / "builds/macos" / c["project"] / mode |
| out = base / "macos/arm64" / mode / c["project"] |
| out.mkdir(parents=True, exist_ok=True) |
| build.mkdir(parents=True, exist_ok=True) |
| status = { |
| "project": c["project"], |
| "platform": "macos", |
| "optimization": mode, |
| "source_revision": c["source_revision"], |
| "state": "building", |
| "scoring_ready": False, |
| } |
| started = time.monotonic() |
| try: |
| flags = opt + " -g -fno-builtin -save-temps=obj" |
| configure = [ |
| "cmake", |
| "-S", |
| str(src), |
| "-B", |
| str(build), |
| "-G", |
| "Unix Makefiles", |
| "--fresh", |
| "-DCMAKE_BUILD_TYPE=Qualification", |
| "-DCMAKE_C_FLAGS=" + flags, |
| "-DCMAKE_CXX_FLAGS=" + flags, |
| "-DCMAKE_C_FLAGS_QUALIFICATION=-DNDEBUG", |
| "-DCMAKE_CXX_FLAGS_QUALIFICATION=-DNDEBUG", |
| "-DCMAKE_OSX_ARCHITECTURES=arm64", |
| "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON", |
| "-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=OFF", |
| "-DBUILD_TESTING=OFF", |
| ] |
| if c["project"] == "snappy": |
| configure += [ |
| "-DBUILD_SHARED_LIBS=ON", |
| "-DSNAPPY_BUILD_TESTS=OFF", |
| "-DSNAPPY_BUILD_BENCHMARKS=OFF", |
| ] |
| target = "snappy" |
| image = build / "libsnappy.dylib" |
| elif c["project"] == "ninja": |
| target = "ninja" |
| image = build / "ninja" |
| else: |
| configure += [ |
| "-DBUILD_SHARED_LIBS=OFF", |
| "-DENABLE_GTEST=OFF", |
| "-DENABLE_BENCHMARK=OFF", |
| "-DBUILD_PYTHON=OFF", |
| "-DBUILD_OPENCC_JIEBA_PLUGIN=OFF", |
| ] |
| target = "opencc" |
| image = build / "src/tools/opencc" |
| with (out / "build.log").open("w") as log: |
| run(configure, src, log) |
| run( |
| [ |
| "cmake", |
| "--build", |
| str(build), |
| "--target", |
| target, |
| "--parallel", |
| "3", |
| ], |
| src, |
| log, |
| ) |
| if not image.exists(): |
| options = [ |
| p |
| for p in build.rglob("opencc") |
| if p.is_file() and not p.is_symlink() |
| ] |
| assert len(options) == 1, options |
| image = options[0] |
| binary = out / image.name |
| shutil.copy2(image, binary) |
| run( |
| [ |
| "xcrun", |
| "dsymutil", |
| str(image), |
| "-o", |
| str(out / (image.name + ".dSYM")), |
| ], |
| src, |
| log, |
| ) |
| run( |
| [ |
| "xcrun", |
| "dwarfdump", |
| "--verify", |
| str(out / (image.name + ".dSYM")), |
| ], |
| src, |
| log, |
| ) |
| with (out / "debug-uuid.txt").open("w") as uuid: |
| subprocess.run( |
| [ |
| "xcrun", |
| "dwarfdump", |
| "--uuid", |
| str(binary), |
| str(out / (image.name + ".dSYM")), |
| ], |
| stdout=uuid, |
| check=True, |
| ) |
| stripped = out / (image.name + ".stripped") |
| shutil.copy2(binary, stripped) |
| run(["llvm-strip", "--strip-all", str(stripped)], src, log) |
| for path, label in [(binary, "original"), (stripped, "stripped")]: |
| with (out / (label + "-sections.txt")).open("w") as dest: |
| subprocess.run( |
| [ |
| "llvm-readobj", |
| "--file-headers", |
| "--sections", |
| str(path), |
| ], |
| stdout=dest, |
| check=True, |
| ) |
| shutil.copy2( |
| build / "compile_commands.json", out / "compile_commands.json" |
| ) |
| preprocessed = out / "preprocessed.tar.gz" |
| iis = [ |
| p |
| for p in build.rglob("*.ii") |
| if "CompilerId" not in str(p) and "CMakeScratch" not in str(p) |
| ] |
| assert iis, "No preprocessed TUs" |
| with tarfile.open(preprocessed, "w:gz") as tar: |
| for p in sorted(iis): |
| tar.add(p, arcname=str(p.relative_to(build))) |
| status.update( |
| state="artifact-built-debug-verified", |
| binary=str(binary.relative_to(base)), |
| binary_sha256=sha(binary), |
| stripped=str(stripped.relative_to(base)), |
| stripped_sha256=sha(stripped), |
| preprocessed_tus=len(iis), |
| compiler=subprocess.check_output( |
| ["xcrun", "clang++", "--version"], text=True |
| ).splitlines()[0], |
| effective_flags=flags + " -DNDEBUG", |
| remaining_gates=[ |
| "source-owned function identity extraction", |
| "source/ABI type ground truth adapter", |
| "code-section parity and no-debug input verification", |
| ], |
| ) |
| except Exception as e: |
| status.update(state="failed", error=str(e)) |
| status["elapsed_seconds"] = time.monotonic() - started |
| (out / "status.json").write_text(json.dumps(status, indent=2)) |
| print(json.dumps(status), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
