Modern cloud applications are refactored into microservices, which are deployed as containers across multiple servers. An end-user request often triggers several remote procedure calls (RPCs) between these microservices. RPC latency anomalies caused by packet-processing delays (bottlenecks) in the host network stack are common. Bottlenecks at a few network components can compound across services, causing SLA violations for many requests.

In the evolving computing landscape, extending from centralized clouds to multi-cloud and edge, the need for adaptable observability is becoming increasingly critical. Traditional static monitoring approaches grapple with inefficient data transfer, limited scalability, heterogeneous environments, and rigid metric processing pipelines. This paper introduces a novel metric processing system, Programmable Metric Flows (PMF), which is rooted in the principle of dynamism. PMF is a first- of-its-kind, light-weight, SQL-based metric processor. It empowers optimization-driven transformations of metrics, tailored to evolving resource availability and application requirements. This paper demonstrates how PMF enables various transformations for dynamic and fine-grained metric collection. We also showcase the capability of PMF for dynamically tuning the frequency of metrics to reduce the WAN cost in edge environments. Our experiments show that PMF performs at par with state-of-the- art techniques in terms of metric processing capability, with 10X lesser resource utilization. We envision PMF to usher in an era of lightweight programmability for observability platforms. PMF is open-source and available at https://github.com/observ-vol-mgtIPMF

Multi-cloud deployments are set to change the very fabric of cloud computing, allowing applications to be deployed over multiple clusters and cloud providers, offering flexibility and geo-redundancy. Existing multi-cloud networking approaches either require tight coupling of clusters or separation of control and management for intra and inter cluster networking. Unlike compute and storage, networking for multi-cluster cannot be approached as an extension to single cluster operations. Multi -cloud necessitates that networking must be rethought in terms of the application and not the underlying networking solution, cluster type or cloud provider. We propose Application Networking Interface (ANI), an application centric, provider agnostic interface to control and manage networking solutions for single and multi-cluster contexts. ANI presents ex-citing opportunities for application networking and we envision that it will revamp the outlook towards multi-cloud networking.

Containerized Network Functions (CNFs) have seen recent increase in adoption due to the success of orchestration platforms and the natural flexibility of containers for deployment to heterogeneous, resource constrained environments like the edge. However, the weak isolation model of containers makes them susceptible to performance degradation due to interference from other containers. The interference manifests as stress on various resources like CPU, memory, cache, bandwidth of a CNF. While identifying the exact resource that is under stress is essential to employ the right remediation strategies, it is a challenging problem given the wide spectrum of applications, platforms and hardware, especially with the high performance requirements of CNFs with stringent SLAs. We present Sari, a first of a kind practical NF -agnostic framework leveraging temporal patterns in syscalls. Sari works for multi-service NFs and generalizes to a wide range of conditions. We leverage supervised time series classification and achieve performance upto 98.9% with minimal captures at runtime (starting from 25ms). Sari'sprediction error is 63.33% lower than any existing stress identification framework for VNFs and to the best of our knowledge, the first to address the problem for CNFs.

Text-based specifications are the de-facto standard for specifying complex multi-tier systems. For example, 3GPP specifications define various interfaces, messages, and message processing at the multiple inter-connected nodes of a 5G system. These standards documents tend to be verbose, and may be ambiguous or inconsistent in places, increasing programmer effort to implement them in a general purpose language. This paper presents Pyramis, a Domain Specific Language (DSL) with suitable high-level abstractions for specifying the interfaces, messages, and processing in a multi-tier system. Pyramis allows programmers to specify multi-tier systems in a concise and precise manner, and enables easy development of software based on the specifications. We also develop a translator with Pyramis that automatically generates optimized, multi-threaded C++ code for the various components of the multi-tier system from the specification, and also generates eBPF-based measurement code for computing various performance metrics. We use Pyramis to build several components in the 5G mobile packet core. We show that the specifications written in Pyramis are 2–3 × smaller than the actual reference implementation, while the auto-generated C++ code performs on par with a hand-optimized implementation. We believe that Pyramis can eventually replace verbose text specifications like the 3GPP standards documents in telecom systems.

Efforts to improve multicore scalability of network functions (NFs) have traditionally focused on making network stacks scalable via partitioning TCP/IP data structures into per-core slices and ensuring flow-to-core affinity, leading to elimination of locking in the network stack while processing an incoming packet. But the above techniques fail to eliminate locking in NFs which store state at the granularity of an application-layer key that does not map to a TCP/IP flow, e.g., NFs in the 5G packet core that store state at the granularity of a mobile subscriber/user, where requests from a user could arrive over multiple flows, or requests from multiple users can arrive on a single flow. Prior work does not allow steering all traffic of a particular user to the same core for such NFs. This paper presents AppSteer, a framework that enables application-aware steering of incoming requests to cores for NFs running on the Linux kernel, in order to localize the requests of a given application-layer entity (e.g., mobile user) to a single core. NFs running over AppSteer can then partition their state into per-core slices and access it in a lockfree manner, leading to better multicore scalability. We evaluate AppSteer by building lockfree versions of production-grade 5G core NFs running on top of AppSteer and show that they have 15–18% higher throughput at 16 cores when compared to their locking-based counterparts.

Observability Volume Management (OVM) presents a lightweight, automated processing system to help manage the large amounts of Observability data. The focus is on automating, analyzing, and making recommendations for volume management in multi-cloud, edge, and distributed systems.

Many applications deployed in the cloud are usually refactored into small components called microservices that are deployed as containers in a Kubernetes environment. Such applications are deployed on a cluster of physical servers which are connected via the datacenter network.In such deployments, resources such as compute, memory, and network, are shared and hence some microservices (culprits) can misbehave and consume more resources. This interference among applications hosted on the same node leads to performance issues (e.g., high latency, packet loss) in the microservices (victims) followed by a delayed or low-quality response. Given the highly distributed and transient nature of the workloads, it’s extremely challenging to debug performance issues. Especially, given the nature of existing monitoring tools, which collect traces and analyze them at individual points (network, host, etc) in a disaggregated manner.In this paper, we argue toward a case for a cross-domain (network & host) monitoring and debugging framework which could provide the end-to-end observability to debug performance issues of applications and pin-point the root-cause whether it is on the sender-host, receiver-host or the network. We present the design and provide preliminary implementation details using eBPF (extended Berkeley Packet Filter) to elucidate the feasibility of the system.

Several novel userspace network stacks have been proposed in recent research to overcome the limitations of the Linux network stack in providing high-performance I/O for Virtual Network Functions (VNFs). In this paper, we evaluate the performance of several state-of-the-art network stacks in the context of the VNFs of the 5G mobile packet core. The VNFs in the 5G core are several times more compute-intensive than the VNFs used to benchmark network stacks in prior work, given the need to perform user authentication and other such cryptographic operations. Our evaluation shows that while modern stacks outperform the Linux kernel stack over I/O intensive VNFs (as observed in prior work), the performance gap is not as wide in the case of CPU-intensive VNFs of the 5G core. We also find that the packet core VNFs can obtain up to 67% higher performance if the network stack could partition traffic to CPU cores at the granularity at which VNFs maintain state (mobile subscriber in this case), enabling a lockfree architecture within the VNF. The insights from our work can help us design a network stack that is better suited for compute-intensive VNFs such as those in the 5G core.

Network Function Virtualization (NFV) aims to reduce costs and increase flexibility of networks by moving functionality traditionally implemented in custom hardware into software packet processing applications, or virtual network functions (VNFs), running on commodity servers in a cloud. This paper describes the design and implementation of libVNF, a library to build high performance, horizontally scalable VNFs. Unlike existing frameworks for VNF development, our library (i) can be used for the development of L2/L3 middleboxes as well as VNFs that are transport layer endpoints; (ii) seamlessly supports multiple network stacks in the backend; and (iii) enables distributed implementation of VNFs via functions for distributed state and replica management. We have implemented a variety of VNFs using our library to demonstrate the expressiveness of our API. Our evaluation shows that building VNFs using libVNF can reduce the number of lines of code in the VNF by up to 50%. Further, optimizations in our library ensure that the performance of VNFs built with our library scales well with increasing number of CPU cores and distributed replicas.