File size: 6,085 Bytes
39ea985 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | """Pass A driver: parse a list of OMol25 calculations and write Zarr shards.
Usage (one node, all cores):
python pass_a.py --list subsets/subset_100k.txt --out store_100k --workers 64
Usage (sbatch array): add --task-id N --n-tasks M to process a contiguous stripe.
Each worker buffers records per dataset and flushes a shard once the buffer exceeds --shard-bytes,
so shard files stay a manageable size whether the systems are 15 atoms or 250.
"""
from __future__ import annotations
import argparse, os, sys, time, traceback
import multiprocessing as mp
import numpy as np
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from omol_parse import parse_archive
from omol_store import write_shard, shard_bytes, frontier
M5250 = "/global/cfs/projectdirs/m5250/OMol_elec"
def dataset_of(rel):
parts = rel.split("/")
if parts[0] == "omol" and len(parts) > 2:
return "/".join(parts[:3])
return parts[0]
def _prepare(rec, rel):
"""Attach identity and derived scalars; drop what the store does not keep."""
rec["rel_path"] = rel
rec["calc_id"] = rel.replace("/", "__")
rec["dataset"] = dataset_of(rel)
rec["n_atoms"] = len(rec["elements"])
rec["homo_a"], rec["lumo_a"], rec["gap_a"] = frontier(rec.get("eps_a"), rec.get("occ_a"))
rec["homo_b"], rec["lumo_b"], rec["gap_b"] = frontier(rec.get("eps_b"), rec.get("occ_b"))
return rec
def worker(args):
"""Process one (dataset, chunk) unit and write exactly one p1 and one p2 shard.
Work is grouped by dataset upstream so each shard is large. Writing many small Zarr groups is
metadata-bound on CFS (roughly 80 arrays per shard), so few-and-large is far faster.
"""
(wid, ds, chunk_idx, rels, out_root, shard_budget, task_id) = args
p1_root = os.path.join(out_root, "p1")
p2_root = os.path.join(out_root, "p2")
recs, buffered, n_sub = [], 0, 0
n_ok = n_fail = 0
failures = []
t0 = time.time()
def flush():
nonlocal recs, buffered, n_sub
if not recs:
return
name = f"shard_t{task_id:02d}_{chunk_idx:04d}_{n_sub:02d}.zarr"
write_shard(recs, os.path.join(p1_root, ds), name, include_matrices=False)
write_shard(recs, os.path.join(p2_root, ds), name, include_matrices=True)
n_sub += 1
recs, buffered = [], 0
for rel in rels:
tar = os.path.join(M5250, rel, "orca.tar.zst")
try:
rec = _prepare(parse_archive(tar), rel)
# A Fock matrix is not universal: some inputs omit Print[P_Fockian] entirely
# (about a quarter of omol/redo_orca6). Those rows are still complete for Project 1,
# so they are kept and flagged rather than dropped.
if rec["nbas"] is None or not rec["elements"]:
raise ValueError("incomplete record (nbas or geometry missing)")
recs.append(rec)
buffered += shard_bytes(rec)
n_ok += 1
if buffered > shard_budget:
flush()
except Exception as e:
n_fail += 1
failures.append(f"{rel}\t{type(e).__name__}\t{str(e)[:200]}")
flush()
dt = time.time() - t0
print(f"[w{wid:03d}] {ds}/{chunk_idx:04d}: ok={n_ok} fail={n_fail} "
f"{dt/max(len(rels),1):.2f}s/calc", flush=True)
return wid, n_ok, n_fail, failures, dt
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--list", required=True)
ap.add_argument("--out", required=True)
ap.add_argument("--workers", type=int, default=32)
ap.add_argument("--limit", type=int, default=0)
ap.add_argument("--task-id", type=int, default=0)
ap.add_argument("--n-tasks", type=int, default=1)
ap.add_argument("--shard-bytes", type=float, default=1.5e9)
ap.add_argument("--calcs-per-chunk", type=int, default=1500,
help="calculations per work unit; one unit writes one shard")
args = ap.parse_args()
with open(args.list) as fh:
rels = [l.strip() for l in fh if l.strip()]
if args.limit:
rels = rels[:args.limit]
if args.n_tasks > 1:
rels = rels[args.task_id::args.n_tasks]
os.makedirs(args.out, exist_ok=True)
print(f"pass A: {len(rels):,} calculations, {args.workers} workers -> {args.out}", flush=True)
by_ds = {}
for rel in rels:
by_ds.setdefault(dataset_of(rel), []).append(rel)
units = []
for ds in sorted(by_ds):
lst = by_ds[ds]
for c, start in enumerate(range(0, len(lst), args.calcs_per_chunk)):
units.append((ds, c, lst[start:start + args.calcs_per_chunk]))
units.sort(key=lambda u: -len(u[2])) # longest first, so the tail is short
jobs = [(i % args.workers, ds, c, lst, args.out, args.shard_bytes, args.task_id)
for i, (ds, c, lst) in enumerate(units)]
print(f"{len(by_ds)} datasets -> {len(jobs)} work units "
f"(<= {args.calcs_per_chunk} calcs each)", flush=True)
t0 = time.time()
n_ok = n_fail = 0
all_fail = []
with mp.Pool(min(args.workers, len(jobs))) as pool:
done = 0
for wid, ok, fail, failures, dt in pool.imap_unordered(worker, jobs):
n_ok += ok
n_fail += fail
all_fail.extend(failures)
done += 1
el = time.time() - t0
print(f" units {done}/{len(jobs)} ok={n_ok:,} fail={n_fail:,} "
f"elapsed {el/60:.1f} min eta {el/done*(len(jobs)-done)/60:.1f} min", flush=True)
dt = time.time() - t0
fail_path = os.path.join(args.out, f"failures_task{args.task_id}.tsv")
if all_fail:
with open(fail_path, "w") as fh:
fh.write("rel_path\terror\tdetail\n" + "\n".join(all_fail) + "\n")
print(f"\nok {n_ok:,} failed {n_fail:,} wall {dt/60:.1f} min "
f"({dt*args.workers/max(n_ok,1):.2f} core-s per calc)")
if all_fail:
print(f"failures written to {fail_path}")
if __name__ == "__main__":
mp.set_start_method("fork", force=True) # forkserver hangs under srun on Perlmutter
main()
|