| """Generator configuration.
|
|
|
| One frozen dataclass holds every knob: which levels of the experimental design to generate, how
|
| many replicates per cell, the physical model constants and the potential-field parameters.
|
| ``scripts/run_local_sweep.py`` turns each field into a command-line flag, and the resolved
|
| configuration is written next to the data as ``data/config.json`` so that any episode can be
|
| re-created bit for bit from ``(config, episode_id)``.
|
| """
|
| from __future__ import annotations
|
|
|
| import json
|
| from dataclasses import asdict, dataclass, field, fields
|
| from pathlib import Path
|
| from typing import List
|
|
|
| from . import design
|
|
|
| DATASET_VERSION = "2.0"
|
| ROUTERS = ("potential", "potential_split", "potential_static",
|
| "shortest_path", "ecmp", "adaptive_shortest_path")
|
|
|
|
|
| def _f(default, help_text):
|
| return field(default=default, metadata={"help": help_text})
|
|
|
|
|
| @dataclass(frozen=True)
|
| class SimConfig:
|
|
|
| replicates: int = _f(10, "episodes per design cell; episodes = replicates x cells")
|
| topologies: tuple = _f(design.TOPOLOGIES, "topology families to include")
|
| sizes: tuple = _f(design.SIZES, "nominal network sizes to include")
|
| traffic_profiles: tuple = _f(tuple(design.TRAFFIC_PROFILES), "traffic profiles to include")
|
| load_levels: tuple = _f(tuple(design.LOAD_LEVELS), "load levels to include")
|
| dynamics_levels: tuple = _f(tuple(design.DYNAMICS_LEVELS), "topology-dynamics levels to include")
|
| routers: tuple = _f(ROUTERS, "routers replayed on identical traffic and events")
|
|
|
|
|
| seed: int = _f(2026, "base seed; episode e draws from numpy default_rng([seed, e])")
|
| shard_episodes: int = _f(40, "episodes per Parquet shard (one shard = one resumable unit)")
|
| field_budget_bytes: int = _f(1_000_000, "potential field of the tracked flows is logged every k steps to stay within this budget")
|
|
|
|
|
| steps: int = _f(1000, "simulated steps per episode (1 step = 1 ms)")
|
| buffer_size: int = _f(256, "per-node drop-tail buffer in packets (< 32768)")
|
| mean_degree: int = _f(6, "target mean degree of the random-graph families")
|
| capacity_range: tuple = _f((8, 80), "link capacity in packets/step for random graphs (1 pkt/step ~ 12 Mbps)")
|
| latency_range: tuple = _f((1, 10), "link propagation delay in steps for random graphs")
|
| fat_tree_capacity: int = _f(40, "fat-tree fabric link capacity, packets/step (host links carry twice this)")
|
| flows_per_endpoint: int = _f(2, "flows per endpoint node; sources and sinks are distinct ordered pairs")
|
| tracked_flows: int = _f(8, "flows per episode with step-level telemetry and stored potential field")
|
|
|
|
|
| source_injection: float = _f(1.0, "unit injection at a flow's source")
|
| background_injection: float = _f(0.5, "total background injection spread over all non-sink nodes")
|
| congestion_gain: float = _f(2.0, "repulsive injection of a full buffer (alpha)")
|
|
|
| def __post_init__(self):
|
| for f in fields(self):
|
| if isinstance(f.default, tuple):
|
| object.__setattr__(self, f.name, tuple(getattr(self, f.name)))
|
| for name, allowed in (("topologies", design.TOPOLOGIES), ("sizes", design.SIZES),
|
| ("traffic_profiles", design.TRAFFIC_PROFILES), ("load_levels", design.LOAD_LEVELS),
|
| ("dynamics_levels", design.DYNAMICS_LEVELS), ("routers", ROUTERS)):
|
| chosen = getattr(self, name)
|
| if not chosen or set(chosen) - set(allowed):
|
| raise ValueError(f"{name} must be a non-empty subset of {tuple(allowed)}, got {chosen}")
|
| if self.replicates < 1:
|
| raise ValueError("replicates must be at least 1")
|
| if not 0 < self.buffer_size < 32768:
|
| raise ValueError("buffer_size must fit in an int16 telemetry column (< 32768)")
|
| if self.flows_per_endpoint < 1 or self.tracked_flows < 1:
|
| raise ValueError("flows_per_endpoint and tracked_flows must be positive")
|
| if self.mean_degree < 2:
|
| raise ValueError("mean_degree must be at least 2")
|
| for name in ("capacity_range", "latency_range"):
|
| lo, hi = getattr(self, name)
|
| if not 0 < lo <= hi:
|
| raise ValueError(f"{name} must satisfy 0 < low <= high, got {(lo, hi)}")
|
| if self.background_injection <= 0:
|
| raise ValueError("background_injection must be positive: it guarantees loop-free descent")
|
|
|
| @property
|
| def cells(self) -> List[design.Cell]:
|
| return design.cells(self.topologies, self.sizes, self.traffic_profiles, self.load_levels, self.dynamics_levels)
|
|
|
| @property
|
| def episodes(self) -> int:
|
| return self.replicates * len(self.cells)
|
|
|
| def to_json(self) -> str:
|
| return json.dumps(asdict(self), indent=2)
|
|
|
| def save(self, path: Path) -> None:
|
| path.write_text(self.to_json(), encoding="utf-8")
|
|
|
| @classmethod
|
| def load(cls, path: Path) -> "SimConfig":
|
| return cls(**json.loads(path.read_text(encoding="utf-8")))
|
|
|
| def __eq__(self, other) -> bool:
|
| return isinstance(other, SimConfig) and self.to_json() == other.to_json()
|
|
|
