The Segment Routing (SR) architecture is based on source routing. Within an SR enabled network, a list of instructions called segments can be added to the packet headers to influence the forwarding and the processing of the packets. In SRv6 (Segment Routing over IPv6 data plane) the segments are represented with IPv6 addresses, which are 16 bytes long. There are some SRv6 service scenarios that may require to carry a large number of segments in the IPv6 packet headers. Reducing the size of these overheads is useful to minimize the impact on MTU (Maximum Transfer Unit) and to enable SRv6 on legacy hardware devices with limited processing capabilities that could suffer from the long headers. In this paper we present the Micro SID solution for the efficient representation of segment identifiers. The proposed Micro SID solution has been implemented on three different architectures (VPP, Linux, P4) and interoperability tests have been performed. We also analyze the reduction of the header size that can be achieved with Micro SIDs and compare it with other proposals for segment list compression. Our results show that the header size can be reduced up to 75%. Finally, we mention that a fundamental asset of the proposed Micro SID solution is the full compatibility and seamless interoperability with existing SRv6 architecture.

Network services are essential in modern networks. They are a crucial part of today's network operation and ensure customizable, reliable, and secure communication. This being said, they also have a noteworthy drawback: they are consumed in a static manner. As a consequence, the management of network services is too complex and thus expensive and error-prone. Furthermore, this static processing cannot react to network changes: a service outage, a link failure, or any other network events can result in connectivity loss for customers and has to be usually resolved manually. This paper proposes a practical solution for dynamic, event-triggered, and fast path calculations that program services and permit a so-called service chain. To allow programming services directly in the backbone of a service provider network is solving the static service consumption in service provider networks. The solution is based on the functionalities of Segment Routing over IPv6 (SRv6 in short), which implements the source-based routing paradigm with the native IPv6 encapsulation. Our focus was set on finding the best reliable and fast way to calculate the best path through the given service instances. Because service provider networks are constantly growing, an algorithm has to be found and implemented so that the growth of the network has no impact on the calculation performance. A complete cloud-native development approach has been taken to create the application as elastic and fault-tolerant as possible. Thanks to the cloud-native approach, the application can be portable in a different environment, in an on-premise datacenter, or directly in the public cloud.

Segment Routing (SR) is a form of loose source routing. It provides the ability to include a list of instructions, called segments, in the packet header. The SR architecture has been first implemented with the MPLS (SR-MPLS) data plane and then, quite recently, with the IPv6 data plane (SRv6). SRv6 is a promising solution to support advanced services such as Traffic Engineering, Service Function Chaining and Virtual Private Networks. The SRv6 data plane is supported in many different software forwarding engines including the Linux kernel and the Vector Packet Processor (VPP), as well as in hardware devices. In this paper, we present SRPerf, a performance evaluation framework for software and hardware implementations of SRv6. SRPerf is able to perform different benchmarking tests such as throughput and latency. The architecture of SRPerf can be easily extended to support new benchmarking methodologies as well as different SRv6 implementations. We have used SRPerf to evaluate the performance of two SRv6 implementations: Linux kernel and VPP. SRPerf is a valuable tool in the context of modern forwarding engines where new features can be added at fast pace, as it helps experimenters to validate their work. In this work, we have leveraged SRPerf to validate the implementation of some SRv6 behaviors in the Linux kernel and we have discovered and fixed some implementation flaws, making available the fixed code.

The Segment Routing (SR) architecture is based on loose source routing. A list of instructions, called segments can be added to the packet headers, to influence the forwarding and the processing of the packets in an SR enabled network. In SRv6 (Segment Routing over IPv6 data plane) the segments are represented with IPv6 addresses, which are 16 bytes long. There are some SRv6 service scenarios that may require to carry a large number of segments in the IPv6 packet headers. Reducing the size of these overheads is useful to minimize the impact on MTU (Maximum Transfer Unit) and to enable SRv6 on legacy hardware devices with limited processing capabilities that could suffer the long headers. In this paper we present the Micro SID solution for the efficient representation of segment identifiers. With this solution, the length of the segment list can be drastically reduced.

With the growth of demands for quasi-instantaneous communication services such as real-time video streaming, cloud gaming, and industry 4.0 applications, multi-constraint Traffic Engineering (TE) becomes increasingly important. While legacy TE management planes have proven laborious to deploy, Segment Routing (SR) drastically eases the deployment of TE paths and thus became the most appropriate technology for many operators. The flexibility of SR sparked demands in ways to compute more elaborate paths. In particular, there exists a clear need in computing and deploying Delay-Constrained Least-Cost paths (DCLC) for real-time applications requiring both low delay and high bandwidth routes. However, most current DCLC solutions are heuristics not specifically tailored for SR. In this work, we leverage both inherent limitations in the accuracy of delay measurements and an operational constraint added by SR. We include these characteristics in the design of BEST2COP, an exact but efficient ECMP-aware algorithm that natively solves DCLC in SR domains. Through an extensive performance evaluation, we first show that BEST2COP scales well even in large random networks. In real networks having up to thousands of destinations, our algorithm returns all DCLC solutions encoded as SR paths in way less than a second.

In this paper, we are interested in the relationship between packet losses and routing changes in an operational network. To do so we designed and deployed DCART, a monitoring platform over RENATER, the French research and education network. Our platform collects four data sources using both active and passive measurements in order to unveil their temporal correlations. Active probing allows especially for measuring packet losses on specifically crafted data flows. Those flows explore several load balanced paths and ease the revelation of forwarding loops. Passive monitoring is achieved by listening to all routing updates from IS-IS, the intra-domain routing protocol in use, and by retrieving tickets generated by the Network Operations Center (NOC). During our monitoring campaign, we observe that most of the series of loss were correlated to routing events either because routing changes lead to inconsistent state transitions , or because faulty – and so lossy – links trigger numerous periods of link flapping. In particular, we show that losses due to forwarding loops resulting from inconsistent routing states are quite common when links come back after an outage. We also show that link flapping sometimes induce very long lasting lossy periods frequently unnoticed by the NOC. A lightweight monitoring platform such as DCART could be used to better anticipate recurrent network outages and to improve the ticketing system.

This paper presents an architecture to support Vir- tual Network Functions (VNFs) chaining using the IPv6 Segment Routing (SR) network programming model. Two classes of VNFs are considered: SR-aware and SR-unaware. The operations to support both SR-aware and SR-unaware VNFs are described at an architectural level and we propose a solution for SR-unaware VNFs hosted in a NFV node. An Open Source implementation of the proposed solution for a Linux based NFV host is available and a set of performance measurements have been carried out in a testbed.

Manageability and high availability are critical properties for IP networks. Unfortunately, with link-state routing protocols commonly used in such networks, topological changes lead to transient forwarding loops inducing service disruption. This reduces the frequency at which operators can adapt their network. Prior works proved that it is possible to avoid disruptions due to the planned reconfiguration of a link by progressively changing its weight, leading to a solution that does not require changing protocol specification. In this paper, we study the more general problem of gracefully modifying the logical state of multiple interfaces of a router, while minimizing the number of weight updates. Compared to single-link modifications, the router update problem is k-dimensional for a router having k neighbors. We also show that multidimensional updates may trigger new kinds of disruptions that make the problem more challenging than the single-link case. We then present and evaluate efficient algorithms that compute minimal sequences of weights enabling disruption-free router reconfigurations. Based on analysis of real IP network topologies, we show that both the size of such sequences and the computing time taken by our algorithms are limited.

The use of real-time multimedia or mission-critical applications over IP networks puts strong pressure on service providers to operate disruption-free networks. However, after any topological change, link-state Interior Gateway Protocols (IGPs), such as IS-IS or OSPF, enter a convergence phase during which transient forwarding loops may occur. Such loops increase the network latency and cause packet losses. In this paper, we propose and evaluate an efficient algorithm aimed at avoiding such traffic disruptions without modifying these IGPs. In case of an intentional modification of the weight of a link (e.g., to shut it down for maintenance operations or to perform traffic engineering), our algorithm iteratively changes this weight, splitting the modification into a sequence of loop-free transitions. The number of weight increments that need to be applied on the link to reach its target state is minimized in order to remain usable in existing networks. Analysis performed on inferred and real Internet service provider (ISP) topologies shows that few weight increments are required to handle most link shutdown events (less than two intermediate metrics for more than 85% of the links). The evaluation of our implementation also reveals that these minimal sequences can be computed in a reasonable time.

Manageability and evolvability are crucial needs for IP networks. Unfortunately, planned topological changes may lead to transient forwarding loops in link-state routing protocols commonly used in IP networks. These lead to service unavailability, reducing the frequency at which operators can adapt the network topology. Prior works proved that the state of a given link can be modified while avoiding forwarding inconsistencies without changing protocol specifications. In this paper, we study the more general problem of gracefully modifying the state of an entire router, while minimizing the induced operational impact. As opposed to a single-link modification, the router update problem is k-dimensional for a node of degree k. Moreover, we show that the interplay between operations applied at the router granularity can lead to loops that do not occur considering a single-link modification. In this paper, we present an efficient algorithm that computes minimal sequences of weights to be configured on the links of the updated node. Based on real IP network topologies, we show that the size of such sequence is limited in practice.

In wireless sensor networks, energy efficiency is generally achieved by turning off some capabilities from a subset of deployed sensors. The set of active nodes must therefore meet the application requirements (e.g. area coverage, data redundancy) while remaining fully connected to allow further data collection. Here, we focus on the case of a nomad sink entering the network and gathering every monitoring data. At the routing layer, minimizing the number of nodes acting as relays requires to construct a maximum leaf spanning tree (MLST). However, optimizing convergecast communications consists in minimizing the hop distance between the sink and all others nodes, leading so to a shortest path tree rooted at the sink. In this paper, we propose a distributed routing protocol that aims at constructing an energy efficient backbone being convergecast efficient at the same time. Our proposal introduces a tradeoff parameter to adjust the compromise “number of relays / routing efficiency” and then constructs a hybrid routing structure based on the combination of variants of the Wu-Li algorithm and a gradient-based routing protocol. For all topologies we simulated, and when tuned for energy saving, our approach outperforms a 2-approximation for constructing a MLST. Furthermore, when tuned for convergecast routing, simulation results show that our solution constructs a routing optimal backbone that involves a small fraction of relays.