| |
| """Execute predicted CadQuery programs into meshes, one throwaway process each. |
| |
| Split out of infer_cadrille_geomcad.py because running these in the generation |
| loop kept killing the job. OCCT does not hand memory back between programs, and |
| a predicted sweep is routinely a few hundred spline segments whose tessellation |
| allocates gigabytes, so a long split climbs until the OOM killer takes it with |
| the GPU work half finished. maxtasksperchild=1 gives every program a fresh |
| interpreter, which makes accumulation impossible rather than merely slower, and |
| an address-space cap turns a pathological solid into one failed sample instead |
| of a dead machine. Spawn cost is milliseconds against a 30 second timeout. |
| |
| Idempotent: a directory that already holds a mesh is skipped, so this can be run |
| against a split that is still being generated, and again when it finishes. |
| |
| python exec_preds.py --pred preds_geomcad20k/sweep --workers 8 |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import multiprocessing as mp |
| import os |
| import resource |
| import signal |
| from pathlib import Path |
|
|
| EXEC_TIMEOUT = 30 |
| |
| |
| MEM_LIMIT_GB = 8 |
|
|
|
|
| class _Timeout(Exception): |
| pass |
|
|
|
|
| def _alarm(signum, frame): |
| raise _Timeout() |
|
|
|
|
| def _init(): |
| lim = MEM_LIMIT_GB * 1024 ** 3 |
| try: |
| resource.setrlimit(resource.RLIMIT_AS, (lim, lim)) |
| except (ValueError, OSError): |
| pass |
| for v in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS"): |
| os.environ.setdefault(v, "1") |
|
|
|
|
| def run_one(args) -> bool: |
| py, stl = args |
| signal.signal(signal.SIGALRM, _alarm) |
| signal.alarm(EXEC_TIMEOUT) |
| try: |
| import cadquery as cq |
| import trimesh |
| ns = {} |
| exec(Path(py).read_text(errors="ignore"), {"cq": cq}, ns) |
| vertices, faces = ns["r"].val().tessellate(0.001, 0.1) |
| trimesh.Trimesh([(v.x, v.y, v.z) for v in vertices], faces).export(str(stl)) |
| return True |
| except BaseException: |
| |
| |
| return False |
| finally: |
| try: |
| signal.alarm(0) |
| except BaseException: |
| pass |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--pred", required=True, help="directory of <id>/<id>.txt") |
| ap.add_argument("--workers", type=int, default=4) |
| ap.add_argument("--redo", action="store_true", help="rebuild meshes that exist") |
| args = ap.parse_args() |
|
|
| root = Path(args.pred) |
| jobs, skipped = [], 0 |
| for d in sorted(root.iterdir(), key=lambda p: (len(p.name), p.name)): |
| if not d.is_dir(): |
| continue |
| sid = d.name |
| py = d / f"{sid}.txt" |
| stl = d / f"{sid}.stl" |
| if not py.is_file(): |
| continue |
| if stl.is_file() and not args.redo: |
| skipped += 1 |
| continue |
| jobs.append((str(py), str(stl))) |
|
|
| print(f"{root.name}: {len(jobs)} to execute, {skipped} already have a mesh", |
| flush=True) |
| if not jobs: |
| return |
|
|
| ok = 0 |
| ctx = mp.get_context("spawn") |
| with ctx.Pool(args.workers, initializer=_init, maxtasksperchild=1) as pool: |
| for n, good in enumerate(pool.imap_unordered(run_one, jobs, chunksize=1), 1): |
| ok += good |
| if n % 100 == 0 or n == len(jobs): |
| print(f" {n}/{len(jobs)} executed {ok}", flush=True) |
|
|
| total = ok + skipped |
| print(f"{root.name}: {ok}/{len(jobs)} newly executed, {total} meshes present") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
