Modern software development abstracts applications from the underlying infrastructure, enabling global-scale deployment with minimal concern about low-level networking details. However, when these infrastructure-agnostic software components need to communicate, they encounter significant networking limitations. This forces developers to either navigate complex, low-level networking constructs to achieve the desired connectivity or give up on truly flexible connectivity and limit their software to static connectivity patterns. In this paper, we focus on the evolving challenges of application connectivity in today's hyper-distributed reality. We propose to model connectivity around the notion of application services and have realized this proposal as ClusterLink, which exposes the app-level APIs for specifying communication policies at a very granular level and implements them efficiently. This paper shares details on ClusterLink design principles, APIs, architecture, and implementation, and shows that ClusterLink outperforms its closest competitor by 2.5x in throughput in a cloud-based experimental setting.

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.

Network management tasks heavily rely on network telemetry data. Programmable data planes provide novel ways to collect this telemetry data efficiently using probabilistic data structures like bloom filters and their variants. Despite the benefits of the data structures (and associated data plane primitives), their exposure increases the attack surface. That is, they are at risk of adversarial network inputs.

Enterprises often deploy their business applications in multiple clouds as well as in multiple traditional environments. This work focuses on the connectivity aspects of this new way of operating and consuming digital services. We define the related requirements, analyze the challenges, and present ClusterLink, our solution for interconnecting today's and future multi-cloud applications.

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.

5G networks are gaining pace in development and deployment in recent years. One of 5G's key objective is to support a variety of use cases with different Service Level Objectives (SLOs). Slicing is a key part of 5G that allows operators to provide a tailored set of resources to different use cases in order to meet their SLOs. Existing works focus on slicing in the frontend or the C-RAN. However, slicing is missing in the fronthaul network that connects the frontend to the C-RAN. This leads to over-provisioning in the fronthaul and the C-RAN, and also limits the scalability of the network.

Slicing is a critical technology in 5G, as it allows operators to slice a physical network into multiple virtual networks, each dedicated to a different use case/Mobile Virtual Network Operator (MVNO) [2]. Network slicing enables network operators to deploy a tailored set of resources for specific use cases or MVNO. For example, high performance reliable hardware is required only for ultra-reliable low-latency (uRLLC) use cases such as autonomous vehicle networks. Such tailoring of services reduces costs for network operators. Further, 5G systems can now be deployed more quickly due to virtualization provided by slicing, thereby enabling faster time-to-market. To this end, there exists a large body of work that introduces slicing in different parts of the cellular network (see Fig. 1). PRAN [12] and FlexRAN [13] provide slicing in the Radio Access Network (RAN) while Orion [14] provides slicing for the frontend (wireless spectrum). The fronthaul connects the frontend base station to the RAN and carries digitized radio signals between the two parts of the cellular network. However, to the best of our knowledge, there exists no work on slicing in the fronthaul. This severely limits the benefits of slicing in the RAN and the frontend (see §1.1).

Sketches have successfully provided accurate and fine-grained measurements (e.g., flow size and heavy hitters) which are imperative for network management. In particular, Count-Min (CM) sketch is widely utilized in many applications due to its simple design and ease of implementation. There have been many efforts to build monitoring frameworks based on Count-Min sketch. However, these frameworks either support very specific measurement tasks or they cannot be implemented on high-speed programmable hardware (PISA).

Writing packet-processing programs for programmable switch pipelines is challenging because of their all-or-nothing nature: a program either runs at line rate if it can fit within pipeline resources, or does not run at all. It is the compiler's responsibility to fit programs into pipeline resources. However, switch compilers, which use rewrite rules to generate switch machine code, often reject programs because the rules fail to transform programs into a form that can be mapped to a pipeline's limited resources---even if a mapping actually exists.

As the current generation of mobile smartphones become more powerful, they are being used to perform more resource intensive tasks making battery lifetime a major bottle-neck. In this paper, we present a technique called dynamic AoV lookahead for reducing wireless interface power consumption upto 50% while playing a popular, yet resource intensive, mobile multiplayer games.

With mobile devices becoming ubiquitous, collaborative applications have become increasingly pervasive. In these applications, there is a strong need to obtain a count of the number of mobile devices present in an area, as it closely approximates the size of the crowd. Ideally, a crowd counting solution should be easy to deploy, scalable, energy efficient, be minimally intrusive to the user and reasonably accurate. Existing solutions using data communication or RFID do not meet these criteria. In this paper, we propose a crowd counting solution based on audio tones, leveraging the microphones and speaker phones that are commonly available on most phones, tackling all the above criteria. We have implemented our solution on 25 Android phones and run several experiments at a bus stop, aboard a bus, within a cafeteria and a classroom. Experimental evaluations show that we are able to achieve up to 90% accuracy and consume 81% less energy than the WiFi interface in idle mode.

In this paper, we show how tone mapping techniques can be used to dynamically increase the image brightness, thus allowing the LCD backlight levels to be reduced. This saves significant power as the majority of the LCD's display power is consumed by its backlight. The Gamma function (or equivalent) can be efficiently implemented in smartphones with minimal resource cost. We describe how we overcame the Gamma function's non-linear nature by using adaptive thresholds to apply different Gamma values to images with differing brightness levels. These adaptive thresholds allow us to save significant amounts of power while preserving the image quality. We implemented our solution on a laptop and two Android smartphones. Finally, we present measured analytical results for two different games (Quake III and Planeshift), and user study results (using Quake III and 60 participants) that shows that we can save up to 68% of the display power without significantly affecting the perceived gameplay quality.

The current generation of mobile smartphones are not just devices for voice communication. Instead, they are frequently used as mobile PC replacements that are used to edit documents, browse the web, check email, and play games. However, this functionality comes at the cost of battery lifetimes. Indeed, to maintain the slim form factor required for these phones (which impacts the amount of battery that can be put into the phone), it is quite common for the battery lifetimes of smartphones to be significantly shorter compared to previous generation of "dumber" phones.