Always wanted to build an imaginary hyperscale network? Now, you can

MIT's Flexplane: design on the fly without breaking the network


An MIT student has created a scheme to shadow packets as they pass through networks, to help take the risk out of experimenting with changes to network configurations.

The disaggregation of the control plane from the data plane is old news, but according to MIT graduate student Amy Ousterhout and her collaborators, there's good reason to think another level of disaggregation might be useful.

Flexplane takes the software routing – the control plane, in SDN-speak – and splits it in two: there's the “real network”, where packets move, and there's also an emulated network that's a software model.

“The emulator maintains a model of the network topology in software, and users implement their schemes in the emulated routers. Before each packet is sent on the real network, a corresponding emulated packet traverses the emulated network and experiences behaviour specified by the resource management scheme. Once this is complete, the real packet traverses the network without delay”, the paper states.

Flexplane schematic

Flexplain explained, from Amy Ousterhout's paper

Why do this? As Ousterhout explains, it means users can experiment with changes to the control plane and get the emulator to tell them what's going to happen – and only push the new configuration to production if it's not going to break things.

The paper says Flexplane can still keep up with a line rate throughput up to 760 Gbps on a 10-core machine, which is a lot faster than a full software implementation of a router, and fast enough to operate a lot of production environments (even though it's pitched at academic and experimental users).

It gets that performance because unlike a software router, Flexplane's emulator doesn't try and deal with whole packets. Instead, the header fields of an ingress packet is all that's handed to the emulator.

“The way it works is, when an endpoint wants to send a [data] packet, it first sends a request to this centralised emulator,” Ousterhout explains in this MIT release.

“The emulator emulates in software the scheme that you want to experiment with in your network. Then it tells the endpoint when to send the packet so that it will arrive at its destination as though it had traversed a network running the programmed scheme.”

As well as allowing a network admin to set up and test changes before they push them to production, there's another, more academic, application of the system: protocol testing.

Once a protocol works – MIT's media release uses the ancient Transmission Control Protocol as its example – it can be extremely difficult to replace, partly because who's going to set up a hyperscale data centre as the test case for a new protocol?

Reconfigurable hardware (such as using FPGAs) is laborious, and software routers can't reach high enough throughput to provide a realistic simulation.

MIT quotes a Yale associate professor, Minlan Yu, in explaining why the emulation is a useful approach: “many problems happen at the interactions between applications and the network stack, which are hard to understand by simply simulating the traffic.”

Ousterhout, a graduate student in electrical engineering and computer science, worked with another grad Jonathan Perry (supported by a Facebook Fellowship), advisor, Hari Balakrishnan, the Fujitsu Professor in Electrical Engineering and Computer Science; and Facebook network engineer Petr Lapukhov.

Flexplane will get its first public outing later this month at the Usenix Symposium on Networked Systems Design and Implementation. ®

Sponsored: Becoming a Pragmatic Security Leader

Biting the hand that feeds IT © 1998–2019