Software-Defined Networking (SDN) has revolutionized network management by decoupling control logic from data forwarding. However, limited by the traditional controller paradigm, existing SDN controllers remain inherently static, relying on predefined rules. This rigidity makes them ill-equipped to handle unforeseen traffic patterns or emerging threats, often defaulting to generic actions that fail to address nuanced scenarios.

In data center networks today, switches sitting inside the network perform packet forwarding and hosts sitting at the outer edge of the network perform congestion control. In this work, we argue that this convention is completely backwards and show that data center networks can be significantly simplified and improved by performing congestion control inside the switch, where the congestion actually occurs, and making forwarding decisions at the edge, where there is more context of the traffic.To support our thesis, we present a new network architecture named Riley that consists of simplified switches with no control plane and end hosts that are knowledgeable of the network topology, which a design that essentially flips data center networks inside-out. Riley provides the following two benefits from the traditional network architecture: First, Riley forwarding protocol enables fast routing without any switch forwarding state and switch local control plane, which both are implemented as highly complex and resource intensive software running on costly hardware. Second, switches in Riley collect detailed link-level statistics entirely in the data plane, such as latency and congestion, allowing the switches to make local congestion control decisions and end-hosts to use the statistics to make more informed traffic engineering decisions. By doing so, we show that Riley greatly reduces switch resource consumption and improves congestion control performance, while incurring nearly no traffic performance reductions or increases in end-host resource usage.

There is a growing interest in serverless compute, a cloud computing model that automates infrastructure resource- allocation and management while billing customers only for the resources they use. Workloads like stream processing benefit from high elasticity and fine-grain pricing of these serverless frameworks. However, so far, limited concurrency and high latency of server CPUs prohibit many interactive workloads (e.g., web servers and database clients) from taking advantage of serverless compute to achieve high performance.In this paper, we argue that server CPUs are ill-suited to run serverless workloads (i.e., lambdas) and present λ-NIC, an open- source framework, that runs interactive workloads directly on a SmartNIC; more specifically an ASIC-based NIC that consists of a dense grid of Network Processing Unit (NPU) cores. λ- NIC leverages SmartNIC's proximity to the network and a vast array of NPU cores to simultaneously run thousands of lambdas on a single NIC with strict tail-latency guarantees. To ease the development and deployment of lambdas, λ-NIC exposes an event-based programming abstraction, Match+Lambda, and a machine model that allows developers to compose and execute lambdas on SmartNICs easily. Our evaluation shows that λ- NIC achieves up to 880x and 736x improvements in workloads' response latency and throughput, respectively, while significantly reducing host CPU and memory usage.

Conventional distributed data storage services, like databases and file systems, rely on replication for fault tolerance; as a consequence, the performance of these services depends heavily on the performance of the underlying replication system in use. Existing replication systems, built using a replication protocol (e.g., CURP), are implemented as user-level processes capable of performing replication with relatively low latencies (~10+ μs). However, such user-level processes are susceptible to performance degradation at scale, due to software overheads (e.g., operating system and networking stack), and contention for server resources (e.g., CPU, disk, and memory) between multiple processes; thus, leading to higher latencies with longer tails.

The conventional software running on network devices, such as switches and routers, is typically vendor-supplied, proprietary and closed-source; as a result, it tends to contain extraneous features that a single operator will not most likely fully utilize. Furthermore, cloud-scale data center networks often times have software and operational requirements that may not be well addressed by the switch vendors.

Recent efforts to simplify network data plane programming focus on providing simple, high-level domain-specific languages (DSLs). In the case of software switches, data plane programs are written in these DSLs and then compiled to run on CPU-based architecture. However, the simplicity of these DSLs, along with the lack of low-level interfaces exposed by the software switch, restrict compilers from generating optimal data plane programs for CPU-based architecture.

With the increase in adoption of SDN, programmable switches are becoming an attractive mechanism for enabling network operators to configure protocols without replacing networking hardware. This paper argues that the functionality of programmable switches can be extended beyond network operations to the application layer, in order to achieve significant end-to-end application performance improvements. To illustrate the potential of this new concept, we develop AppSwitch, a packet switch that also performs load balancing for key-value storage systems. Unlike existing key-value load balancers, which require each request to send an extra message to a proxy server, AppSwitch requires only a single message from the key-value client to the server. This results in a 2x reduction in end-to-end average latency and 2x throughput improvement. We implemented AppSwitch on PISCES, a P4 programmable version of Open vSwitch. Finally, we demonstrate that AppSwitch can be deployed transparently, without any changes to the key-value clients and servers.

Hypervisors use software switches to steer packets to and from virtual machines (VMs). These switches frequently need upgrading and customization—to support new protocol headers or encapsulations for tunneling and overlays, to improve measurement and debugging features, and even to add middlebox-like functions. Software switches are typically based on a large body of code, including kernel code, and changing the switch is a formidable undertaking requiring domain mastery of network protocol design and developing, testing, and maintaining a large, complex codebase. Changing how a software switch forwards packets should not require intimate knowledge of its implementation. Instead, it should be possible to specify how packets are processed and forwarded in a high-level domain-specific language (DSL) such as P4, and compiled to run on a software switch. We present PISCES, a software switch derived from Open vSwitch (OVS), a hard-wired hypervisor switch, whose behavior is customized using P4. PISCES is not hard-wired to specific protocols; this independence makes it easy to add new features. We also show how the compiler can analyze the high-level specification to optimize forwarding performance. Our evaluation shows that PISCES performs comparably to OVS and that PISCES programs are about 40 times shorter than equivalent changes to OVS source code.

Interacting with biological systems via experiments is important for academia, industry, and education, but access barriers exist due to training, costs, safety, logistics, and spatial separation. High-throughput equipment combined with web streaming could enable interactive biology experiments online, but no such platform currently exists. We present a cloud experimentation architecture (paralleling cloud computation), which is optimized for a class of domain-specific equipments (biotic processing units - BPU) to share and execute many experiments in parallel remotely and interactively at all time. We implemented an instance of this architecture that enables chemotactic experiments with a slime mold Physarum Polycephelum. A user study in the blended teaching and research setting of a graduate-level biophysics class demonstrated that this platform lowers the access barrier for non-biologists, enables discovery, and facilitates learning analytics. This architecture is flexible for integration with various biological specimens and equipments to facilitate scalable interactive online education, collaborations, research, and citizen science.