Packet-level accuracy without the usual pain. Days is a process-based discrete-event network simulator designed to stay simple while scaling to datacenter-sized topologies.
Speedup over DONS (Days, FatTree-32, 4096 flows)
Hosts and switches simulated (FatTree-256)
Memory at FatTree-256 (Days)
LOC (Days, not incl. executor)
tokens (Days, incl. unit tests)
Model each network element as an isolated coroutine, exchanging packets via message passing—simpler to reason about, easier to extend.
Built with Rust’s async/await “zero-cost futures” and a performance-tuned executor to drive large numbers of concurrent network processes.
Advance simulation time only when needed while preserving packet-level behavior across switches, queues, and transport protocols.
FatTree and Torus topologies, multiple scheduling disciplines, packet drops, routing, TCP variants, and collective communication primitives.
Configure FatTree/Torus topologies and traffic patterns (including TCP) with concise TOML—zero coding required.
Swap schedulers (e.g., FCFS, DRR, WFQ, Virtual Clock) and drop policies (e.g., tail drop, RED) to match your study.
Execute the simulator as a standard Rust program and let the process-based runtime drive timeouts and packet delivery.
Stress test larger flow counts and topologies; benchmark against classic DES frameworks and modern performance estimators.
seed = 1000 [topology] category = "FatTree" [topology.fat_tree] k = 32 [[flow_set]] flow_type = "TCP" flow_count = 4096 [flow_set.traffic.tcp] cc_algorithm = "CUBIC"
Days aims to pare simulation down to essential facilities: processes that wait for packets or timeouts, and a runtime that advances time only when progress is blocked.
The result is a foundation that stays easy to reason about, but benchmarks as “seriously performant” against classic simulators and modern learning-based estimators.
“FatTree-32 with 4,096 flows: Days completes in 6.5s, versus 170m30s for DONS.”
“Days is able to accommodate runs from FatTree-4 topology all the way up to FatTree-256 (with 4,194,304 hosts and 81,920 switches).”
“At FatTree-128 (524,288 hosts, 20,480 switches), Days uses around 8.43 GB of memory—practical on modern machines.”
A Python prototype that explores process-based simulation with generators — excellent for rapid prototyping.
(yield)A Rust implementation with stackless coroutines and a custom multi-threaded executor tuned for packet-level DES at scale.
Days is a process-based, packet-level discrete-event network simulator built in Rust. It models network elements as concurrent coroutines that exchange packets via message passing, and advances simulation time only when necessary.
Process-based simulation represents each network element as a coroutine with private state and explicit inputs/outputs. This actor-like structure is easier to implement correctly and naturally exposes concurrency without a single global event-queue bottleneck.
Days uses Rust async/await and a performance-optimized executor to run many network-element coroutines efficiently. In the paper’s evaluations, it scales to very large FatTree topologies while keeping memory usage practical on consumer hardware.
Days includes essential building blocks such as FatTree and Torus topologies, multiple scheduling disciplines, packet drop policies, routing, TCP variants, and collective communication operations like broadcast and all-reduce.
A simpler foundation for packet-level discrete-event network simulation, powered by modern coroutines and executors.
Design and benchmarks in the paper.