Allocating guaranteed resources and optimizing system parameters for Cloud-native Network Function (CNF) deployments introduce significant complexity in management. The performance of CNFs deployed on shared resources always depends on their incoming traffic and their competition for the underlying resource, both of which are usually very dynamic. The complexity of managing their deployments across many physical resources can explode very quickly and become infeasible for taking runtime management decisions in closed-loops. In this work we experimentally analyze the impact of CNFs sharing Central Processing Unit (CPU) and memory resources and make a key observation that increasing the number of deployed CNFs results in an increase of packet service time variability which in turn leads to longer waiting times. We also propose a model of CNF performance when sharing these resources, and discuss its extension to a general compute-network resource model for CNF performance estimation in closed management loops.

Quantum entanglement is so fundamentally different from a network packet that several quantum network stacks have been proposed; one of which has even been experimentally demonstrated. Several simulators have also been developed to make up for limited hardware availability, and which facilitate the design and evaluation of quantum network protocols. However, the lack of shared tooling and community-agreed node architectures has resulted in protocol implementations that are tightly coupled to their simulators. Besides limiting their reusability between different simulators, it also makes building upon prior results and simulations difficult. To address this problem, we have developed QuIP: a P4-based Quantum Internet Protocol prototyping framework for quantum network protocol design. QuIP is a framework for designing and implementing quantum network protocols in a platform-agnostic fashion. It achieves this by providing the means to flexibly, but rigorously, define device architectures against which quantum network protocols can be implemented in the network programming language P416. QuIP also comes with the necessary tooling to enable their execution in existing quantum network simulators. We demonstrate its use by showcasing V1Quantum, a completely new device architecture, implementing a link- and network-layer protocol, and simulating it in the existing simulator NetSquid.

Networks often need to concurrently process millions of flows with varying Quality-of-Service (QoS) requirements. Doing so by deploying flow-specific rules at network nodes would require significant memory and overhead.In this paper, we take a fundamentally different approach, called P4QoS, by embedding QoS requirements in the packets themselves and leveraging P4-programmable network switches to process the traffic based on them. We illustrate and evaluate our approach with latency as our QoS metric, but our concept can be applied to other metrics as well. Our evaluation, both in software (Mininet) and in hardware (Intel Tofino), shows that P4QoS can satisfy application-specific QoS requirements with negligible memory overhead.

The concept of network slicing enables operators to provision multiple virtual networks on top of a single (shared) physical infrastructure. Adding elasticity to slicing, i.e., the ability to on-demand provision/release dedicated network resources, improves resource utilization. However, efficiently allocating and scaling slice resources, while maintaining state consistency, is challenging. Especially with P4-programmab1e network devices that process packets at Tbps speeds, controller-driven scaling of network functions would be too time-consuming, and data-plane scaling is needed. In this paper, we address this need, by developing a custom scaling protocol and framework that can consistently, with negligible delay, scale network slices and functions transparently to the slice end-users. We compare, via emulation and experiments on programmable hardware, our approach to state-of-the-art scaling techniques and demonstrate significant slice resource utilization improvements and scaling duration reductions.

Congestion control algorithms are usually developed in isolation without thoroughly investigating their co-existence and interactions with other protocols and/or congestion control algorithms. As a result, flows using different algorithms and/or having different Round-Trip Times may overpower each other, resulting in unfair resource distribution, with a subset of the flows usually claiming most of the capacity. To solve the aforementioned problem, we make use of programmable switches and the network programming language P4 to enforce fairness from within the network itself, instead of from the congestion control algorithms ran at the end-points. Our solution P4air continuously monitors the properties of all flows that pass through a switch and groups them based on the behavior of the congestion control algorithms used. Furthermore, for each group, it applies appropriate measures to suppress the aggressive flows and boost smaller flows. Our experiments, using modern programmable hardware (Barefoot Tofino switch), demonstrate significant performance gains for P4air in terms of fairness compared to state-of-the-art solutions.