Q-SR: An Extensible Optimization Framework for Segment Routing

12/24/2020
by   Jianwei Zhang, et al.
Microsoft
0

Segment routing (SR) combines the advantages of source routing supported by centralized software-defined networking (SDN) paradigm and hop-by-hop routing applied in distributed IP network infrastructure. However, because of the computation inefficiency, it is nearly impossible to evaluate whether various types of networks will benefit from the SR with multiple segments using conventional approaches. In this paper, we propose a flexible Q-SR model as well as its formulation in order to fully explore the potential of SR from an algorithmic perspective. The model leads to a highly extensible framework to design and evaluate algorithms that can be adapted to various network topologies and traffic matrices. For the offline setting, we develop a fully polynomial time approximation scheme (FPTAS) which can finds a (1+ω)-approximation solution for any specified ω>0 in time that is a polynomial function of the network size. To the best of our knowledge, the proposed FPTAS is the first algorithm that can compute arbitrarily accurate solution. For the online setting, we develop an online primal-dual algorithm that proves O(1)-competitive and violates link capacities by a factor of O(log n), where n is the node number. We also prove performance bounds for the proposed algorithms. We conduct simulations on realistic topologies to validate SR parameters and algorithmic parameters in both offline and online scenarios.

READ FULL TEXT VIEW PDF

page 2

page 3

page 4

page 5

page 6

page 7

page 9

page 11

12/25/2020

Extreme Flow Decomposition for Multi-Source Multicast with Intra-Session Network Coding

Network coding (NC), when combined with multipath routing, enables a lin...
01/03/2019

An Efficient Linux Kernel Implementation of Service Function Chaining for legacy VNFs based on IPv6 Segment Routing

We consider the IPv6 Segment Routing (SRv6) technology for Service Funct...
07/23/2020

Micro SIDs: a solution for Efficient Representation of Segment IDs in SRv6 Networks

The Segment Routing (SR) architecture is based on loose source routing. ...
10/18/2021

Deploying Near-Optimal Delay-Constrained Paths with Segment Routing in Massive-Scale Networks

With a growing demand for quasi-instantaneous communication services suc...
08/05/2021

Routing with Face Traversal and Auctions Algorithms for Task Allocation in WSRN

Four new algorithms (RFTA1, RFTA2, GFGF2A, and RFTA2GE) handling the eve...
11/10/2020

Computing Delay-Constrained Least-Cost Paths for Segment Routing is Easier Than You Think

With the growth of demands for quasi-instantaneous communication service...
06/04/2020

TDSR: Transparent Distributed Segment-Based Routing

Component reliability and performance pose a great challenge for interco...

I Introduction

Segment routing (SR) combines the advantages of source routing supported by centralized software-defined networking (SDN) paradigm and hop-by-hop routing applied in distributed IP network infrastructure [1, 2, 12]. The key idea behind SR is to break a routing path into multiple segments using a sequence of SR-node (a.k.a. intermediate node) in order to control the routing path more flexibly and hence improve network utilization.

In parallel with the SR, middleboxes have become ubiquitous in SDN as well as data center networks (DCN). Service function chaining (SFC) is a set of operations to steer traffic through an ordered list of physical or virtual middleboxes which provide network functions such as VPN, NAT, DPI, and firewall. From another perspective, SR can be viewed as the supporting technology of a large variety of novel network technologies at the network layer, such as SFC [4], network function virtualization (NFV) [11], 5G [13], SD-WAN [2]. They share a common technical ground on the modeling and algorithm design from the multi-commodity flow (MCF) theory, while having disparate orientations.

Existing literature claim that 2-SR (SR using at most 2 segments) can achieve near-optimal performance [8, 10, 22, 23]. Thus, the routing paths between the source and target nodes usually take on a short and wide shape, i.e., there are usually a large number of 2-hop paths; here each hop means a shortest path routing. This is quite different from the case in SFC, where the routing paths are often long and narrow. Due to the computation inefficiency, it is nearly impossible to evaluate whether various types of networks will benefit from the SR with multiple segments using conventional approaches [22]. To this end, in this paper, we try to address the following challenges in SR networks.

  • How to establish a flexible and extensible model to optimize network throughput by leveraging SR with multiple segments?

  • How to design efficient algorithms to solve the model in both offline and online scenarios?

To tackle the above challenges, we aim to fully explore the potential of SR from an algorithmic perspective. Similar to the methodology in [6], we will not consider practical hardware (e.g. routers) or software (e.g. protocols) limits on the segment number. Specifically, the main contributions of this paper are the following:

  • We propose a flexible -SR model as well as its formulation where segment number, SR-node number, intra-segment routing policy are all parameterized. The model leads to a highly extensible framework to design and evaluate algorithms that can be adapted to various network topologies and traffic matrices.

  • For the offline setting, we develop an fully polynomial time approximation scheme (FPTAS) which can finds a -approximation solution for any specified in time that is a polynomial function of the problem size. The proposed FPTAS is the first algorithm that can compute arbitrarily accurate solution and only on this basis can we further evaluate whether using multiple segments is inevitable on various types of networks.

  • For the online setting, we develop an online primal-dual algorithm that proves -competitive and violates link capacities by a factor of , where is the node number.

  • We prove performance bounds for the proposed algorithms. We conduct simulations on realistic topologies to validate SR related parameters and algorithmic parameters in both offline and online settings.

The rest of this paper is organized as follows. We review related work in Section II. We introduce the system model and preliminaries in Section III. We formulate the offline and online network throughput maximization problems for SR and develop approximation and online algorithms in Sections IV and V, respectively. The min-cost SR-path computation module is presented in Section VI. We present simulation results in Section VII. Finally, we discuss important extentions in Section VIII and conclude in Section IX. All proofs are presented in the appendix. Main notation is summarized in Table I.

Ii Related Work

Ii-a Segment Routing Using Multiple Segments

Bhatia et al. [8] for the first time formulate a generic SRTE problem to minimize maximum link utilization, where all intermediate nodes are used to construct optimal segment routing paths and they also propose a 2-SR online algorithm.

To jointly optimize the efficiency of intermediate nodes selection and the subsequent flow assignment, Settawatcharawanit et al. [10] formulate a bi-objective mixed-integer nonlinear program (BOMINLP) to investigate the trade-off between link utilization and computation time. They conclude that the maximum link utilization performance of 2-SR is indentical to -SR. Thus, they focus on limiting the candidate paths lengths as well as reducing the computation overheads by a stretch bounding method.

Pereira et al. [3]

propose a single adjacency label path segment routing (SALP-SR) model that forwards traffic flows using at the most three segments. They also propose an evolutionary computation approach to improve traffic distribution. As applications, they also extend the model to handle semi-oblivious traffic matrices and address link failures.

Jadin et al. [6] formulate the SRTE problem into an ILP, and propose a CG4SR approach that combines the column generation and dynamic program techniques. The approach can only obtain near optimal solutions with gap guarantees by realistic experiments. They also compute a stronger lower-bound than traditional MCF approach through experiments.

Li et al. [5] find that SR without support of adjacency segments cannot reach the optimum. To fully support adjacency segments in SR, they propose an extended LP formulation for 2-SR and an MILP formulation for -SR. Due to the computation complexity, the MILP is further simplified to prevent excessive flow splitting or using long paths.

SR combines the advantages of centralized inter-segment source routing and distributed intra-segment hop-by-hop routing. Unlike the above works, the proposed -SR model in this paper provides the maximum freedom to deploy SR-nodes and predict the performance. Our algorithm proves a -approximation solution, that is, it can be arbitrarily close to the optimum. In our simulation, the proposed algorithms can even support rapid computation for the number of segments as large as .

Ii-B Service Function Chain

Starting from the classical MCF model, Cao et al. [15] consider the policy-aware routing problem in both offline and online settings, where a traffic demand must traverse a predetermined ordered list of middleboxes. However, the only resource constraint is put on link capacities; the middleboxes do not consume any resources.

Further, Charikar et al. [16] propose a new kind of MCF problem, where the traffic flows consume bandwidth on the links as well as processing resources on the nodes. They also formulate the problem via an LP model and develop an efficient combinatorial algorithm to solve the model approximatedly with arbitrary accuracy.

Recently, more realistic SFC models for unicast [17] and multicast [18], which incorporate link bandwidth, residual energy in mobile devices and cloudlet computing capacity constraints in the context of NFV-enabled MEC networks are proposed. Notice that these models assume that the network elements (APs or cloudlets) in the backbone are connected via wireline links.

Although SR and SFC belong to different areas of research, they are very close in terms of the MCF-based models and algorithms. In SR, all the available resources, including network links and SR-nodes, should be jointly managed to optimize the TE objectives at the network layer [21, 22]. While in SFC, the middleboxes impose extra computation and storage constraints on a wider range of objectives from network layer to application layer. Therefore, the two areas can borrow ideas and merit from each other.

Notation Description
SR network , where is the node set and the link set.
Auxiliary graph constructed for request .
Node number and link number of .
Capacity of link .
, , Request , its source node and target node.
Size of request .
Set of all possible SR-node lists for request .
Available SR-nodes for request .
Maximum number of segments for request .
SR-path via SR-node list due to request .
Mapping coefficient from to link , i.e. the amount of flow routed on link through SR-node list due to a unit request .
Fraction of request routed through SR-node list .
Flow amount of request routed through SR-node list .
Dual variable associated with each link .
Dual variable associated with each request .
Multiplier that request size can be supported for .
Tunable parameter of FPTAS.
Tunable parameter of online algorithm.
SR Segment routing.
LP Linear program.
MCF Multi-commodity flow.
ECMP Equal-cost multipath.
MF Middlebox fabric.
TABLE I: Notations

Iii System Model

We model an SR network with a directed graph , where represents the node set and the link (edge) set. The number of nodes and links are denoted by and , respectively. The network is not necessarily assumed symmetric, i.e., some links may not be bi-directional.

We introduce the following SR parameters in the -SR framework, which can be illustrated by Fig. 3 in Section VI.

  • SR-node set (a.k.a. the width of MF in Fig. 3);

  • Segment number (a.k.a. the length of MF in Fig. 3);

  • Intra-segment routing;

  • Inter-segment routing.

Given a request , assume the set of available SR-nodes is and the (maximum allowable) segment number is , then .

By definition, -SR may even degenerate to 1-SR, i.e. the shortest path routing, or generalize to -SR, i.e. the MCF routing, which can use all simple paths available to achieve the highest performance in theory while suffering from the largest cost.

Define as the set of all possible SR-node lists, i.e.:

The framework is flexible and extensible to support innovations in SR. For instance, under this framework, both node segment and adjacency segment in SR can be supported. In this paper, we restrict our attention to inter-segment routing, assuming that the intra-segment routing multpaths are predetermined using some link-state routing protocols.

Iii-a SR-Function for Intra-Segment Routing

Let represent the flow on link when unit flow is routed from to according to some link-state routing policy. The routing policy may be the shortest path algorithm (ECMP permitted), DEFT [24], PEFT [25], and etc. Note that is uniquely determined by the IGP link weights, which have no relation with the link length system in the dual problem. The link-state based routing policy based on the IGP link weights. Therefore, we treat as input parameters of the solution algorithms. The definition and computation of consider the hierarchical structure of the Internet. Unlike previous works, we need not to compute over the entire node set . This provides more operational flexibility of the SR-nodes deployment.

Given an SR-node list for request and the notations and . Define the SR-function as

Therefore, calculates the flow on link if a unit flow is routed from to through SR-node list . It is predetermined by the network topology, link weights and intra-segment routing policy including but not limited to the shortest path policy. Note that if the equal-cost multipath (ECMP) routing is employed, then can be fractional and that if there is a link traversed more than once, can be larger than one. Thus, the path, referred to as SR-path, is a generic path rather than a simple path. In the following sections we will see that the SR-path constitutes the meta-structure of the proposed algorithms. The examples in the next section illustrate how traffic will be split across the SR-path.

It is not hard to see that adjacency segments [6, 3] can also be supported in the -SR mode as well as the proposed algorithms in the following sections. For instance, suppose link is an adjacency segment, we only need to make a simple assignment . For clarity and without loss of generality, we focus on the node segments in this paper.

Iii-B Illustrative Examples

Example 1: The close-to-optimal performance of the 2-SR setting, when being applied to real networks, has been claimed in many literature, e.g. [8, 10, 22]. In [22], an unrealistic topology is constructed to validate this point. Here we give another counter example to illustrate the inefficiency of 2-SR, see Fig. 1. The topology we used here, however, can be seen as a highly abstract multi-domain network structure. Suppose all links have identical capacities 100 and weights 1. Under the 2-SR setting, the maximum throughput from to is 100 even though all nodes in blue color are selected as candidate SR-nodes. This is due to the fact that some paths, e.g., , cannot be utilized. In the 3-SR setting, however, this path can be activated if and are chosen as SR-nodes. Similarly, all paths from to become available in this setting, thereby achieving the maximum thoughput 300. This type of topology is quite common in the case of inter-domain routing. The severe inefficiency shown in this example originates from the misalignment of link weights setting and the objective of throughput maximization. To tackle this issue, we should steer traffic to non-shortest paths using link-state based routing protocols, just as the well known DEFT [24], PEFT [25], and the method in [3].

Another point we want to emphasize is that the flexibility and resultant complexity of intra- and inter-segment routing can be converted into each other. More exactly, the maximum throughput can also be achieved using only as the SR-node by appropriately setting the values of and . The theoretical analysis to this convertion is still an open challenge.

Fig. 1: Inefficiency of 2-SR (Example 1). All links have identical capacities 100 and weights 1.

Example 2: In Fig. 2, we want to send a unit flow from to and there is only one SR-node . Suppose all the links have unlimited capacities and identical IGP weights 1. According to the shortest path policy, only the paths (also links) and are utilized. If the weights of links and are raised to 3, the ECMP policy could be activited. If their weights are further raised to 5, only the paths and can be utilized. In other words, in such case, no matter how inter-segment routing is optimized, links and can never be used. To solve this problem, we only need to introduce the adjacency segments and , i.e. setting and .

we emphasize again that in this paper we leave the intra-segment routing as an input parameter in the -SR framework and focus on the inter-segment routing optimization.

Fig. 2: Intra-segment routing (Example 2). There is only one SR-node .

Iv Offline Network Throughput Maximization

In the offline network throughput maximization problem, we know all the routing requests in advance. The objective is to simultaneously maximize the throughput of all the requests. We first present the offline formulation and thereby develop an approximation algorithm.

Iv-a Problem Formulation

Based on the maximum concurrent flow problem [26], the offline problem can be formulated as the following LP.

s.t. (1)
(2)

Similar to a typical MCF formulation, constraints (1) and (2) imply the flow conservation and capacity limitation, respectively. By associating a length with each link and a weight with each request , we can write the dual to the above LP as:

s.t. (3)
(4)

Using the definitions of , an alternate way to write the dual constraint is

In the worst case, the SR-node list can be as long as and each position of can be empty or occupied by any SR-node. Thus, the number of variables in can be at most . As far as we know, no tractable general-purpose LP solver can be directly applied to so large a problem.

Iv-B Approximation Algorithm

We design an FPTAS to solve the problem [26, 9]. The FPTAS is a primal-dual algorithm which includes an outer loop of a primal-dual update and an inner loop of min-cost SR-path computation.

The algorithm to solve the problem starts by assigning a precomputed length of to all links .

The algorithm proceeds in phases. In each phase, we route units of flow from node to , for each request . A phase ends when all requests are routed.

The flow of value of request is routed from to in multiple iterations as follows. In each iteration, a min-cost SR-path from to that minimizes the left-hand side of constraint (3) under current link lengths is computed.

The path is computated in Section VI. The bottleneck of this path, i.e. the maximum amount of flow that can be sent along this path, is given by

The amount of flow sent along this path in a step, denoted by , is also bounded by the remaining amount of flow for , denoted by , i.e.:

After the flow of value is sent through the SR-node list , the flow value and the link length at each link along the path are updated as follows:

1) Update the flow values as

2) Update the link lengths as

The update happens after each iteration associated with routing a portion of flow . The algorithm terminates when the dual objective function value becomes less than one.

When the algorithm terminates, dual feasibility constraints will be satisfied. However, link capacity constraint (2) in the primal solution will be violated, since we were working with the original (not the residual) link capacities at each stage. To remedy this, we scale down the traffic at each link uniformly so that the link capacity constraints are satisfied.

  Input: ; ;
  Initialize via the IGP routing policy using primal link weight system.
  while  do
     for  do
        
        Invoke Auxiliary Graph Construction.
        while  do
           Invoke Mincost Computation Module to compute the optimal SR-node list , and denote as the optimal SR-path.
           
           
           
           for  do
              
              
           end for
        end while
     end for
     
     
  end while
  
  
  Output: ;
Algorithm 1 FPTAS for -SR Model

Theorem 1: For any specified , Algorithm 1 computes a -approximation solution. If the algorithmic parameters are and , the running time is , where is the time required to compute a min-cost SR-path.

Proof: See Appendix. ∎

V Online Network Throughput Maximization

In the online network throughput maximization problem, the routing requests arrive one by one without the knowledge of future arrivals. The objective is to accept as many requests as possible. We first present the online formulation and thereby develop an online primal-dual algorithm.

V-a Problem Formulation

Based on the maximum multicommodity flow problem [26], the online problem can be formulated as the following ILP.

s.t. (5)
(6)

Similar to the offline formulation, constraints (5) and (6) imply the flow conservation and capacity limitation, respectively. We then consider the LP relaxation of this problem where is relaxed to . Note that is already implied by constraint (5). By associating a length with each link and a weight with each request , we can write the dual to the above LP as:

s.t. (7)
  Input:
  while Upon the arrival of request  do
     Invoke Auxiliary Graph Construction.
     Invoke Mincost Computation Module to compute the optimal SR-node list and , and denote as the optimal SR-path.
     if  then
        Reject ;
     else
        Accept ;
        
        
        for  do
           ,
           where and .
        end for
     end if
  end while
  Output:
Algorithm 2 Online Algorithm for -SR Model

V-B Online Algorithm

We design an online primal-dual algorithm which includes an outer loop of a primal-dual update and an inner loop of min-cost SR-path computation.

The algorithm to solve the problem starts by assigning a precomputed length of zero to all links.

The algorithm proceeds in iterations and each iteration corresponds to a request. Upon the arrival of a new request , we try to route units of flow from node to , for each request .

In each iteration, a min-cost SR-path from to that maximizes the right-hand side of constraint (7) under current link lengths computed according to Section VI.

If the min-cost value is larger than one, the request is rejected. Otherwise, the request is accepted, and the entire flow of request is routed along the min-cost SR-path.

After the flow is sent, the flow value and the link length at each link along the path are updated as follows:

1) Update the flow value as

which implies according to constraint (5).

2) Update the link lengths as

Parameter is designed to provide a tradeoff between the competitiveness of the proposed online algorithm and the degree of violating the capacity constraint in the primal problem. That is, a smaller leads to larger network throughput as well as a larger degree of violation on the link capacity [17].

Theorem 2: Algorithm 2 is an all-or-nothing, non-preemptive, monotone, and -competitive, more specifically -competitive, online algorithm. In other words, the routing flow is -competitive and it violates the link capacity constraints by .

Proof: See Appendix. ∎

Vi Min-Cost SR-Path Computation

The key steps in the FPTAS and the online algorithm all involve the computation of the min-cost SR-path for a request where the length of a link is the dual variable .

In order to accelerate the FPTAS, the auxiliary graph construction and the link lengths update are organized into independent algorithms auxiliary graph construction and mincost computation module, respectively. In the FPTAS, the auxiliary graph construction needs to be executed only once in each iteration while the mincost computation module should be executed in every step. However, it makes no difference for the online algorithm whether the two algorithms are independent because both of them are executed once in every iteration.

In the auxiliary graph construction, denote the auxiliary graph by . There are two end nodes corresponding to and for the current request , and layers of SR-nodes . There are links connecting to all the SR-nodes in the first layer, from each SR-node in the first layer to each SR-node in the second layer, etc, This process is repeated until all SR-nodes of the last layer are connected to , as shown in Fig. 3. The node set composed of all the possibly involved SR-nodes for a given request is called the Middlebox Fabric (MF).

Fig. 3: Auxiliary graph for request .

In the mincost computation module, the main processes are as follows:

1) Execute an all-pair-flow-splitting-cost (APFSC) computation to get the total costs between all node pairs. In particular, if the shortest path routing is employed in , the APFSC computation reduces to an all-pair-shortest-path computation. This, of course, can simplify the implementaiton and accelerate the algorithm. We are interested in the paths and corresponding SR-nodes that are relevant for request .

2) Update the link lengths of to the total cost between the two nodes the link connects.

3) Compute the shortest path in the auxiliary graph between and . This determines the optimal segment list (SR-node list) .

  Input: ; ; ;
  Construct an auxiliary graph for request .
  Output:
Algorithm 3 Auxiliary Graph Construction
  Input: ;
  Calculate the APFSC under the dual link length system :
   
  Update link lengths for :
   
  Compute the shortest path from to in under the link length system .
  The length of the shortest path is:
   
  The optimal SR-node list is:
   
  (Note that the shortest path in is exactly the min-cost SR-path in for request .)
  Output: ; ;
Algorithm 4 Mincost Computation Module

Although the MF in Fig. 3 looks similar to that in [15], the computation of end-to-end paths is entirely different. For the algorithm in [15], only the dual link weights are used to perform an all-pair shortest path computation in each iteration. For our algorithms, the primal link weights are used to generate physical routing paths while the dual link lengths to guide flow allocation on the generated paths.

In practice, for the network operator, the MF in Fig. 3 can be automatically or even manually adapted to specific network topologies to steer the flow on a more desirable routing path while greatly reducing resource overheads.

Vii Simulation Results

Vii-a Simulation Settings

We use two typical networks to evaluate the proposed solutions. In the Abilene network shown in Fig. (a)a, all the 30 links are bidirectional and have equal capacities 100. In the -SR network shown in Fig. (b)b, without loss of generality, we make all the 36 links unidirectional from node 1 to 21. The simulation settings are summarized in Table II

. The volume is an rough estimation to the whole network capacity and is calculated as the sum of all the link capacities.

(a)
(b)
Fig. 4: Simulation networks. (a) Abilene network, 12 nodes and 30 links. Blackbox test. (b) -SR network, 21 nodes and 36 links. Whitebox test.

-1.0in-1.0in

TABLE II: Simulation Settings
Strategy Capacity Volume FPTAS Online algorithm
Abilene network 100 12 random node pairs; =20 100 random requests; =5
-SR network 100 1 node pair; =100 100 requests; =5
(a)
(b)
Fig. 5: FPTAS. and normalized computation time versus . . (a) Abilene network. (b) -SR network.
(a)
(b)
Fig. 6: FPTAS. and normalized computation time versus . (a) Abilene network. . (b) -SR network. .

The experiments on the Abilene network can be seen as blackbox tests. It shows the overall performance in realistic networks, especially the Internet backbone. The experiments on the -SR network can be seen as whitebox tests. The reasons why we devise such a network are two-fold. First, it essencially reflects the hierarchical characteristics of current multi-domain Internet [20, 19]. Specifically, this network simulates a real inter-domain network. There exist multiple available paths between a node pair within a domain and different domains are connected by edge devices which may be performance bottlenecks. Second, the optimal throughput of Q-SR is hard to obtained by conventional methods. For instance, it is nearly impossible to compute a 5-SR setting using a general LP solver even for a network with such size, while we can easily make an estimation from this highly structured topology. In this way, the traffic distribution becomes tractable and we are able to evaluate to what extent the proposed algorithms can approximate the optimum.

In the following, we conduct the simulations from two perspectives. From the algorithimic perspective, we want to validate and analyze the effects of parameters and . From the SR perspective, since we have already parameterized the SR-node number, the segment number and the multipath policy for intra-segment routing in our model, we will not validate all of the parameters or variables in this paper due to space limitation. Instead, we are more interesting in whether would virtually influence the routing performance and resource consumption. This is because lots of literature claim that it is unprofitable to set in real networks.

Generally speaking, a larger (and hence ) will lead to a larger thoughput while accompanied by heavier computation overheads in the offline setting and severer bandwidth constraints violations in the online setting. How to achieve a trade-off is closely relevant to the network topology and thus is not the focus of this paper. Since we aim to highlight the computation efficiency of the proposed algorithms, we let unless otherwise specified.

To evaluate the FPTAS, for the Abilene network, each of the 12 nodes randomly selects another node to send a request with size ; for the -SR network, all the requests aggregate to one request from node 1 to 21 with size .

To evaluate the online algorithm, we randomly generate 100 requests with equal size . These requests enter the network one by one in a non-preemptive manner. That is, once a request enters the network, it will stay for ever. For the Abilene network, the traffic spreads across amost the whole network. For the -SR network, the traffic is injected into the network at node 1 and is finally absorbed at node 21.

Vii-B Fptas

In this section, we validate the parameters and in terms of the routing performance metric and the computation cost metric. The normalized computation time is defined as the ratio of real computation time to the real computation time when (a commonly used setting in literature). More precisely, the algorithms execute within a few seconds for all the instances considered in our simulation.

Fig. 5 shows how influences the throughput as well as the computation overheads. For the Abilene network, the throughput reaches the optimum when and further increasing of does not bring any improvent. For the -SR network, the throughput gradually increases with until it reaches the maximum 4.53 when . It can be easily seen from Fig. (b)b that the theoretical optimal throughput is when . All the 5 parallel paths, e.g. (1,2,6,7,11,12,16,17,21), from node 1 to 21 are fully utilized. On the other hand, the optimum can only be achieved when , more exactly . In fact, our algorithms can even support a rapid computation for a very large , say , with only small additional overheads than the that just reaches the optimum.

Considering that the Abilene network can reach a satisfactory throughput when while is the best setting for the -SR network, we use these settings of for the validation of and .

Notably, the computation overheads also concern with the topologies. The computation time increases almost simultaneously with the throughput in the -SR network, while there is only a slow increasing in the Abilene network.

Fig. 6 shows that the effects of are quite similar in the two networks. When becomes smaller, grows linearly while the computation time grows exponentially. Obviously, is a good choice to reach a tradeoff between routing performance and computation cost. For the -SR network, the setting leads to a throughput when , which is fairly close to the optimum .

(a)
(b)
Fig. 7: Online algorithm. Acceptance ratio and violation ratio versus . . (a) Abilene network. (b) -SR network.
(a)
(b)
Fig. 8: Online algorithm. Acceptance ratio and violation ratio versus . (a) Abilene network. . (b) -SR network. .

Vii-C Online Algorithm

In this section, we validate the parameters and in terms of the routing performance metric acceptance ratio and the resource cost metric violation ratio. The acceptance ratio is defined as the ratio of accepted number of requests to the total request number. The violation ratio is defined as the maximum ratio of the real flow amount on a link to its capacity over all links.

Similar to the offline scenario, as seen from Fig. 7, has significant influences on the routing performance as well as the resource consumption. However, unlike the offline scenario, approaching the optimum needs an even larger in the online setting. For the Abilene network, the acceptance ratio reaches the optimum when . For the -SR network, the acceptance ratio gradually increases with until reaches the optimum when .

As for the violation ratio, the two networks have a similar trend. The violation ratio gradually increases and reaches almost stable when surpasses some value.

As shown in Fig. 8, the effects of are also quite similar in the two networks. When becomes smaller, grows linearly while the computation time grows exponentially.

Similar to the effects of imposed on the FPTAS, there is also a trade-off between routing performance and resource consumption when choosing an appropriate . It is virtually meaningless to compare the performance between the two neworks, because the acceptance ratio can be raised by reducing the request sizes or enlarging the link capacities.

Viii Discussion

The proposed -SR framework is flexible enough to be extended in the following ways.

Segment multicast: The proposed framework as a whole can be extended to a novel routing paradigm segment multicast. By doing this, the SR-path becomes a pseudo directed steiner tree [18]. Since the computation of a directed steiner tree is NP-hard, we can invoke an approximation algorithm in the min-cost SR-path computation model. Of course, this may introduce some implementation issues and protocol overheads on encoding a multicast tree to packet header in a source routing manner.

Intra-segment routing: The intra-segment routing should be fully investigated, including link weights setting and intra-segment routing policy [7]. For instance, the intra-segment routing module can be replaced with other link-state routing policies or even a centralized min-cost MCF routing module. In the current SR architecture, the intra-segment routing is fixed and the only optimization space left lies in the inter-segment routing.

SR-node selection and placement: The topology-adaptive and traffic-aware SR-node selection and placement methods should be further considered. Specifically, each layer of SR-nodes in the MF structure shown in Fig. 3 can be independently specified for each request. In the worst case, e.g. the -SR network, only if all the intermediate nodes are employed will the throughput be maximized. Therefore, how to improve the routing performance while keeping as small overall costs as possible is also a major challenge.

Combining with SFC: How to combine the research methods and results of SR and SFC, just as indicated in Section II, has both theory value and practical significance. From the standpoint of network operator, for instance, there is a strong need to incorporate a realistic SR-node cost model to the framework, while this may have been well solved in the context of SFC [17, 18].

Ix Conclusion

In this paper, we propose a flexible -SR model and its formulation where segment number, SR-node number, intra-segment routing policy are all parameterized. The model leads to a highly extensible framework to design and evaluate algorithms that can be adapted to various network topologies and traffic matrices. For both offline and online settings, we develop primal-dual algorithms with provable worst case performance bounds. The advantage of computation efficiency of the algorithms over existing methods is so great that it enables quantitative evaluation of various SR parameters and algorithmic parameters on various types of network topologies.

Appendix

Ix-a Proofs for Algorithm 1

Lemma 1: When the FPTAS terminates, the primal solution needs to be scaled by a factor of at most to ensure primal feasibility (i.e., satisfying link capacity constraints).

Proof: Serialize all the steps of all the iterations of all the phases into steps. Define the flow scaling factor of link as:

According to the update rule of , we have:

Using the Taylor Formula, the inequality holds. Setting and , we have:

Hence, the lemma is proven.

Lemma 2: At the end of phases in the FPTAS, we have

Proof: Define

Define

We now sum over all iterations during phase to obtain:

Since , we have:

Using the initial value , we have for

The last step uses the assumption that . The procedure stops at the first phase for which

which implies that

Proof of Theorem 1: The analysis of the algorithm proceeds similar to [26].

1) Approximation ratio: Let represent the ratio of the dual to the primal solution. Then we have

Substituting the bound on from Lemma 2, we have

Setting leads to .

Equating the desired approximation factor to this ratio and solving for , we get the value of stated in the theorem.

2) Running time: Using weak-duality from linear programming theory, we have

Then the number of phases is upper bounded by

Note that the number of phases derived above is under the assumption . The case can be recast as by scaling the link capacities and/or request sizes using the same technique in Section 5.3 of [26]. Then, the number of phases is at most . We omit the details here.

Since each link length has an initial value of and a final length less than , the number of steps exceeds the number of iterations by at most . Considering that each phase contains iterations, the total number of steps is at most

Multiplying the above expression by , i.e. the running time of each step, proves the theorem. ∎

Ix-B Proofs for Algorithm 2

Proof of Theorem 2: The online algorithm is by nature an approximation algorithm, and the performance guarantee can be proved in three steps as in [8].

1) Dual feasibility: We first show that the dual variables and generated in each step by the algorithm are feasible.

Let denote the intermediate node that minimizes .

Setting makes hold for all SR-node lists. The subsequent increase in will always maintain the inequality since does not change.

2) Competitive ratio: First, we give an upper bound of . Suppose there are paths from node to and the flow amount on path is , then

Denote by the number of links of path , then

Thus, the SR-function for request is

During the step where request is accepted, the increase in the primal function is:

and the increase in the dual function is:

Therefore, the competitive ratio can be calculated as:

3) Primal feasibility: We now show that the solution is almost primal feasible.

Denote the link price after request has been accepted and processed by , and the utilization of link as

First, we prove an lower bound of :

We use the induction method. According to the update rule of , we have:

The last inequality follows from:

and

Second, we prove an upper bound of :

Denote . After request is accepted, the min-cost value . Then:

According to the update rule of and , we have:

Combining the lower bound and the upper bound, we have:

References

  • [1] Z. N. Abdullah, I. Ahmady and I. Hussain, “Segment routing in software defined networks: A survey,” IEEE Communications Surveys & Tutorials, vol. 21, no.1, pp. 464–486, 2018.
  • [2] P. L. Ventre, S. Salsano, M. Polverini, et al., “Segment routing: A comprehensive survey of research activities, standardization efforts and implementation results,” IEEE Communications Surveys & Tutorials, 2020.
  • [3] V. Pereira, M. Rocha, and P. Sousa, “Traffic Engineering with Three-Segments Routing,” IEEE Transactions on Network and Service Management, 2020.
  • [4] Y. Wang, X, Zhang, L. Fan, et al., “Segment Routing Optimization for VNF Chaining,” in Proc. IEEE ICC, 2017, pp. 1–7.
  • [5] X. Li and K. L. Yeung, “Traffic Engineering in Segment Routing Networks Using MILP,” IEEE Transactions on Network and Service Management, vol. 17, no. 3, pp. 1941–1953, 2020.
  • [6] M. Jadin, F. Aubry, P. Schaus, et al., “CG4SR: Near optimal traffic engineering for segment routing with column generation,” in Proc. IEEE INFOCOM, 2019, pp. 1333–1341.
  • [7] G. Trimponias, Y. Xiao, X. Wu, et al., “Node-constrained traffic engineering: Theory and applications,” IEEE/ACM Transactions on Networking, vol. 27, no.4, pp. 1344–1358, 2019.
  • [8] R. Bhatia, F, Hao, M. Kodialam, et al., “Optimized network traffic engineering using segment routing,” in Proc. IEEE INFOCOM, 2015, pp. 657-665.
  • [9] F, Hao, M. Kodialam, and T.V. Lakshman, “Optimizing restoration with segment routing,” in Proc. IEEE INFOCOM, 2016, pp. 1–9.
  • [10] T. Settawatchatcharawanit, Y. H. Chiang, V. Suppakitpaisarn, et al., “A computation-efficient approach for segment routing traffic engineering.” IEEE Access, vol. 7, pp. 160408–160417, 2019.
  • [11] F. Spinelli, L. Iannone, and J. Tollet, “Chaining your virtual private clouds with segment routing,” in Proc. IEEE INFOCOM WKSHPS, pp. 1027–1028, Apr. 2019.
  • [12] A. Cianfrani, M. Listanti, and M. Polverini, “Incremental deployment of segment routing into an ISP network: A traffic engineering perspective,” IEEE/ACM Transactions on Networking , vol. 25, no. 5, pp. 3146–3160, Aug, 2017.
  • [13] T. H. Chi, C. H. Lin, J.J. Kuo, et al., “Live video multicast for dynamic users via segment routing in 5G networks,” in Proc. IEEE GLOBECOM, 2018, pp. 1–7.
  • [14] F. Hao, M. Kodialam, and T. V. Lakshman, “Optimizing restoration with segment routing,” in Proc. IEEE INFOCOM, 2016, pp. 1–9.
  • [15] Z. Cao, M. Kodialam, and T. V. Lakshman, “Traffic steering in software defined networks: Planning and online routing,” In Proc. ACM SIGCOMM, 2014, pp. 65–70.
  • [16] M. Charikar, Y. Naamad, J. Rexford, et al., “Multi-commodity flow with in-network processing,” In International Symposium on Algorithmic Aspects of Cloud Computing, 2018, pp. 73–101.
  • [17] Z. Xu, W. Liang, A. Galis, et al., “Throughput optimization for admitting NFV-enabled requests in cloud networks,” Computer Networks, vol. 143, pp. 15–29, 2018.
  • [18] Y. Ma, W. Liang, J. Wu, et al., “Throughput maximization of NFV-enabled multicasting in mobile edge cloud networks,” IEEE Transactions on Parallel and Distributed Systems, vol. 31, no. 2, pp. 393–407, 2019.
  • [19] A. Giorgetti, A. Sgambelluri, F. Paolucci, et al., “Segment routing for effective recovery and multi-domain traffic engineering,” Journal of Optical Communications and Networking, vol. 9, no. 2, pp. A223–A232, 2017.
  • [20] D. Dietrich, A. Abujoda, A. Rizk, et al., “Multi-provider service chain embedding with Nestor,” IEEE Transactions on Network and Service Management, vol. 14, no. 1, pp. 91–105, 2017.
  • [21] E. Moreno, A. Beghelli, and F. Cugini, “Traffic engineering in segment routing networks,” Computer Networks, vol. 114, pp. 23–31, 2017.
  • [22] T. Schüller, N. Aschenbruck, M. Chimani, et al., “Traffic engineering using segment routing and considering requirements of a carrier IP network,” IEEE/ACM Transactions on Networking, vol. 26, no. 4, pp. 1851–1864, 2018.
  • [23] T. Schüller, N. Aschenbruck, M. Chimani, et al., “Failure Resiliency With Only a Few Tunnels-Enabling Segment Routing for Traffic Engineering,” IEEE/ACM Transactions on Networking. 2020.
  • [24] D. Xu, M. Chiang, and J. Rexford, “Deft: Distributed exponentially-weighted flow splitting,” in Proc. IEEE INFOCOM, 2007, pp. 71–79.
  • [25] D. Xu, M. Chiang, and J. Rexford, “Link-state routing with hop-by-hop forwarding can achieve optimal traffic engineering,” IEEE/ACM Transactions on Networking, vol. 19, no. 6, pp. 1717–1730, 2011.
  • [26] N. Garg and J. Koenemann, “Faster and simpler algorithms for multicommodity flow and other fractional packing problems,” SIAM Journal on Computing, vol. 37, no. 2, pp. 630–652, 2007.