Title: Nüwa: A Generative Control Plane for AI Network Simulation
Authors: Wenkai Li, Ran Shu, Peng Zhang, Yiren Zhao, Danfeng Shan, Yongqiang Xiong
Introduction:
Modern AI training clusters are growing to tens or hundreds of thousands of GPUs, making it increasingly important to evaluate network designs, routing strategies, and training system configurations through high-fidelity simulation. However, existing packet-level network simulators face serious scalability problems because their control plane must compute routes and construct forwarding tables before simulation begins. These initialization operations can require hundreds of GB of memory and hours of computation at large scales, limiting the ability to perform large-scale design exploration and repeated experiments. Existing approaches either rely on general routing algorithms that provide flexibility but suffer from high overhead, or use handwritten topology-specific routing logic that is fast but difficult to extend, fragile under failures, and unable to support diverse routing policies. Nüwa studies whether a network simulator control plane can achieve both scalability and generality for large-scale AI network simulation.
Key idea and contribution:
The key idea of Nüwa is to treat routing as a compilation problem instead of explicitly computing and storing every source-destination forwarding path. Given a declarative topology description and routing policies, Nüwa compiles them into compact forwarding artifacts, including shortest-path routing rules, policy-based non-minimal routing rules, and failure-handling information. This avoids expensive global route computation and large forwarding tables while still supporting efficient packet forwarding.
Nüwa takes advantage of the hierarchical and symmetric structures commonly found in AI network fabrics. It introduces an interconnection template library and a compiler architecture (Figure 3). The topology specification is built from reusable templates such as ClosLayer and BCubeLayer, and the compiler generates structured topology instances, shortest routing rule tables, non-minimal routing policy tables, and port mappings. Instead of storing individual routes, Nüwa derives forwarding decisions from structural properties of the topology, allowing the same mechanism to support multiple structured AI fabrics.
For routing policies and failures, Nüwa extends the compilation framework. Policy-based non-minimal routing is represented as combinations of waypoints and shortest-path segments, enabling support for techniques such as detours and load balancing. Failures are treated as exceptions rather than requiring complete route recomputation. Nüwa uses sparse exception tables organized through structured address prefixes, allowing only affected regions to update their forwarding behavior.
Evaluation
The authors implemented Nüwa on top of ns-3 with approximately 7K lines of C++ code and evaluated it using Fat-tree, Dragonfly, and Torus topologies, comparing it with vanilla ns-3 and ns-3-dc. The evaluation examined routing fidelity, memory usage, initialization time, and the overhead introduced by failure handling and non-minimal routing. Nüwa achieved identical packet traces compared with reference routing implementations for shortest-path and policy-based routing, demonstrating that the generated forwarding rules preserve routing correctness. It also significantly reduced memory consumption; for example, at FT32 it used 15.0 GB compared with 31.9 GB for ns-3-dc, and it scaled to FT96 with more than 220K GPUs.
For initialization performance, Nüwa completed FT56 initialization in about 20 seconds, while ns-3-dc required more than 13,000 seconds, and it could initialize a 220K-GPU Fat-tree in under 90 seconds. The total simulation time on FT64 was only 20% of ns-3-dc.
This result is significant because it enables researchers and engineers to explore much larger AI cluster designs and routing strategies through simulation without being limited by control-plane memory and initialization overhead. The improvement makes large-scale simulation practical for iterative AI infrastructure optimization.
Q&A
Q: Since this is the control plane, and forwarding performance is not the main concern, could you look into alternative architectures that are more distributed—for example, scaling up to tens of thousands of containers, with each container emulating some control-plane component of a switch?
A: Actually, we are not considering such scenarios. Our focus is on simulating a single large network instance, such as a large-scale training job or multiple serving instances. In these cases, even generating the routing tables for the experiment can introduce significant overhead. What we aim to address is this scalability issue, rather than the performance of the control plane itself.
Q: So, for the data plane, after you have generated all the routing tables, do you still perform the same packet-level simulation?
A: Yes.
Q: Would it be possible to replace the data-plane simulation with a flow-based approach or another faster simulation method?
A: Flow-based approaches generally have simpler routing requirements compared with packet-level simulations. Therefore, some modifications would be needed to support them. However, our design is general enough and compatible with such extensions, which we plan to explore as future work.
Personal thoughts
The main takeaway from this paper is that the authors identify an overlooked bottleneck in network simulation: the control plane rather than the packet-processing data plane. Previous optimization efforts mainly focused on accelerating packet events, but Nüwa shows that route generation and forwarding-state construction can become the dominant cost when simulations involve extremely large AI clusters. I like that the authors do not simply optimize existing routing-table generation algorithms; instead, they rethink the abstraction and exploit the structural properties of AI networks.
Another strength is the balance between performance and generality. Handwritten routing logic can be extremely fast, but it often sacrifices flexibility and failure handling. Nüwa provides a more systematic approach by expressing topology construction and routing behavior through reusable templates. However, an open question is how far this approach can generalize beyond highly structured AI fabrics. The authors explicitly exclude irregular networks such as Jellyfish and dynamically reconfigurable optical networks, so future work could explore whether similar compilation techniques can support less structured environments. Additionally, as AI clusters increasingly adopt adaptive and dynamic network mechanisms, extending Nüwa to handle rapidly changing topologies and runtime optimization policies could be an interesting research direction.