There is no system yet that provides predictable data plane and control plane operations in programmable networks. However, both predictable data plane and control plane operations are needed, e.g., in industrial networks. Particularly there, the operation of the network needs to be planned and, hence, relies on network operations that are deterministic and executed in a timely manner. To fill this gap, this paper proposes our system namedNAGA, which provides data plane deterministic guarantees along with consistent and timely network updates in programmable networks. In order to not rely on specialized hardware,NAGAuses widely-available hardware capabilities such as priority queuing and label-based forwarding. Whereas the real implementation ofNAGAin a P4-based testbed demonstrates that applications receive guaranteed performance in terms of latency and data rate, simulation studies show the ability ofNAGAto be even deployed in large scale scenarios beyond industrial networks, such as wide area and data center networks.

Languages for programming data planes like P4 sparked a plethora of new applications in the data plane. The dynamic, evolving environment makes it challenging to understand what performance can be expected when running a program in a specific data plane target. However, knowing this is crucial for network operators when upgrading their networks.

To provide the predictability required by emerging applications, operators typically rely on policing and/or shaping at the edge to ensure that tenants do not use excess bandwidth that was not accounted for. One of the promises of 6G is to deploy applications with strict predictability requirements across subnets and even over the Internet, where policing cannot be implemented in the end hosts. This paper presents an empirical study of the ability of modern programmable network devices to implement predictable traffic policing in the network. We find out that none of the five investigated hardware switches can provide accurate traffic policing, a key requirement for providing predictable service to applications. We observe that the switches let applications send more than what they should be allowed to, reaching up to 60% and 100% relative error for the rate and burst parameters. We further uncover the fact that switches cannot police arbitrarily low bursts, e.g., not less than 13 kilobit for one of our switches. We investigate how such limitations impact the performance of state-of-the-art solutions for predictable latency such as Chameleon. We observe that, for ensuring its predictable guarantees, Chameleon rejects around 50% of the tenants it could accommodate if switches were perfect, hence decreasing by the same ratio the revenue for the operator. Based on these observations, we discuss solutions toward more accurate and predictable policing in wide-area networks.

Providing predictable performance to tenants is mission critical for network hypervisors. As a hypervisor acts as an intermediary between tenants controllers and the physical infrastructure, its resources (e.g., CPU, RAM) should be provisioned and allocated carefully. Initially, we demonstrate that state-of-the-art CPU prediction approaches are not suitable for provisioning network hypervisor CPU resources, since they predict only the mean CPU utilization. However, provisioning the resources with a mean value can significantly degrade the forwarding performance of a network hypervisor. In this article, we present a novel approach which provisions network hypervisor CPU resources efficiently, while avoiding performance degradation. We take three steps to achieve our goal:(i)conducting a profound measurement campaign to determine what is the minimum amount of CPU resources that needs to be allocated to a network hypervisor in order to have no performance degradation;(ii)revealing the key properties of virtual networks that affect the CPU utilization;(iii)designing a precise CPU prediction model. Using randomly generated virtual networks and arbitrary physical topologies, we show that our prediction model exhibits an average relative error of around 4%. Further, our evaluations indicate that provisioning the CPU resources of a network hypervisor based on the proposed prediction model does not degrade the hypervisor forwarding performance. Utilizing our approach, network operators can minimize their resources consumption while still providing predictable and undegraded forwarding performance to tenants.

This paper presents Chameleon, a cloud network providing both predictable latency and high utilization, typically two conflicting goals, especially in multi-tenant datacenters. Chameleon exploits routing flexibilities available in modern communication networks to dynamically adapt toward the demand, and uses network calculus principles along individual paths. More specifically, Chameleon employs source routing on the "queue-level topology", a network abstraction that accounts for the current states of the network queues and, hence, the different delays of different paths. Chameleon is based on a simple greedy algorithm and can be deployed at the edge; it does not require any modifications of network devices. We implement and evaluate Chameleon in simulations and a real testbed. Compared to state-of-the-art, we find that Chameleon can admit and embed significantly, i.e., up to 15 times more flows, improving network utilization while meeting strict latency guarantees.

To meet their increasingly stringent dependability requirements, communication networks need to be predictable, both in terms of correctness and performance. In principle, Software-Defined Networks (SDN) enable such more predictable networks, however, these networks still depend the underlying switches. This paper presents an empirical study of the predictability of SDN switches. Our extensive benchmarking of seven hardware OpenFlow switches from four different manufacturers raises several concerns regarding the dependability of these switches. We uncover several incorrect and unpredictable behaviors and performance issues. In particular, we identify unpredictable behaviors related to the management of flows and buffers, and observe that existing quality-of-service mechanisms, such as priority queuing, introduce unexpected overheads. The latter, in turn, can lead to violations of latency guarantees. Based on our insights, we discuss first solutions toward more predictable architectures.

A predictable network performance is mission critical for many applications and yet hard to provide due to difficulties in modeling the behavior of the increasingly complex network equipment. This paper studies the problem of providing deterministic latency guarantees in small networks based on low-capacity hardware (e.g., in-cabin and industrial networks): such networks are of increasing importance, need to meet stringent performance requirements, but have hardly been explored so far. Our main contribution is the design, implementation, and evaluation of Loko, a system which provides predictable latency guarantees in programmable networks using low-cost hardware. Loko relies on a novel measurement-based methodology and uses deterministic network calculus to derive a reliable performance model of a given switch. To this end, we also show that state-of-the-art models in the literature like QJump and Silo fall short to model the behavior of such switches, due to incorrect architectural and performance assumptions. As a case study, we implement Loko for the Zodiac FX switch. Our experiments are encouraging: we find that the derived models are indeed accurate, allowing Loko to provide deterministic end-to-end guarantees with low-cost programmable devices.

Byzantine Fault Tolerance (BFT) enables correct operation of distributed, i.e., replicated applications in the face of malicious take-over and faulty/buggy individual instances. Recently, BFT designs have gained traction in the context of Software Defined Networking (SDN). In SDN, controller replicas are distributed and their state replicated for high availability purposes. Malicious controller replicas, however, may destabilize the control plane and manipulate the data plane, thus motivating the BFT requirement. Nonetheless, deploying BFT in practice comes at a disadvantage of increased traffic load stemming from replicated controllers, as well as a requirement for proprietary switch functionalities, thus putting strain on switches' control plane where particular BFT actions must be executed in software. P4BFT leverages an optimal strategy to decrease the total amount of messages transmitted to switches that are the configuration targets of SDN controllers. It does so by means of message comparison and deduction of correct messages in the determined optimal locations in the data plane. In terms of the incurred control plane load, our P4-based data plane extensions outperform the existing solutions by ~33.2% and ~40.2% on average, in random 128-switch and Fat-Tree/Internet2 topologies, respectively. To validate the correctness and performance gains of P4BFT, we deploy bmv2 and Netronome Agilio SmartNIC-based topologies. The advantages of P4BFT can thus be reproduced both with software switches and "commodity" P4-enabled hardware. A hardware- accelerated controller packet comparison procedure results in an average 96.4% decrease in processing delay per request compared to existing software approaches.

People desire to be connected, no matter where they are. Recently, providing Internet access to on-board passengers has received a lot of attention from both industry and academia. However, in order to guarantee an acceptable Quality of Service (QoS) for the passenger services with low incurred cost, the path to route the services, as well as the datacenter (DC) to deploy the services should be carefully determined. This problem is challenging, due to different types of Air-to-Ground (A2G) connections, i.e., satellites and Direct Air-To-Ground (DA2G) links. These A2G connection types differ in terms of cost, bandwidth, and latency. Furthermore, due to the flights' movements, it is important to consider adapting the service location accordingly. In this work, we formulate two Mixed Integer Linear Programs (MILPs) for the problem of Joint Service Placement and Routing (JSPR): i) Static (S-JSPR), and ii) Mobility-Aware (MA-JSPR) in Space-Air-Ground Integrated Networks (SAGIN), with the objective of minimizing the total cost. We compare S-JSPR and MA-JSPR using comprehensive evaluations in a realistic European-based SAGIN. The obtained results show that the MA-JSPR model, by considering the future flight positions and using a service migration control, reduces the long-term total cost notably. Also, we show S-JSPR benefits from a low time-complexity and it achieves lower end-to-end delays comparing to MA-JSPR model.

Current approaches to tackle the single point of failure in SDN entail a distributed operation of SDN controller instances. Their state synchronization process is reliant on the assumption of a correct decision-making in the controllers. Successful introduction of SDN in the critical infrastructure networks also requires catering to the issue ofunavailable,unreliable(e.g. buggy), andmaliciouscontroller failures. We propose MORPH, a framework tolerant to unavailability and Byzantine failures, which distinguishes and localizes faulty controller instances and appropriately reconfigures the control plane. Our controller-switch connection assignment leverages the awareness of the source of failure to optimize the number of active controllers and minimize the controller and switch reconfiguration delays. The proposed re-assignment executes dynamically after each successful failure identification. We require$2F_{M}+F_{A}+1$controllers to tolerate$F_{M}$malicious and$F_{A}$availability-induced failures. After a successful detection of$F_{M}$malicious controllers, MORPH reconfigures the control plane to require asinglecontroller message to forward the system state. Moreover, we outline and present a solution to the practical correctness issues related to thestatefulnessof the distributed SDN controller applications, previously ignored in the literature. We base our performance analysis on a resource-aware routing application, deployed in an emulated testbed comprising up to 16 controllers and up to 34 switches, so to tolerate up to 5 unique Byzantine and additional 5 availability-induced controller failures (a total of 10 unique controller failures). We quantify and highlight the dynamic decrease in the packet and CPU load and the response time after each successful failure detection.