| |
| |
| |
| |
| """Convert the paired SyzPilot corpus into deterministic Parquet shards.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| from concurrent.futures import ThreadPoolExecutor |
| import hashlib |
| import json |
| import math |
| import os |
| from pathlib import Path |
| import re |
| import sys |
| import time |
| from typing import Any |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
|
|
| SCHEMA_VERSION = 1 |
| ID_PATTERN = re.compile(r"^[0-9a-f]{40}$") |
| SCHEMA = pa.schema( |
| [ |
| pa.field("id", pa.string(), nullable=False), |
| pa.field("program", pa.string(), nullable=False), |
| pa.field("coverage", pa.string(), nullable=False), |
| pa.field("program_size_bytes", pa.int32(), nullable=False), |
| pa.field("coverage_size_bytes", pa.int32(), nullable=False), |
| pa.field("coverage_count", pa.int32(), nullable=False), |
| ] |
| ) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description=( |
| "Convert dataset_224w/programs and dataset_224w/coverages into " |
| "paired, deterministically ordered Parquet shards." |
| ) |
| ) |
| parser.add_argument( |
| "--source", |
| type=Path, |
| default=Path.home() / "datasets" / "dataset_224w", |
| help="Directory containing programs/ and coverages/.", |
| ) |
| parser.add_argument( |
| "--output", |
| type=Path, |
| default=Path.cwd(), |
| help="Dataset repository directory.", |
| ) |
| parser.add_argument( |
| "--rows-per-shard", |
| type=int, |
| default=5_000, |
| help="Maximum rows in each Parquet shard.", |
| ) |
| parser.add_argument( |
| "--row-group-rows", |
| type=int, |
| default=512, |
| help="Rows in each Parquet row group.", |
| ) |
| parser.add_argument( |
| "--workers", |
| type=int, |
| default=32, |
| help="Threads used to read pairs of source files.", |
| ) |
| parser.add_argument( |
| "--compression-level", |
| type=int, |
| default=3, |
| help="Zstandard compression level.", |
| ) |
| parser.add_argument( |
| "--limit", |
| type=int, |
| help="Convert only the first N sorted IDs (for validation runs only).", |
| ) |
| args = parser.parse_args() |
| if args.rows_per_shard <= 0: |
| parser.error("--rows-per-shard must be positive") |
| if args.row_group_rows <= 0: |
| parser.error("--row-group-rows must be positive") |
| if args.workers <= 0: |
| parser.error("--workers must be positive") |
| if args.limit is not None and args.limit <= 0: |
| parser.error("--limit must be positive") |
| return args |
|
|
|
|
| def file_sha256(path: Path, chunk_size: int = 8 * 1024 * 1024) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(chunk_size), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def write_json_atomic(path: Path, value: Any) -> None: |
| temporary = path.with_suffix(path.suffix + ".tmp") |
| with temporary.open("w", encoding="utf-8") as handle: |
| json.dump(value, handle, indent=2, sort_keys=True) |
| handle.write("\n") |
| os.replace(temporary, path) |
|
|
|
|
| def list_source_ids(directory: Path) -> list[str]: |
| if not directory.is_dir(): |
| raise FileNotFoundError(f"source directory does not exist: {directory}") |
|
|
| names: list[str] = [] |
| invalid: list[str] = [] |
| with os.scandir(directory) as entries: |
| for entry in entries: |
| if not entry.is_file(follow_symlinks=False): |
| continue |
| if not ID_PATTERN.fullmatch(entry.name): |
| invalid.append(entry.name) |
| if len(invalid) >= 10: |
| break |
| names.append(entry.name) |
|
|
| if invalid: |
| joined = ", ".join(repr(name) for name in invalid) |
| raise ValueError(f"unexpected source filenames in {directory}: {joined}") |
| return names |
|
|
|
|
| def count_lines(data: bytes) -> int: |
| if not data: |
| return 0 |
| return data.count(b"\n") + (0 if data.endswith(b"\n") else 1) |
|
|
|
|
| def read_pair( |
| item: tuple[str, Path, Path], |
| ) -> tuple[str, str, str, int, int, int]: |
| sample_id, program_dir, coverage_dir = item |
| program_bytes = (program_dir / sample_id).read_bytes() |
| coverage_bytes = (coverage_dir / sample_id).read_bytes() |
| try: |
| program = program_bytes.decode("utf-8") |
| coverage = coverage_bytes.decode("ascii") |
| except UnicodeDecodeError as error: |
| raise ValueError(f"text decoding failed for sample {sample_id}") from error |
| return ( |
| sample_id, |
| program, |
| coverage, |
| len(program_bytes), |
| len(coverage_bytes), |
| count_lines(coverage_bytes), |
| ) |
|
|
|
|
| def build_table(rows: list[tuple[str, str, str, int, int, int]]) -> pa.Table: |
| columns = list(zip(*rows, strict=True)) |
| return pa.Table.from_arrays( |
| [pa.array(column, type=field.type) for column, field in zip(columns, SCHEMA)], |
| schema=SCHEMA, |
| ) |
|
|
|
|
| def validate_source(program_dir: Path, coverage_dir: Path) -> list[str]: |
| started = time.monotonic() |
| print("Listing source IDs...", flush=True) |
| program_ids = list_source_ids(program_dir) |
| coverage_ids = set(list_source_ids(coverage_dir)) |
| program_set = set(program_ids) |
|
|
| missing_coverages = sorted(program_set - coverage_ids)[:10] |
| orphan_coverages = sorted(coverage_ids - program_set)[:10] |
| if missing_coverages or orphan_coverages: |
| raise ValueError( |
| "program/coverage pairing mismatch; " |
| f"missing coverage examples={missing_coverages}, " |
| f"orphan coverage examples={orphan_coverages}" |
| ) |
|
|
| del coverage_ids |
| del program_set |
| program_ids.sort() |
| elapsed = time.monotonic() - started |
| print(f"Validated {len(program_ids):,} paired IDs in {elapsed:.1f}s", flush=True) |
| return program_ids |
|
|
|
|
| def load_state(path: Path, expected: dict[str, Any]) -> dict[str, Any]: |
| if not path.exists(): |
| return {**expected, "completed_shards": {}} |
| with path.open("r", encoding="utf-8") as handle: |
| state = json.load(handle) |
| for key, value in expected.items(): |
| if state.get(key) != value: |
| raise ValueError( |
| f"existing build state has {key}={state.get(key)!r}; " |
| f"expected {value!r}" |
| ) |
| if not isinstance(state.get("completed_shards"), dict): |
| raise ValueError("existing build state has no completed_shards mapping") |
| return state |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| source = args.source.resolve() |
| output = args.output.resolve() |
| program_dir = source / "programs" |
| coverage_dir = source / "coverages" |
| data_dir = output / "data" |
| data_dir.mkdir(parents=True, exist_ok=True) |
|
|
| sample_ids = validate_source(program_dir, coverage_dir) |
| source_total = len(sample_ids) |
| if args.limit is not None: |
| sample_ids = sample_ids[: args.limit] |
| total_rows = len(sample_ids) |
| total_shards = math.ceil(total_rows / args.rows_per_shard) |
|
|
| state_path = output / "_build_state.json" |
| state_expected = { |
| "schema_version": SCHEMA_VERSION, |
| "source": str(source), |
| "source_total_pairs": source_total, |
| "selected_rows": total_rows, |
| "rows_per_shard": args.rows_per_shard, |
| "row_group_rows": args.row_group_rows, |
| "compression": "zstd", |
| "compression_level": args.compression_level, |
| } |
| state = load_state(state_path, state_expected) |
| completed: dict[str, dict[str, Any]] = state["completed_shards"] |
| build_started = time.monotonic() |
|
|
| with ThreadPoolExecutor(max_workers=args.workers) as executor: |
| for shard_index in range(total_shards): |
| start = shard_index * args.rows_per_shard |
| stop = min(start + args.rows_per_shard, total_rows) |
| shard_ids = sample_ids[start:stop] |
| shard_name = f"train-{shard_index:05d}-of-{total_shards:05d}.parquet" |
| shard_path = data_dir / shard_name |
| relative_path = f"data/{shard_name}" |
|
|
| old_entry = completed.get(relative_path) |
| if old_entry and shard_path.is_file(): |
| current_size = shard_path.stat().st_size |
| if current_size == old_entry.get("size_bytes"): |
| current_hash = file_sha256(shard_path) |
| if current_hash == old_entry.get("sha256"): |
| print( |
| f"[{shard_index + 1}/{total_shards}] Reusing {shard_name}", |
| flush=True, |
| ) |
| continue |
|
|
| shard_started = time.monotonic() |
| tasks = ((sample_id, program_dir, coverage_dir) for sample_id in shard_ids) |
| rows = list(executor.map(read_pair, tasks, chunksize=16)) |
| table = build_table(rows) |
|
|
| temporary = shard_path.with_suffix(".parquet.tmp") |
| pq.write_table( |
| table, |
| temporary, |
| compression="zstd", |
| compression_level=args.compression_level, |
| use_dictionary=False, |
| write_statistics=[ |
| "id", |
| "program_size_bytes", |
| "coverage_size_bytes", |
| "coverage_count", |
| ], |
| row_group_size=args.row_group_rows, |
| data_page_size=1024 * 1024, |
| ) |
| os.replace(temporary, shard_path) |
|
|
| entry = { |
| "first_id": shard_ids[0], |
| "last_id": shard_ids[-1], |
| "num_rows": len(rows), |
| "program_bytes": sum(row[3] for row in rows), |
| "coverage_bytes": sum(row[4] for row in rows), |
| "coverage_addresses": sum(row[5] for row in rows), |
| "size_bytes": shard_path.stat().st_size, |
| "sha256": file_sha256(shard_path), |
| } |
| completed[relative_path] = entry |
| write_json_atomic(state_path, state) |
|
|
| elapsed = time.monotonic() - shard_started |
| ratio = entry["size_bytes"] / max( |
| entry["program_bytes"] + entry["coverage_bytes"], 1 |
| ) |
| print( |
| f"[{shard_index + 1}/{total_shards}] Wrote {shard_name}: " |
| f"{len(rows):,} rows, {entry['size_bytes'] / 2**20:.1f} MiB, " |
| f"ratio={ratio:.3f}, {elapsed:.1f}s", |
| flush=True, |
| ) |
|
|
| expected_paths = { |
| f"data/train-{index:05d}-of-{total_shards:05d}.parquet" |
| for index in range(total_shards) |
| } |
| if set(completed) != expected_paths: |
| missing = sorted(expected_paths - set(completed))[:10] |
| extra = sorted(set(completed) - expected_paths)[:10] |
| raise RuntimeError(f"build state mismatch: missing={missing}, extra={extra}") |
|
|
| ordered_shards = [ |
| {"path": path, **completed[path]} for path in sorted(expected_paths) |
| ] |
| manifest = { |
| "dataset": "SyzPilot-dataset", |
| "format": "parquet", |
| "schema_version": SCHEMA_VERSION, |
| "schema": [ |
| {"name": field.name, "type": str(field.type), "nullable": field.nullable} |
| for field in SCHEMA |
| ], |
| "ordering": "Rows are sorted lexicographically by id across shards.", |
| "num_rows": sum(shard["num_rows"] for shard in ordered_shards), |
| "num_shards": len(ordered_shards), |
| "program_bytes": sum(shard["program_bytes"] for shard in ordered_shards), |
| "coverage_bytes": sum(shard["coverage_bytes"] for shard in ordered_shards), |
| "coverage_addresses": sum( |
| shard["coverage_addresses"] for shard in ordered_shards |
| ), |
| "parquet_bytes": sum(shard["size_bytes"] for shard in ordered_shards), |
| "shards": ordered_shards, |
| } |
| write_json_atomic(output / "manifest.json", manifest) |
|
|
| elapsed = time.monotonic() - build_started |
| print( |
| f"Completed {manifest['num_rows']:,} rows in {manifest['num_shards']} " |
| f"shards ({manifest['parquet_bytes'] / 2**30:.2f} GiB) in " |
| f"{elapsed / 60:.1f} minutes.", |
| flush=True, |
| ) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| raise SystemExit(main()) |
| except KeyboardInterrupt: |
| print("Interrupted; completed shards can be reused on the next run.", file=sys.stderr) |
| raise SystemExit(130) |
|
|
