Real-time Communications (RTC) services, including multiparty conferencing, live streaming, and cloud-gaming, rely on a large-scale media plane infrastructure that provides real-time audio/video processing to clients. Unfortunately, offthe- shelf RTC services are not elastically scalable. As a result, operators must provision media servers to meet peak demand, resulting in resource under-utilization and high cost. Given that today microservice orchestrators like Kubernetes allow web-services to scale transparently and econimically, this paper looks at applying the same approach to scale large-scale RTC services. We find that this is challenging for two reasons: (a) the default network dataplane underlying Kubernetes does not meet the compelling traffic management, performance and real-time requirements of RTC; and (b) current autoscaling policies are ill-suited to RTC. We address these challenges by designing a RTC-specific service mesh that pushes media traffic processing into the OS kernel and designing new RTC-specific Kubernetes autoscaling policies. Our evaluation on a functional VoIP test-bed shows that this combination allows to deploy elatically scalable RTC services with 100× lower-jitter and 700× lower RTT than the current state-of-the art.

While the industry is still struggling to embrace the network function virtualization paradigm, recently a novel approach has appeared with the promise of improving the state-of-the-art: stateless virtualized network functions. Rooted in cloud-native computing, this design outsources the state embedded in virtual network functions to a dedicated "state storage" layer, facilitating elastic scaling and resiliency. While related work mostly focuses on performance, we in this paper pinpoint all other factors that weigh in when it comes to deploying the stateless design in a carrier-grade operator network. Among those we argue that reliability and flexibility are key, and we propose a system design that can be adapted to any telco use case without the need for complex coordination among the network control, the stateless network functions, and the state storage backend. Then, in extensive evaluations on synthetic use cases we show that the additional flexibility provided by our design does not come at a performance penalty; in fact, in certain cases our design outperforms the state-of-the-art significantly. Finally, we present what to our knowledge is the first product-phase realization of the stateless paradigm, an operational virtualized IP Multimedia Subsystem that can restore the live call records of thousands of mobile subscribers under a couple of seconds with half the resources required by a traditional "stateful" design.

Packet processing programs may have multiple semantically equivalent representations in terms of the match-action abstraction exposed by the underlying data plane. Some representations may encode the entire packet processing program into one large table allowing packets to be matched in a single lookup, while others may encode the same functionality decomposed into a pipeline of smaller match-action tables, maximizing modularity at the cost of increased lookup latency. In this paper, we provide the first systematic study of match-action program representations in order to assist network programmers in navigating this vast design space. Borrowing from relational database and formal language theory, we define a framework for the equivalent transformation of match-action programs to obtain certain irredundant representations that we call "normal forms". We find that normalization generally improves the capacity of the control plane to program the data-plane and to observe its state, at the same time having negligible, or positive, performance impact.

The killer features of the next-generation 5G mobile standard, including mobile edge computing and network slicing, will be very difficult to support with traditional fixed-function network appliances. Rather, the 5G core will depend on programmable switches, which allow packet processing functionality to be reconfigured on the fly in order to deploy virtualized network functions and service chains instantaneously. With 5G on the close horizon, it has become crucial to identify the price for programmability in the software data plane, considering the expected complexity and scale of the next-generation mobile core. In this paper, we report on a multi-year data-plane scalability study we have conducted for a large mobile vendor. Our results paint a rather pessimistic picture on the current landscape of the programmable software data plane. We find that the prominent programmable switches either do not provide all the features necessary to implement 5G telco pipelines efficiently or struggle to meet the scale, and the performance operators have come to expect from conventional fixed-function appliances. The only exception, ESwitch, remains proprietary. We call for further work on data-plane scalability and sketch some directions for future research.

This experience paper describes the process of leveraging the NFV orchestration platform built in the EU FP7 project UNIFY to deploy a dynamic network service exemplified by an elastic router. Elasticity is realized by scaling dataplane resources as a function of traffic load. To achieve this, the service includes a custom scaling logic and monitoring capabilities. An automated monitoring framework not only triggers elastic scaling, but also a troubleshooting process which detects and analyzes anomalies, pro-actively aiding both dev and ops personnel. Such a DevOps-inspired approach enables a shorter update cycle to the running service. We highlight multiple learnings yielded throughout the prototype realization, focussing on the functional areas of service decomposition and scaling; programmable monitoring; and automated troubleshooting. Such practical insights will contribute to solving challenges such as agile deployment and efficient resource usage in future NFV platforms.

Next generation network services will be realized by NFV-based microservices to enable greater dynamics in deployment and operations. Here, we present a demonstrator that realizes this concept using the NFV platform built in the EU FP7 project UNIFY. Using the example of an Elastic Router service, we show automated deployment and configuration of service components as well as corresponding monitoring components facilitating automated scaling of the entire service. We also demonstrate automatic execution of troubleshooting and debugging actions. Operations of the service are inspired by DevOps principles, enabling quick detection of operational conditions and fast corrective actions. This demo conveys essential insights on how the life-cycle of an NFV-based network service may be realized in future NFV platforms.

Network service providers are facing challenges for deploying new services mainly due to the growing complexity of software architecture and development process. Moreover, the recent architectural innovation of network systems such as Network Function Virtualization (NFV), Software-defined Networking (SDN), and Cloud computing increases the development and operation complexity yet again. One of the emerging solutions to this problem is a novel software development concept, namely DevOps, that is widely employed by major Internet software companies. Although the goals of DevOps in data centers are well-suited for the demands of agile service creation, additional requirements specific to the virtualized and software-defined network environment are important to be addressed from the perspective of modern network carriers. In this paper, we thoroughly debate DevOps requirements for developing a modern service creation platform by taking EU FP7 project UNIFY as a reference architecture and suggest the corresponding extensions of UNIFY interfaces that meet the discovered requirements.

Software Defined Networking (SDN) and Network Functions Virtualization facilitate, with their advanced programmability features, the design of automated dynamic service creation platforms. Applying DevOps principles to service design can further reduce service creation times and support continuous operation. Monitoring, troubleshooting, and other DevOps tools can have different roles within virtualised networks, depending on virtualization level, type of instantiation, and user intent. We have implemented and integrated four key DevOps tools that are useful in their own right, but showcase also an integrated scenario, where they form the basis for a more complete and realistic DevOps toolkit. The current set of tools include a message bus, a rudimentary configuration tool, a probabilistic congestion detector, and a watchpoint mechanism. The demo also presents potential roles and use-cases for the tools.

SDN opens a new chapter in network troubleshooting as besides misconfigurations and firmware/hardware errors, software bugs can occur all over the SDN stack. As an answer to this challenge the networking community developed a wealth of piecemeal SDN troubleshooting tools aiming to track down misconfigurations or bugs of a specific nature (e.g. in a given SDN layer). In this demonstration we present EPOXIDE, an Emacs based modular framework, which can effectively combine existing network and software troubleshooting tools in a single platform and defines a possible way of integrated SDN troubleshooting.

Many networking visioners agree that 5G will be much more than the incremental improvement, in terms of data rate, of 4G. Besides the mobile networks, 5G will fundamentally influence the core infrastructure as well. In our vision the realization of the challenging promises of 5G (e.g. extremely fast, low-overhead, low-delay access of mostly cloudified services and content) will require the massive use of multipathing equipped with low overhead transport solutions tailored to fast, reliable and secure data retrieval from cloud architectures. In this demo we present a prototype architecture supporting such services by making use of automatically configured multipath service chains implementing network coding based transport solutions over off-the-shelf software defined networking (SDN) components.

Multipath TCP is an experimental transport protocol with remarkable recent past and non-negligible future potential. It has been standardized recently, however the evaluation studies focus only on a limited set of isolated use-cases and a comprehensive analysis or a feasible path of Internet-wide adoption is still missing. This is mostly because in the current networking practice it is unusual to configure multiple paths between the endpoints of a connection. Therefore, conducting and precisely controlling multipath experiments over the real “internet” is a challenging task for some experimenters and impossible for others. In this paper, we invoke SDN technology to make this control possible and exploit large-scale internet testbeds to conduct end-to-end MPTCP experiments. More specifically, we establish a special purpose control and measurement framework on top of two distinct internet testbeds. First, using the OpenFlow support of GÉANT, we build a testbed enabling measurements with real traffic. Second, we design and establish a publicly available large-scale multipath capable measurement framework on top of PlanetLab Europe and show the challenges of such a system. Furthermore, we present measurements results with MPTCP in both testbeds to get insight into its behavior in such not well explored environment.

Mininet is a great prototyping tool which combines existing SDN-related software components (e.g., Open vSwitch, OpenFlow controllers, network namespaces, cgroups) into a framework, which can automatically set up and configure customized OpenFlow testbeds scaling up to hundreds of nodes. Standing on the shoulders of Mininet, we implement a similar prototyping system called ESCAPE, which can be used to develop and test various components of the service chaining architecture. Our framework incorporates Click for implementing Virtual Network Functions (VNF), NETCONF for managing Click-based VNFs and POX for taking care of traffic steering. We also add our extensible Orchestrator module, which can accommodate mapping algorithms from abstract service descriptions to deployed and running service chains.

Multipath TCP is an experimental transport protocol with remarkable recent past and non-negligible future potential. However the lack of available large-scale testbeds and publicly accessible multiple paths grossly prohibits the adoption of the technology. Here, we demonstrate a large-scale multipath playground deployed on PlanetLab Europe, which can be used either by experimenters and researchers to test and verify their multipath-related ideas (e.g. enhancing congestion control, fairness or even the arrangement of multiple paths) and also by early adopters to enhance their Internet connection even if single-homed.

The limited capabilities of the switches renders the implementation of unorthodox routing and forwarding mechanisms as a hard task in OpenFlow. Our high level goal is therefore to inspect the possibilities of slightly smartening up the OpenFlow switches. As a first step in this direction we demonstrate (with Bloom filters, greedy routing and network coding) that a very limited computational capability enables us to natively support experimental technologies while preserving performance. We distribute the demos in source files and as a ready-to-experiment VM image to promote further improvements and evaluations.

In real-time video streaming data is only useful until its lifetime expires. The significant channel condition variations in case of multi-hop ad hoc networks undermine the quality of multimedia applications by introducing congestion and delay jitters. To overcome problems related to congestion, previous works considered media transcoding or selective packet dropping. However, these methods seems to be inadequate to eliminate stale packets with expired lifetime. In this paper we propose a mechanism, where the scheduler can decide if the respective frame is eligible or not for transmission, namely, if it can be entirely transmitted before its lifetime expires. For the decisions, only the length and deadline of upcoming frames are considered. The behavior of locally acting and feedback-based decision mechanisms are both explored through extensive simulations. Our approach performs better than the previous solutions in terms of effective channel utilization and end-to-end delay.

In the widely studied and powerful bufferless fluid flow multiplexing model (bffm), important QoS measures are often considered such as saturation probability and workload loss ratio. When regulated traffic are multiplexed into a buffer, similar QoS measures can also be identified such as buffer overflow probability and buffer workload loss ratio. In this paper, we set up a family of closed-form bounds which can be applied for QoS measures arising in both multiplexing models. The bounds have been compared based on numerical investigations.

This paper proposes network level call admission control (CAC) algorithms for the most significant theoretical traffic scheduling algorithm, generalized processor sharing (GPS), and highlights important issues that arise when generalizing single node CAC results to the network level. The framework allows arbitrary network topology, in which competing leaky bucket controlled sessions are considered to be arbitrary weighted. This weighting relaxes bandwidth-delay coupling and extends the usable weight space of the admissible region, which make possible to build resource efficient CAC algorithms on the network level when combined with the tight delay bounds of [Barta, F. et al., 2001]. In order to keep end-to-end delay bounds under control, network nodes apply traffic shaping to eliminate the effects of complex traffic interactions.

This paper proposes several call admission control (CAC) algorithms for tandem networks that employ the generalized processor sharing (GPS) scheduling discipline, and also points out important network issues that are crucial in the design of network level CAC algorithms for GPS. Sessions are considered to be leaky bucket constrained and are regulated by traffic shapers at each network node. The end-to-end service curve approach of Barta et al. (2001) is used to carry out the analytical framework of our algorithms. Different CAC algorithms are developed to support different session treatment strategies and diverse server capacities. The proposed algorithms follow different end-to-end delay provisioning strategies whose performance is compared through numerical examples.

This work is motivated by the increasing need of end-to-end performance bound provisioning in multi-service networks. Providing performance bounds in a networking environment is a difficult problem as traffic is bursty and its dynamics is far more complex than in a single server environment. As end-to-end bounds are basically based on local switch guarantees, computation of local performance bounds requires the knowledge of traffic conditions at inputs of each switch. This paper investigates the problem of traffic characterization of arbitrary topology networks that employ the generalized processor sharing (GPS) scheduling discipline at each node. The study focuses on the derivation of internal (at inputs of switches) traffic descriptors of sessions which are originally leaky bucket constrained at the network edge. Allowing arbitrary weight assignment of sessions the analysis classifies GPS networks into different sets by means of various stability conditions. Methods are presented for the determination of internal traffic parameters in cyclic, acyclic networks with and without virtual feedback. Numerical examples are shown for the illustration of our algorithmic approach for the above mentioned scenarios as well as for end-to-end delay computation of sessions.

We propose a solution to the problem of calculating deterministic end-to-end delay bounds in arbitrary topology networks, which employ the generalized processor sharing (GPS) discipline at each node. We give a general framework under network calculus by extending the service curve model of GPS and constructing the end-to-end service curve for each session, from which exact values of delay and backlog bounds can be computed. Network internal traffic characterization and traffic shaping are applied to support local performance bound computation. Sessions are allowed to be arbitrary weighted and virtual feedback is handled by the iterative approach of Barta, Nemeth, Szabo and Bird (see ICC2001). Numerical examples are shown to illustrate our algorithmic approach for per-session end-to-end delay bound computation.

Generalized processor sharing (GPS) is an ideal fluid scheduling discipline that supports well defined delay and loss bounds on leaky-bucket constrained traffic. Its packetized versions (WFQ, WF2Q, PGPS etc.) are considered as the packet scheduler of choice in IP routers and ATM switches of the future. The currently accepted approach for the design of GPS schedulers is based on deterministic QoS guarantees, which is overly conservative due to the applied loose bounds and leads to limitations on capacity. We developed a framework for the computation of tighter delay bounds, bandwidth and delay de-coupling in GPS systems. In this paper, we propose several effective call admission control (CAC) algorithms that work in the bandwidth and delay de-coupled system while using the tighter delay bounds presented herein. One of the proposed CAC algorithms also handles the best-effort service class beside the QoS guaranteed service classes. Performance evaluation of several CAC algorithms are presented.