Network system operation is typically divided into control and data planes – while the data plane is responsible for processing individual messages or packets, the control plane computes the configuration of devices and optimizes system-wide performance. Unfortunately, the control plane of each network system or protocol layer typically operates independently (e.g., CDNs selecting servers without coordinating with ISPs), resulting in poor interactions between control planes across systems. We can categorize existing systems into one of four general control plane coordination mechanisms that overcome these problems, based on how much information can be shared between control planes. If no information can be shared, control planes simply react to data plane changes as a rudimentary formof coordination (e.g., CDN server selection + ISP traffic engineering). If all information can be shared, transparency in decisionmaking can remove most poor interactions (e.g., Coflow datacenter flow scheduling). In many scenarios, however, only some information can be shared (e.g., between control planes running in different companies). Coordination in these scenarios is more specialized; control planes with separate data plane resources can use priority ranking (i.e., providing a list of preferences for resources without needing to show how these preferences were decided; e.g., BGP routing between ISPs), and control planes with shared data plane resources can use hierarchical partitioning (i.e., making coarsegrained decisions globally, and fine-grained decisions locally; e.g., internet-wide BGP + OSPF routing). While systems utilizing control plane coordination exist today, they have been designed ad hoc. We propose a set of recipes that show when it's appropriate to use different coordination mechanisms, based on key properties (information sharing and shared resources) in varied scenarios (layering, administrative separation, and internet-scale systems).

We use these recipes to guide system design in a variety of contexts, as a case study in control plane coordination. First, many systems use layer separation for modularity, but in doing so trade performance for generality. As layered systems have no information sharing constraints, we argue that transparency (i.e., cross-layer optimization; allowing layers to run specialized code to better use other layers) is the correct technique for regaining performance. We explore this with our emulator Etalon [116], in the context of reconfigurable datacenters. Second, some systems are administratively separate(i.e., are split across dierent companies), limiting information sharing for business reasons. These systems may overcome adverse interactions using priority ranking. We explore this with VDX [114, 115], in the context of content brokering. Finally, systems needing internet scalability are increasingly combining a slow centralized control plane with a fast distributed control plane. Complete information sharing (and thus, transparency) would appear possible, but timescale separation makes this fundamentally impractical. Instead, hierarchical partitioning can overcome the challenges present in this scenario. We explore this with VDN [117], in the context of live video delivery. Through this case study we find that these coordination mechanism not only solve a variety of problems, but can be efficiently implemented.

Thesis Committee:
Srinivasan Seshan (Chair)
Vyas Sekar
Peter Steenkiste
Bruce Mggs (Duke University/Akamai)

Frank Pfenning, Head, Computer Science Department
Andrew W. Moore, Dean, School of Computer Science

129 pages

Return to: SCS Technical Report Collection
School of Computer Science

This page maintained by reports@cs.cmu.edu