#!/usr/bin/env python3 """Compute-node smoke test for :class:`CompactGraphDataset`. The test intentionally samples rather than scans the complete dataset. It exercises: * deterministic random graph reconstruction; * at least one graph from every selected shard and cross-shard batches; * the per-process mmap shard cache through repeated access; * PyG DataLoader collation with zero and multiple worker processes; and * model-facing tensor shapes, dtypes, index ranges, and finite values. Timing, process RSS/high-water marks, page faults, and filesystem I/O counters are written to an atomic JSON report. GNU ``time -v`` and Slurm accounting in the companion sbatch file provide job-wide measurements including workers. """ from __future__ import annotations import argparse import gc import json import math import os import random import resource import socket import statistics import sys import time import traceback from pathlib import Path from typing import Any, Dict, List, Mapping, Sequence import torch import torch_geometric from torch.utils.data import Subset from torch_geometric.data import Batch, Data from torch_geometric.loader import DataLoader from compact_graph_dataset import CompactGraphDataset MIB = 1024 * 1024 def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser( description="Sample, batch, and profile a compact GNNCP dataset." ) parser.add_argument("--compact", required=True, help="Compact dataset directory") parser.add_argument("--report", help="Atomic JSON report path") parser.add_argument("--num-random", type=int, default=16) parser.add_argument( "--max-shards", type=int, default=0, help="Maximum shards to probe; 0 tests every shard", ) parser.add_argument("--batch-size", type=int, default=4) parser.add_argument("--num-workers", type=int, default=2) parser.add_argument( "--worker-timeout-s", type=float, default=180.0, help="Multi-worker DataLoader timeout; zero disables it", ) parser.add_argument("--max-batches", type=int, default=8) parser.add_argument("--max-cached-shards", type=int, default=2) parser.add_argument("--repeat-count", type=int, default=3) parser.add_argument("--seed", type=int, default=0) parser.add_argument( "--torch-threads", type=int, default=min(4, int(os.environ.get("SLURM_CPUS_PER_TASK", "4"))), ) parser.add_argument( "--no-strict", action="store_true", help="Disable loader invariant checks (not recommended for smoke tests)", ) args = parser.parse_args() positive = { "num_random": args.num_random, "batch_size": args.batch_size, "max_batches": args.max_batches, "max_cached_shards": args.max_cached_shards, "repeat_count": args.repeat_count, "torch_threads": args.torch_threads, } for name, value in positive.items(): if value < 1: parser.error(f"--{name.replace('_', '-')} must be >= 1") if args.num_workers < 0: parser.error("--num-workers must be >= 0") if args.worker_timeout_s < 0: parser.error("--worker-timeout-s must be >= 0") if args.max_shards < 0: parser.error("--max-shards must be >= 0") return args def _proc_status_mib(field: str) -> float | None: try: with Path("/proc/self/status").open("r", encoding="utf-8") as handle: for line in handle: if line.startswith(f"{field}:"): return float(line.split()[1]) / 1024.0 except OSError: return None return None def _proc_io_bytes() -> Dict[str, int]: result = {"read_bytes": 0, "write_bytes": 0} try: with Path("/proc/self/io").open("r", encoding="utf-8") as handle: for line in handle: key, raw_value = line.split(":", 1) if key in result: result[key] = int(raw_value.strip()) except OSError: pass return result def resource_snapshot() -> Dict[str, float | int | None]: usage = resource.getrusage(resource.RUSAGE_SELF) children = resource.getrusage(resource.RUSAGE_CHILDREN) io_bytes = _proc_io_bytes() # ru_maxrss is KiB on Linux, which is the target Slurm platform. return { "monotonic_s": time.perf_counter(), "rss_mib": _proc_status_mib("VmRSS"), "hwm_mib": _proc_status_mib("VmHWM"), "ru_maxrss_mib": float(usage.ru_maxrss) / 1024.0, "minor_faults": int(usage.ru_minflt), "major_faults": int(usage.ru_majflt), "self_user_cpu_s": float(usage.ru_utime), "self_system_cpu_s": float(usage.ru_stime), "children_ru_maxrss_mib": float(children.ru_maxrss) / 1024.0, "children_minor_faults": int(children.ru_minflt), "children_major_faults": int(children.ru_majflt), "children_user_cpu_s": float(children.ru_utime), "children_system_cpu_s": float(children.ru_stime), "read_bytes": io_bytes["read_bytes"], "write_bytes": io_bytes["write_bytes"], } def resource_delta( before: Mapping[str, float | int | None], after: Mapping[str, float | int | None], ) -> Dict[str, float | int | None]: def subtract(key: str) -> float | int | None: left = after.get(key) right = before.get(key) if left is None or right is None: return None return left - right return { "elapsed_s": subtract("monotonic_s"), "rss_mib_after": after.get("rss_mib"), "rss_mib_delta": subtract("rss_mib"), "hwm_mib_after": after.get("hwm_mib"), "ru_maxrss_mib_after": after.get("ru_maxrss_mib"), "minor_faults_delta": subtract("minor_faults"), "major_faults_delta": subtract("major_faults"), "self_user_cpu_s_delta": subtract("self_user_cpu_s"), "self_system_cpu_s_delta": subtract("self_system_cpu_s"), "children_ru_maxrss_mib_after": after.get("children_ru_maxrss_mib"), "children_minor_faults_delta": subtract("children_minor_faults"), "children_major_faults_delta": subtract("children_major_faults"), "children_user_cpu_s_delta": subtract("children_user_cpu_s"), "children_system_cpu_s_delta": subtract("children_system_cpu_s"), "read_mib_delta": ( None if subtract("read_bytes") is None else float(subtract("read_bytes")) / MIB ), "write_mib_delta": ( None if subtract("write_bytes") is None else float(subtract("write_bytes")) / MIB ), } def latency_summary(values: Sequence[float]) -> Dict[str, float | int]: if not values: return {"count": 0} ordered = sorted(values) p95_index = max(0, math.ceil(0.95 * len(ordered)) - 1) return { "count": len(ordered), "total_s": float(sum(ordered)), "mean_ms": float(statistics.fmean(ordered) * 1000.0), "median_ms": float(statistics.median(ordered) * 1000.0), "p95_ms": float(ordered[p95_index] * 1000.0), "min_ms": float(ordered[0] * 1000.0), "max_ms": float(ordered[-1] * 1000.0), } def ensure_finite(name: str, tensor: torch.Tensor) -> None: if not bool(torch.isfinite(tensor).all().item()): raise RuntimeError(f"{name} contains NaN or infinity") def check_graph(data: Data, dataset_index: int) -> Dict[str, Any]: required = ( "x", "edge_index", "edge_attr", "pos", "is_protein", "y_true", "y_pred", "y_grt", ) missing = [name for name in required if not hasattr(data, name)] if missing: raise RuntimeError(f"graph {dataset_index} is missing fields: {missing}") num_nodes = int(data.num_nodes) if data.x.shape != (num_nodes, 82) or data.x.dtype != torch.float32: raise RuntimeError( f"graph {dataset_index}: x={tuple(data.x.shape)} {data.x.dtype}" ) if data.edge_index.ndim != 2 or data.edge_index.shape[0] != 2: raise RuntimeError( f"graph {dataset_index}: edge_index={tuple(data.edge_index.shape)}" ) if data.edge_index.dtype != torch.int64: raise RuntimeError( f"graph {dataset_index}: edge_index dtype={data.edge_index.dtype}" ) num_edges = int(data.edge_index.shape[1]) if data.edge_attr.shape != (num_edges, 4): raise RuntimeError( f"graph {dataset_index}: edge_attr={tuple(data.edge_attr.shape)}" ) if data.edge_attr.dtype != torch.float32: raise RuntimeError( f"graph {dataset_index}: edge_attr dtype={data.edge_attr.dtype}" ) node_shapes = { "pos": (num_nodes, 3), "is_protein": (num_nodes, 1), "y_true": (num_nodes, 1), "y_pred": (num_nodes, 3), "y_grt": (num_nodes, 3), } for name, expected in node_shapes.items(): tensor = getattr(data, name) if tuple(tensor.shape) != expected or tensor.dtype != torch.float32: raise RuntimeError( f"graph {dataset_index}: {name}={tuple(tensor.shape)} {tensor.dtype}" ) ensure_finite(f"graph {dataset_index} {name}", tensor) ensure_finite(f"graph {dataset_index} x", data.x) ensure_finite(f"graph {dataset_index} edge_attr", data.edge_attr) if not torch.equal(data.pos, data.y_pred): raise RuntimeError(f"graph {dataset_index}: pos and y_pred differ") if num_edges: edge_min = int(data.edge_index.min().item()) edge_max = int(data.edge_index.max().item()) if edge_min < 0 or edge_max >= num_nodes: raise RuntimeError( f"graph {dataset_index}: edge endpoints [{edge_min},{edge_max}] " f"outside [0,{num_nodes})" ) protein_values = torch.unique(data.is_protein) if not bool(torch.all((protein_values == 0) | (protein_values == 1)).item()): raise RuntimeError(f"graph {dataset_index}: is_protein is not binary") return { "dataset_index": dataset_index, "num_nodes": num_nodes, "num_edges": num_edges, "num_protein_nodes": int(data.is_protein.sum().item()), "max_y_true": float(data.y_true.max().item()) if num_nodes else 0.0, } def check_batch(batch: Batch, expected_graphs: int) -> Dict[str, Any]: actual_graphs = int(batch.num_graphs) if actual_graphs != expected_graphs: raise RuntimeError( f"batch reports {actual_graphs} graphs, expected {expected_graphs}" ) num_nodes = int(batch.x.shape[0]) if batch.x.ndim != 2 or batch.x.shape[1] != 82: raise RuntimeError(f"batched x has shape {tuple(batch.x.shape)}") if batch.edge_attr.ndim != 2 or batch.edge_attr.shape[1] != 4: raise RuntimeError( f"batched edge_attr has shape {tuple(batch.edge_attr.shape)}" ) if batch.batch.numel() != num_nodes: raise RuntimeError("PyG batch assignment length does not match node count") if batch.ptr.numel() != actual_graphs + 1: raise RuntimeError("PyG batch ptr length is invalid") if not torch.equal(batch.pos, batch.y_pred): raise RuntimeError("batched pos and y_pred differ") ensure_finite("batch x", batch.x) ensure_finite("batch edge_attr", batch.edge_attr) ensure_finite("batch pos", batch.pos) return { "num_graphs": actual_graphs, "num_nodes": num_nodes, "num_edges": int(batch.edge_index.shape[1]), } def evenly_spaced(values: Sequence[int], limit: int) -> List[int]: if limit <= 0 or len(values) <= limit: return list(values) if limit == 1: return [values[0]] positions = { round(index * (len(values) - 1) / (limit - 1)) for index in range(limit) } return [values[position] for position in sorted(positions)] def global_indices_by_shard(dataset: CompactGraphDataset) -> List[List[int]]: result: List[List[int]] = [[] for _ in dataset.shards] graph_map = dataset.manifest.get("graph_map") if graph_map is not None: for global_index, entry in enumerate(graph_map): if isinstance(entry, Mapping): shard_index = entry.get("shard", entry.get("shard_index")) else: shard_index = entry[0] result[int(shard_index)].append(global_index) else: global_index = 0 for shard_index, count in enumerate(dataset._shard_counts): result[shard_index].extend(range(global_index, global_index + count)) global_index += count empty = [index for index, indices in enumerate(result) if not indices] if empty: raise RuntimeError(f"manifest contains empty shards: {empty}") return result def load_direct( dataset: CompactGraphDataset, indices: Sequence[int], ) -> Dict[str, Any]: before = resource_snapshot() latencies: List[float] = [] samples: List[Dict[str, Any]] = [] total_nodes = 0 total_edges = 0 for dataset_index in indices: started = time.perf_counter() graph = dataset[dataset_index] latency = time.perf_counter() - started metrics = check_graph(graph, dataset_index) metadata = dataset.metadata(dataset_index) metrics.update( { "shard_index": int(metadata["shard_index"]), "source_graph_index": int(metadata["source_graph_index"]), "latency_ms": latency * 1000.0, } ) if "system_id" in metadata: metrics["system_id"] = metadata["system_id"] samples.append(metrics) latencies.append(latency) total_nodes += metrics["num_nodes"] total_edges += metrics["num_edges"] del graph gc.collect() after = resource_snapshot() resources = resource_delta(before, after) elapsed = float(resources["elapsed_s"] or 0.0) return { "indices": list(indices), "latency": latency_summary(latencies), "total_nodes": total_nodes, "total_edges": total_edges, "graphs_per_s": len(indices) / elapsed if elapsed > 0 else None, "nodes_per_s": total_nodes / elapsed if elapsed > 0 else None, "samples": samples, "resources": resources, } def run_loader( dataset: CompactGraphDataset, indices: Sequence[int], *, batch_size: int, num_workers: int, max_batches: int, worker_timeout_s: float, ) -> Dict[str, Any]: before = resource_snapshot() subset = Subset(dataset, list(indices)) loader = DataLoader( subset, batch_size=batch_size, shuffle=False, num_workers=num_workers, persistent_workers=False, pin_memory=False, timeout=worker_timeout_s if num_workers else 0, ) latencies: List[float] = [] batch_metrics: List[Dict[str, Any]] = [] iterator = iter(loader) prior = time.perf_counter() try: for batch_number, batch in enumerate(iterator): now = time.perf_counter() latency = now - prior latencies.append(latency) metrics = check_batch(batch, min(batch_size, len(indices) - batch_number * batch_size)) metrics["batch_number"] = batch_number metrics["latency_ms"] = latency * 1000.0 batch_metrics.append(metrics) del batch if batch_number + 1 >= max_batches: break prior = time.perf_counter() finally: del iterator del loader del subset gc.collect() after = resource_snapshot() resources = resource_delta(before, after) elapsed = float(resources["elapsed_s"] or 0.0) total_graphs = sum(item["num_graphs"] for item in batch_metrics) total_nodes = sum(item["num_nodes"] for item in batch_metrics) total_edges = sum(item["num_edges"] for item in batch_metrics) return { "num_workers": num_workers, "worker_timeout_s": worker_timeout_s if num_workers else 0, "batch_size": batch_size, "input_indices": list(indices), "batches_tested": len(batch_metrics), "graphs_tested": total_graphs, "total_nodes": total_nodes, "total_edges": total_edges, "graphs_per_s": total_graphs / elapsed if elapsed > 0 else None, "nodes_per_s": total_nodes / elapsed if elapsed > 0 else None, "latency": latency_summary(latencies), "batches": batch_metrics, "resources": resources, } def write_report(path: Path, report: Mapping[str, Any]) -> None: path.parent.mkdir(parents=True, exist_ok=True) temporary = path.with_name(f".{path.name}.tmp.{os.getpid()}") with temporary.open("w", encoding="utf-8") as handle: json.dump(report, handle, indent=2, sort_keys=True, ensure_ascii=False) handle.write("\n") os.replace(temporary, path) def run(args: argparse.Namespace) -> Dict[str, Any]: compact = Path(args.compact).expanduser().resolve() default_report = compact / ( f"smoke_report_{os.environ.get('SLURM_JOB_ID', str(os.getpid()))}.json" ) report_path = ( Path(args.report).expanduser().resolve() if args.report else default_report ) report: Dict[str, Any] = { "status": "running", "compact": str(compact), "report": str(report_path), "started_utc_epoch_s": time.time(), "environment": { "hostname": socket.gethostname(), "pid": os.getpid(), "python": sys.version, "torch": torch.__version__, "torch_geometric": torch_geometric.__version__, "slurm_job_id": os.environ.get("SLURM_JOB_ID"), "slurm_array_job_id": os.environ.get("SLURM_ARRAY_JOB_ID"), "slurm_array_task_id": os.environ.get("SLURM_ARRAY_TASK_ID"), "slurm_cpus_per_task": os.environ.get("SLURM_CPUS_PER_TASK"), }, "config": vars(args), "resources_at_start": resource_snapshot(), } try: torch.set_num_threads(args.torch_threads) initialization_before = resource_snapshot() dataset = CompactGraphDataset( compact, max_cached_shards=args.max_cached_shards, strict=not args.no_strict, ) initialization_after = resource_snapshot() if len(dataset) < 1: raise RuntimeError("compact dataset is empty") report["dataset"] = { "num_graphs": len(dataset), "num_shards": len(dataset.shards), "n_systems": dataset.manifest.get("n_systems"), "method": dataset.manifest.get("method"), "size": dataset.manifest.get("size"), "initialization": resource_delta( initialization_before, initialization_after ), } shard_indices = global_indices_by_shard(dataset) selected_shards = evenly_spaced( list(range(len(shard_indices))), args.max_shards ) boundary_indices: List[int] = [] first_per_shard: List[int] = [] for shard_index in selected_shards: indices = shard_indices[shard_index] first_per_shard.append(indices[0]) boundary_indices.append(indices[0]) if indices[-1] != indices[0]: boundary_indices.append(indices[-1]) report["shard_probe"] = { "selected_shards": selected_shards, "boundary_indices": boundary_indices, "all_shards_selected": len(selected_shards) == len(dataset.shards), } report["direct_cross_shard"] = load_direct(dataset, boundary_indices) rng = random.Random(args.seed) random_count = min(args.num_random, len(dataset)) random_indices = rng.sample(range(len(dataset)), random_count) report["direct_random"] = load_direct(dataset, random_indices) repeat_index = random_indices[0] repeat_latencies: List[float] = [] repeat_before = resource_snapshot() for _ in range(args.repeat_count): started = time.perf_counter() graph = dataset[repeat_index] repeat_latencies.append(time.perf_counter() - started) check_graph(graph, repeat_index) del graph gc.collect() repeat_after = resource_snapshot() report["repeated_access"] = { "index": repeat_index, "latency": latency_summary(repeat_latencies), "resources": resource_delta(repeat_before, repeat_after), } cross_loader_indices = first_per_shard[ : args.batch_size * args.max_batches ] report["cross_shard_dataloader"] = run_loader( dataset, cross_loader_indices, batch_size=min(args.batch_size, len(cross_loader_indices)), num_workers=0, max_batches=args.max_batches, worker_timeout_s=args.worker_timeout_s, ) worker_indices = list(dict.fromkeys(random_indices + boundary_indices)) worker_indices = worker_indices[: args.batch_size * args.max_batches] # Forked workers should start with an empty mmap cache. Constructing a # fresh dataset here also catches errors in opening the same manifest # independently from more than one process. worker_dataset = CompactGraphDataset( compact, max_cached_shards=args.max_cached_shards, strict=not args.no_strict, ) report["multiworker_dataloader"] = run_loader( worker_dataset, worker_indices, batch_size=min(args.batch_size, len(worker_indices)), num_workers=args.num_workers, max_batches=args.max_batches, worker_timeout_s=args.worker_timeout_s, ) del worker_dataset report["resources_at_end"] = resource_snapshot() report["completed_utc_epoch_s"] = time.time() report["elapsed_s"] = ( report["completed_utc_epoch_s"] - report["started_utc_epoch_s"] ) report["status"] = "passed" except Exception as error: report["status"] = "failed" report["completed_utc_epoch_s"] = time.time() report["elapsed_s"] = ( report["completed_utc_epoch_s"] - report["started_utc_epoch_s"] ) report["error"] = f"{type(error).__name__}: {error}" report["traceback"] = traceback.format_exc() write_report(report_path, report) raise write_report(report_path, report) print( json.dumps( { "status": report["status"], "report": str(report_path), "num_graphs": report["dataset"]["num_graphs"], "num_shards": report["dataset"]["num_shards"], "elapsed_s": report["elapsed_s"], "rss_mib": report["resources_at_end"]["rss_mib"], "hwm_mib": report["resources_at_end"]["hwm_mib"], }, indent=2, sort_keys=True, ), flush=True, ) return report def main() -> int: args = parse_args() report = run(args) return 0 if report["status"] == "passed" else 1 if __name__ == "__main__": raise SystemExit(main())