Length-Bounded Paths Interdiction in Continuous Domain for Network Performance Assessment
11 Length-Bounded Paths Interdiction in ContinuousDomain for Network Performance Assessment
Lan N. Nguyen and My T. Thai
Abstract —Studying on networked systems, in which a com-munication between nodes is functional if their distance under agiven metric is lower than a pre-defined threshold, has receivedsignificant attention recently. In this work, we propose a metricto measure network resilience on guaranteeing the pre-definedperformance constraint. This metric is investigated under an opti-mization problem, namely Length-bounded Paths Interdiction inContinuous Domain ( cLPI ), which aims to identify a minimumset of nodes whose changes cause routing paths between nodesbecome undesirable for the network service.We show the problem is NP-hard and propose a frameworkby designing two oracles,
Threshold Blocking ( TB ) and CriticalPath Listing ( CPL ), which communicate back and forth toconstruct a feasible solution to cLPI with theoretical bicriteriaapproximation guarantees. Based on this framework, we proposetwo solutions for each oracle. Each combination of one solutionto TB and one solution to CPL gives us a solution to cLPI .The bicriteria guarantee of our algorithms allows us to controlthe solutions’s trade-off between the returned size and theperformance accuracy. New insights into the advantages of eachsolution are further discussed via experimental analysis.
I. I
NTRODUCTION
Components of a network do not have the same importantlevel. There always exists a set of nodes or edges whichplays more critical role than the others on assessing net-works’ performance. Literature has spent a significant efforton identifying such a set whose removal maximally damagesa network’s functionality. Most of early efforts used theconnectivity metric, in which a connection between two nodesis functional if there exists a path connecting them [1], [2],[3], [4], [5], [6]. However, as modern networks evolved, purelyrelying on connectivity is no long sufficient to guarantee anetworks’ functionality or quality of services. Further, insteadof removing nodes/edges, a change on components’ behaviorcan downgrade the whole system’s performance. For exam-ple, a congestion or traffic jams [7], [8] on some routerscan significantly delay communication between end systems,downgrading their quality of services.Motivated by the above observations, recent researchesturn their attention to network malfunction without damagingthe connectivity. For example, Kuhnle et al. [9] studied the
LB-MULTICUT problem, which aims for a minimum set ofedges whose removal causes the shortest distance, in termof edge weights, between targeted pairs of nodes exceed athreshold. The threshold represents constraints for the net-works in order to guarantee quality of services. By discarding
Lan N. Nguyen and My T. Thai are with the Department of Computer andInformation Science and Engineering, University of Florida, Gainesville, FL32611 USA (email: lan.nguyen@ufl.edu, [email protected]fl.edu). the “removal” flavour, Nguyen et al. [10] extended this conceptto introduce the
QoSD problem, in which an edge weight canbe varied with an amount of efforts, defined in the discretedomain, and the problem asks for a minimum amount of effortsfor the same objective as in
LB-MULTICUT .However, these existing works are all in the combinatorialoptimization, which do not capture well the continuous set-tings. For example, in network routing, factors that impactnetwork components’ latency or packet loss rate include:traffic rate [11], power of the interfering signal and noises [12],denial-of-service attacks [13]. Those factors are quantifiedunder continuous variables.Therefore, in this work, we take a further step on networkperformance assessment by introducing the cLPI problemas follows: Given a directed network G = ( V, E ) , a set S of target pairs of nodes and a threshold T , each node v ∈ V is associated with a monotone non-decreasing function f v : R ≥ → R ≥ , the cLPI problem asks for an impact vector x = { x v } v ∈ V with minimum (cid:107) x (cid:107) such that any path p ,connecting a pair in S , satisfies (cid:80) v ∈ p f v ( x v ) ≥ T . Intuitively, x v represents the external impact’s level to node v ; while f v ( x v ) quantifies v ’s behaviors in response to the impact. T represents the network constraint in order to guarantee qualityof services, e.g. low latency. A solution x of cLPI can be usedto assess network resilience to the external impact. Specifi-cally, large (cid:107) x (cid:107) indicates the network is resilient to externalinterference and able to maintain quality of service underextreme environment. Furthermore, a value of x v indicates theimportant level of node v to the network desired functionality.Solving cLPI with bounded performance guarantee ischallenging, indeed. If for all path p , (cid:80) v ∈ p f v ( x v ) ≥ T exhibits convexity, then cLPI can be solved optimally byusing ellipsoid method [14] with a polynomial feasible-checkoracle. However, that is not always the case. Studies onnetwork latency w.r.t impact factor like traffic rate shows (cid:80) v ∈ p f v ( x v ) ≥ T is not convex [13], [15]. That also rulesout the possibility of applying any other Convex Optimizationtechnique. In term of packet loss rate, the behaviors are evenmore complicated [12]. Indeed, we show that cLPI withgeneral functions are NP-hard problem. Thus, in this work, weaim for a general solution that can applied on any monotonenon-decreasing functions f v . Contributions.
In addition to introduce the cLPI problem,the main contributions of this work are: • We propose a general framework for solving cLPI ,separating tasks into two different oracles, called
CriticalPaths Listing ( CPL ) and
Threshold Blocking ( TB ). CPL ’sjob is to restrict the amount of paths considered for a r X i v : . [ c s . D S ] S e p finding a feasible solution of cLPI . TB handles the taskof finding x , guaranteeing all paths, returned by CPL ,having lengths exceeded T . For each oracle, we designtwo algorithmic solutions. Different combination of any CPL and TB algorithms provides different performancetheoretically and practically. • All of our solutions have bicriteria approximation ratios,which could allow a user to control the trade-off betweenruntime versus accuracy. • We extensively evaluate our solutions on real-world ASnetworks. The experiments show our algorithms outper-forms existing solutions of special problems of cLPI in solution quality. We then shed a new insight onadvantages of each algorithms.
Organization . The rest of the paper is organized as fol-lows. Section II reviews literature related to our problem. InSection III, we formally define the cLPI problem, discussits challenges and overall framework of our solutions. SectionIV presents two algorithms for the TB oracle while the onesfor CPL are described in Section V. In Section VI, practicalanalysis on algorithms’ performance is provided. Finally,Section VII concludes the paper.II. A
PPLICATION AND R ELATED W ORK
We first discuss a key application of cLPI in networkperformance assessment and next highlight the most relevantrelated work to cLPI . A. cLPI in network performance assessment A routing protocol specifies how routers communicate witheach other to distribute information that enables them to selectroutes between any two nodes on a computer network [16],[17], [18]. The specific characteristics of routing protocolsinclude the manner in which they avoid routing loops andselect preferred routes, using information about hop costs.With the introduction of Software-Defined-Networking [19],[20], a hop cost can vary from different metrics, serving fordifferent purposes of network administrators.The most common used metric for network vulnerability isnetwork latency. Ideally, communication between hosts in thenetwork is routed in the shortest path, weighted by latencyof nodes. On the other hand, to guarantee quality of services(e.g. low latency) or avoid unexpected routing scheme (e.g.inter-continent routing with intra-traffic), a limit on networklatency can be set so that the routing path has to have latencylower than a threshold. If there exists no routing path with totallatency lower than the threshold, the network is considered tobe undesirable for required services [9], [10].In the context of cLPI , to model the external impact toa hop latency, each node v (e.g routers) in the network isassociated with a function d v ( x ) where x quantifies the impact(e.g. traffic rate, noise); and d v ( x ) measure the latency of v with the impact x . Denote T as the latency threshold. Studying cLPI helps identify the impact levels on nodes/edges thatrequired to damage the networking quality of services, thusproviding a useful metric for network design and assessment. Beside latency, another routing metric can be used is packetloss probability. A routing path with high probability (say atleast ) of successful delivery is preferred. Unlike latency,in term of packet loss probability, a simple trick needs to beapplied. Let ρ v ( x ) denote the loss probability of a packet ifgoing through node v given the external impact amount x ;and P is the expected successful probability of a routing path.Then the network routing is not functional if for a routing path p , (cid:81) v ∈ p (1 − ρ v ( x )) ≤ P . This equation is adapted to cLPI as (cid:80) v ∈ p − ln(1 − ρ v ( x )) ≥ − ln P . B. Existing Algorithms
The early work on network resilience assessment with con-straints on distance between node pairs are
LB-MULTICUT ,[9], Critical Node Detection [21], [22], Multicut [1], [2]. Withthe objective to make all pairs’ distance to be at least T or bedisconnected, the problem asks for a minimum set of edgesor nodes to be removed. One way to apply their solutions to cLPI is by introducing a step of discretization of function f v .In the context of node removal, the cost of cutting a node v is represented by value x where f v ( x ) = T . Our experimentalresults, unfortunately, shows solving cLPI by this methodreturns undesirable solutions in some cases. Other than thatintuitive adoption, it is unclear how to convert the work ofedge/node removal to the flavour of increase edge/node weightas an instance of cLPI .Without targeting for the edge/node removal, the QoSD problem introduces a discrete function b v : Z ≥ → Z + associated with each node v of the network; and asks for a x in integer lattice that any path p connecting a given nodepairs has length exceeding T , i.e. (cid:80) v ∈ p b v ( x v ) ≥ T [10].One may think to discretize functions f v and directly adoptsolutions of QoSD to solve cLPI . However, the discretizationof f v is simply a work of taking an integer x and returningthe value f v ( x × δ ) , where δ is called discretizing step. If δ istoo large, the returned solution will be far from optimum dueto discretization error; otherwise small δ creates significantlylarge inputs for QoSD , causing a burden on memory usage andundesirable runtime. Therefore, a solution, which can directlyapplied into continuous domain, is more desired. cLPI can be modeled under a Constrained Optimiza-tion formulation that minimize (cid:80) v ∈ V x v with constraints (cid:80) v ∈ p f v ( x v ) ≥ T for all paths p connecting pairs and x v ≥ for all v ∈ V . The first constraint is to guarantee that all pathsconnecting target pairs have the length exceeding threshold T . Constrained Optimization is a classical problem, on whichsignificant amount of works have been investigated, including(but not limited to) [23], [24], [25]. However, a major concernof applying those solutions to cLPI is that a set of constraintsis required to be known beforehand. In the case of densenetwork, the set of constraints reach to (cid:80) nk =2 (cid:0) nk (cid:1) k ! paths andan “infinite” period only for enumerating them. Furthermore,even we can list all constraints, those methods meet anotherobstacle that edge weight functions could be any function withcomplex behaviors. Existing methods can easily end up tolocal convergence trap without any performance guarantee.Therefore, a solution, which helps reduce burden of path listing while providing a performance ratio, is more desirable.That is a focus of our work.III. P RELIMINARIES
A. Problem Formulation
In this part, we formally define the cLPI problem andnotations used frequently in our algorithms.We abstract the network using a directed graph G = ( V, E ) with | V | = n nodes and | E | = m directed edges. Each node v is associated with a function f v : R ≥ → R ≥ which indicatesthe weight (e.g. latency, loss rate) of v w.r.t an impact amounton v . In another word, if external impact of an amount of x is put on v , the weight of node v will become f v ( x ) . f v ismonotonically non-decreasing for all v ∈ V , which can beintuitively explained by: the more impact are put on v , theworse v behaves (e.g. long latency, high loss rate).Given V = { v , ...v n } , we denotes the impact in form of avector x = { x , ...x n } where x n is an impact on node v i . Forsimplicity, we use the notation v to present a node in V andits index in V also. So x v means the impact on node v , andthe entry in x corresponding to v also. The overall impact onall nodes, therefore, is (cid:107) x (cid:107) = (cid:80) v ∈ V x v .A path p = { u , u , ...u l } ∈ G is a sequence ofvertices such that ( u i − , u i ) ∈ E for i = 1 , .., l . Apath can also be understood as the sequence of edges { ( u , u ) , ( u , u ) , ... ( u l − , u l ) } . In this work, a path is usedinterchangeably as a sequence of edges or a sequence of nodes.Under an impact vector x , the length of a path p is denotedas d x ( p ) where d x ( p ) = min (cid:0) (cid:80) v ∈ p f v ( x v ) , T (cid:1) . The min term is to bound a path’s length by T . Since we only careabout paths of length at most T , this bound does not impactour algorithms’ results or the problem’s generality.We abuse the notation by also using d to denote distancebetween two nodes in the network. To be specific, d x ( u, v ) denotes distance between node u and v under x , i.e d x ( u, v ) =min p = { u,...,v } d x ( p ) .A single path is a path that there exists no node who appearsmore than once in the path. Let P i denote a set of simple pathsconnecting the pair ( s i , t i ) ∈ S such that (cid:80) v ∈ p f v (0) < T forall p ∈ P i . Let F = ∪ ki =1 P i , we call a path p ∈ F a feasiblepath and F is a set of all feasible paths in G . A non-feasiblepath either connects no pair in S or has an initial length exceed T . cLPI is formally defined as follows: Definition 1.
Length-bounded Paths Interdiction in Continu-ous Domain ( cLPI ). Given an undirected graph G = ( V, E ) ,a set f = { f v : R ≥ → R ≥ } of node weight functionsw.r.t impact on nodes and a target set of pairs of nodes S = { ( s , t ) , ... ( s k , t k ) } , determine an impact vector x witha minimum (cid:107) x (cid:107) such that d x ( s i , t i ) ≥ T for all ( s i , t i ) ∈ S . Let’s look at several mathematical operators on vectorspace R n , which are used along the theoretical proofs of ouralgorithms. Given x = { x , ...x n } , y = { y , ...y n } ∈ R n ,define: x + y = { x + y , ...x n + y n } x \ y = { max( x − y , , ... max( x n − y n , } Moreover, we say x ≤ y if x v ≤ y v for all v ∈ V , thesimilar rule is applied to <, ≥ , > . Theorem 1. cLPI is an NP-hard problemProof.
We reduce
QoSD to cLPI as follows: Given aninstance of the QoSD problem, including a directed graph G = ( V, E ) and a set of target pairs of nodes S , each node v isassociated with a monotone discrete functions b v : Z ≥ → Z + . QoSD asks for a minimum (cid:107) x (cid:107) that any path p connecting apair in S has length exceeding T , i.e. (cid:80) v ∈ p b v ( x v ) ≥ T .We create an instance of cLPI by keeping G, S, T anddefining the node weight functions { f v } v in continuous do-main by letting f v ( x ) = b v ( (cid:98) x (cid:99) ) for x ∈ R ≥ and ∀ v ∈ V . f v is monotone non-decreasing function in continuous domain.It is trivial that each entry x v of an optimal solution of this cLPI instance should be an integer (or else we can replace x v by (cid:98) x v (cid:99) and the cLPI ’s objective still go through). Since theoptimal solution of cLPI contains all integers, it is also anoptimal solution of QoSD . And vice versa, an optimal solutionof
QoSD is also an optimal solution of this cLPI instance.Thus, cLPI is at least as hard as
QoSD . And since
QoSD hasbeen proven to be NP-hard, cLPI is an NP-hard problem.
B. General model of our solutions
Properties of Performance Guarantees.
Given a probleminstance with a threshold T , denote OPT as an optimal solution.We call an impact vector x is ε -feasible to cLPI iff under x ,the distance between each target pair is at least T (1 − ε ) . Ouralgorithms are bicriteria approximation algorithms, returning a ε -feasible solution x whose overall impact is bounded within afactor O (ln |F| ε − ) of OPT . ε is treated as a trade-off betweenthe algorithms’ accuracy and returned (cid:107) x (cid:107) . To be specific,the smaller ε is, the closer pairs’ distances are to T but thelarger the returned solution is. ε is adjustable, allowing usersto control the trade-off as desired. General Framework.
Our solutions contain two separateoracles, called
Threshold Blocking ( TB ) and Critical PathsListing ( CPL ). These two oracles communicate back and forthwith each other to construct a solution to cLPI , given an inputinstance of cLPI and a parameter ε . These two oracles areproposed to tackle two challenges of cLPI as stated before,to be specific: • Threshold Blocking - a primary role of TB is to solvea sub-problem of cLPI : Given a target set P of singlepaths and an initial impact vector x , TB aims to find s of minimum (cid:107) s (cid:107) to x in order to make d x + s ( p ) ≥ T forall p ∈ P . For simplicity, we call this task TB problem. • Critical Paths Listing - this oracle restricts the number ofpaths to be considered in the algorithm, thus significantlyreducing the searching space and burdens on algorithms’runtime and memory for storage.We propose multiple algorithms for each oracle. Specifi-cally, we devise two algorithms for
CPL , which are
FeasibleSet Construction and
Incremental Interdiction . To solve TB ,we develop two algorithms, called Threshold Expansion and
Jump Start Greedy . Different combinations of
CPL and TB algorithms provide different performances theoretically andexperimentally.In general, the flow of our algorithms is:1) The algorithm starts with x v = 0 for all v ∈ V .2) Given the current state of x , by using a technique torestrict searching space, CPL oracle searches for a set ofcritical paths P , who are feasible paths and d x ( p ) < T for all p ∈ P .3) Then those paths along with a current state of x aregiven as an input for the TB oracle, which then finds anadditional budget s for x to make d x + s ( p ) ≥ T for all p ∈ P .4) The additional budget v is then used for CPL to checkthe feasibility. If adding s makes x ε -feasible, thealgorithm returns x + s and terminates. Otherwise, s is used to drive the searching space of CPL and find anew value for x ; then step (2) is repeated.IV. T HRESHOLD B LOCKING O RACLE
In this section, we present two algorithms for ThresholdBlocking ( TB ) Oracle, called Threshold Expansion ( TE ) and Jump Start Greedy ( JSG ).To recap, TB receives a set P of feasible paths from CPL , an impact vector x . The objective of TB is to find anadditional vector s = { s , ...s n } with minimum (cid:80) v s v suchthat d x + s ( p ) ≥ T for all p ∈ P .Denote s ∗ as an optimal solution, i.e. s ∗ = argmin s : d x + s ( p ) ≥ T ∀ p ∈P (cid:107) s (cid:107) The bicriteria guarantee of our algorithms originates from TB ’s algorithms. Say in another way, instead of finding anexact solution, the desired accuracy ε is given to the TB oracleso TB ’s algorithms find s such that d x + s ( p ) ≥ T (1 − ε ) forall p ∈ P .Denote (cid:104) v, x (cid:105) ∈ R n as a vector which receives value x atentry v and elsewhere.Given a path set P , a vector w and a node v , let: r P, w ,v ( x ) = (cid:88) p ∈ P (cid:0) d w + (cid:104) v,x (cid:105) ( p ) − d w ( p ) (cid:1) Intuitively, r P, w ,v ( x ) measures the total increasing lengths,under an impact vector w , of paths in P by adding an amount x to entry v of w . A. Threshold Expansion
In general, TE works in rounds and in each round, TE setup a requirement on an amount to be added in each node.The requirements are relaxed after each round in order toallow new amount to be added; and the algorithm stops whenguaranteeing the obtained solution s make d x + s ( p ) ≥ T (1 − ε ) for all p ∈ P .The requirement in each round of TE is in a form of a num-ber M , which is initiated to be a large number. An amount x to be added into v guarantees x = max { x > | r P , x + s ,v ( x ) x ≥ M } . Intuitively, the condition r P , x + s ,v ( x ) x ≥ M is to ensure theadditional amount is meaningful and significant in comparison Algorithm 1
Theshold Expansion
Input G, { f v } v , P , T, (cid:15), ε, x Output : s that d x + s ( p ) ≥ T (1 − ε ) for all p ∈ P s = { } v M = a large number. v ← the first node in E while P is not empty do ˆ x = max (cid:8) x ≥ | r P , x + s ,v ( x ) x ≥ M (cid:9) s = s + (cid:104) v, ˆ x (cid:105) Remove paths p that d x + s ( p ) ≥ T (1 − ε ) out of P if v is the last node in V then M = (1 − (cid:15) ) M v ← start over with the first node else v ← the next node. Return s with putting an impact on other nodes. Since there couldbe a wide range of x that can satisfy r P , x + s ,v ( x ) x ≥ M ,the algorithm targets for the maximum x because it helpsthe algorithm quickly reach to the feasible solution. After x is added to entry v , the algorithm discards paths p that d x + s ( p ) ≥ T (1 − ε ) out of P since those paths have fulfilledthe algorithm’s target.After considering adding impacts to all nodes with a con-straint in term of M , the algorithm reduces the value of M to be (1 − (cid:15) ) M with (cid:15) is a constant parameter inputtedto the algorithm. The reduction in M is to let new impactamounts be added into nodes. On the other hand, (cid:15) impactsthe performance of the algorithm. Intuitively, the lower valueof (cid:15) is, the better solution quality the algorithm can obtain butthe longer running-time for the algorithm to terminate. Thepseudocode of the algorithm is presented in Alg. 1. TE ’s theoretical performance is obtained with an assumptionthat: M - initiated at line 2 of Alg. 1 - satisfies: M ≥ r P , w ,v ( x ) x for all w ≥ x , v ∈ V and x ≥ (1)This assumption can be removed if f v s are differentiableeverywhere. In that case, we set M as the following lemma. Lemma 1. If f v s are differentiable everywhere, by setting M = |P| × max x ≥ ,v ∈ V,f v ( x ) ≤ T ∂f v ∂x the condition 1 is satisfied. Proof.
We have: r P , w ,v ( x ) x = (cid:88) p ∈P : v ∈ p d w + (cid:104) v,x (cid:105) ( p ) − d w ( p ) x ≤ |P| max p ∈P : v ∈ p d w + (cid:104) v,x (cid:105) ( p ) − d w ( p ) x ≤ |P| max x : f v ( x ) ≤ T f v ( x ) − f v ( w e ) x − w e ≤ |P| × max x ≥ ,v ∈ V,f v ( x ) ≤ T ∂f v ∂x which completes the proof.From now on, for simplicity, when we analyze the perfor-mance of TE at an iteration of the while loop of line 4 Alg.1, we refer M , s , P as their values at that iteration.Let’s consider at an iteration of line 4 Alg. 1, denote s o = { s ov } v = s ∗ \ s . We have the following lemma. Lemma 2. s ov = 0 or r P , x + s ,v ( s ov ) s ov < M − (cid:15) for all v ∈ V .Proof. This lemma is trivial at the time each node beingfirst observed because of the condition 1. Therefore, we onlyconsider at an arbitrary moment after M has been reduced byline 9.Assume there exists a node v such that s ov > and r P , x + s ,v ( s ov ) s ov ≥ M − (cid:15) . Consider the last time v is observed and ˆ x = max (cid:8) x ≥ | r P , x + s (cid:48) ,v ( x ) x ≥ M (cid:48) (cid:9) where s (cid:48) is s beforeadding ˆ x into v ; M (cid:48) = M if v was last observed in the currentround, otherwise M (cid:48) = M − (cid:15) .We have s ≥ s (cid:48) + (cid:104) v, ˆ x (cid:105) but s and s (cid:48) + (cid:104) v, ˆ x (cid:105) have the samevalue at entry v , thus for any p ∈ P that contains v : d x + s (cid:48) + (cid:104) v, ˆ x + s v (cid:105) ( p ) − d x + s (cid:48) + (cid:104) v, ˆ x (cid:105) ( p ) ≥ d x + s + (cid:104) v,s v (cid:105) ( p ) − d x + s ( p ) Therefore, r P , x + s (cid:48) + (cid:104) v, ˆ x (cid:105) ,v ( s ov ) ≥ r P , x + s ,v ( s ov ) ≥ s ov M − (cid:15) So: r P , x + s (cid:48) ,v (ˆ x + s ov ) = r P , x + s (cid:48) ,v (ˆ x ) + r P , x + s (cid:48) + (cid:104) v, ˆ x (cid:105) ,v ( s ov ) ≥ M (cid:48) (ˆ x + s ov ) Then an amount of at least ˆ x + s ov should be added into v ,which contradicts to assumption that ˆ x is the selected amount.Lemma 2 allows us to bound the performance guarantee of TE , which is shown in the following theorem. Theorem 2.
Given G, { f v } v , P , T, ε, x , if s is the additionalimpact vector returned by TE and s ∗ is the optimal vector tomake d x + s ∗ ( p ) ≥ T for all p ∈ P , then: (cid:107) s (cid:107) ≤ ln (cid:0) |P| ε − (cid:1) + 11 − (cid:15) (cid:107) s ∗ (cid:107) Proof.
Let us consider at an arbitrary iteration of the while loop at line 4, node v is being observed, and ˆ x is a selected amount to add into v but has not been added to s yet. Again,denote s o = { s ov } v = s ∗ \ s . Without lost of generality, let ˆ x > . From lemma. 2, we have: r P , x + s ,v (ˆ x )ˆ x ≥ (1 − (cid:15) ) r P , x + s ,v ( s ou ) s ou for all u ∈ V that s ou > .Denote h u = { s w + w>u s ow } w for all u ∈ V . As h u ≥ s but they have the same value at entry u , we have: r P , x + h u ,u ( s ou ) ≤ r P , x + s ,u ( s ou ) Therefore, (cid:88) p ∈P (cid:16) d x + s + s o ( p ) − d x + s ( p ) (cid:17) = (cid:88) u ∈ V r P , x + h u ,u ( s ou ) ≤ (cid:88) u ∈ V r P , x + s ,u ( s ou ) ≤ (cid:88) u ∈ V s ou ˆ x (1 − (cid:15) ) r P , x + s ,v (ˆ x ) ≤ (cid:107) s ∗ (cid:107) ˆ x (1 − (cid:15) ) r P , x + s ,v (ˆ x ) Since s + s o ≥ s ∗ , d x + s + s o ( p ) = T for all p ∈ P .Now, let’s assume the algorithm terminates after addingimpact amounts into nodes L times, denote ˆ x , ... ˆ x L as anadded amount at each times ( (cid:107) s (cid:107) = (cid:80) Lt =1 ˆ x t ). Also, denote s t , P t as s , P before adding ˆ x t at time t . We have: (cid:88) p ∈P t (cid:16) T − d x + s t ( p ) (cid:17) ≤ (cid:107) s ∗ (cid:107) ˆ x t (1 − (cid:15) ) (cid:88) p ∈P t (cid:16) d x + s t +1 ( p ) − d x + s t ( p ) (cid:17) A simple transformation and the fact that P t +1 ⊆ P t gives us: (cid:88) p ∈P t +1 (cid:16) T − d x + s t +1 ( p ) (cid:17) ≤ (cid:16) − ˆ x t (1 − (cid:15) ) (cid:107) s ∗ (cid:107) (cid:17) (cid:88) p ∈P t (cid:16) T − d x + s t ( p ) (cid:17) Therefore, (cid:88) p ∈P L − (cid:16) T − d x + s L − ( p ) (cid:17) ≤ (cid:88) p ∈P (cid:16) T − d x ( p ) (cid:17) L − (cid:89) t =1 (cid:16) − ˆ x t (1 − (cid:15) ) (cid:107) s ∗ (cid:107) (cid:17) ≤ |P| T (cid:16) − (cid:80) L − t ˆ x t (1 − (cid:15) ) (cid:107) s ∗ (cid:107) ( L − (cid:17) L − ≤ e − (cid:107) s L − (cid:107) (1 − (cid:15) ) (cid:107) s ∗(cid:107) |P| T On the other hand, (cid:80) p ∈P L − (cid:16) T − d x + s L − ( p ) (cid:17) ≥ T ε since d x + s L − ( p ) < T (1 − ε ) for all p ∈ P L − ; and P L − (cid:54) = ∅ .Therefore: (cid:107) s L − (cid:107) ≤ (cid:107) s ∗ (cid:107) ln (cid:16) |P| ε − (cid:17) − (cid:15) Now, let consider the final update, we have: ˆ x L ≤ (cid:107) s ∗ (cid:107) − (cid:15) (cid:80) p ∈P L − (cid:16) d x + s L ( p ) − d x + s L − ( p ) (cid:17)(cid:80) p ∈P L − (cid:16) T − d x + s L − ( p ) (cid:17) ≤ (cid:107) s ∗ (cid:107) − (cid:15) Algorithm 2
Jump Start Greedy
Input G, { f v } v , P , T, ε, x Output : s that d x + s ( p ) ≥ T (1 − ε ) for all p ∈ P s = { } v β = O ( (cid:107) s ∗ (cid:107) /n ) while P is not empty do for each v ∈ V do ˆ x v = max x r P , x + s ,v ( x ) x if ˆ x v = 0 (Jump Start) then ˆ x v = max x ≥ β r P , x + s ,v ( x ) x v = argmax v ∈ V r P , x + s ,v (ˆ x v )ˆ x v s = s + (cid:104) v, x v (cid:105) Remove paths p that d x + s ( p ) ≥ T (1 − ε ) out of P Return s Finally, we have (cid:107) s (cid:107) = (cid:107) s L − (cid:107) + ˆ x L ≤ (cid:107) s ∗ (cid:107) ln (cid:16) |P| ε − (cid:17) + 11 − (cid:15) which completes the proof. B. Jump Start Greedy
In general,
JSG works in a greedy manner that iterativelyadds an impact amount to a node which maximizes r P , x + s ,v ( x ) x .The problem is that there exists cases due to traits of thefunctions f v s, the selected budget is and the algorithm fallsinto infinite loops. We call such situation “zero trap”. JSG overcomes that challenge by introducing
Jump Start step toescape the zero trap while keeping a reasonable theoreticalperformance guarantee.
JSG runs in multiple iterations and for each iteration: • Step (1) , for each node v , the algorithm finds a budget ˆ x v that maximizes r P , x + s ,v (ˆ x v )ˆ x v . If ˆ x v = 0 (which typicallyhappens when f v is concave), we do the jump start byforcing the minimum amount added to v has to be atleast a value of β = O ( (cid:107) s ∗ (cid:107) /n ) (how we obtain thevalue of β will be described later). In that case, ˆ x e = argmax x ≥ β (cid:110) r P , x + s ,v ( x ) x (cid:111) . • Step (2) , the algorithm selects a node v that maximizes r P , x + s ,v (ˆ x v )ˆ x v and add ˆ x v into v . The algorithm repeats to step (1) until d x + s ( p ) ≥ T (1 − ε ) for all p ∈ P .The pseudo-code of JSG is presented in Alg. 2 and
JSG ’sperformance guarantee is stated in the following theorem.
Theorem 3.
Given G, { f v } v , P , T, ε, x given to the TB oracle.If v is the impact vector returned by JSG and v ∗ is the optimalvector make d x + s ∗ ( p ) ≥ T for all p ∈ P , then (cid:107) v (cid:107) ≤ O (cid:16) ln (cid:0) |P| ε − (cid:1)(cid:17) (cid:107) v ∗ (cid:107) Proof.
Let’s consider at a certain iteration of while loop (line3 Alg. 2), s is now under construction (not returned solution)and P is not empty. Again, denote s o = { s ov } v = s ∗ \ s and h u = { s w + w>u s ow } w . From the proof of Theorem 2, wehave that r P , x + h u ,u ( s ou ) ≤ r P , x + s ,u ( s ou ) and: (cid:88) p ∈P (cid:16) d x + s + s o ( p ) − d x + s ( p ) (cid:17) ≤ (cid:88) u ∈ V r P , x + s ,u ( s ou ) Due to monotonicity, r P , x + s ,u ( s ou ) ≤ r P , x + s ,u ( s ou + β ) . Weobserve that: Even a node v was forced to take jump start stepor not, the selected amount ˆ x v always satisfies r P , x + s ,v (ˆ x v )ˆ x v ≥ r P , x + s ,v ( x ) x for all x ≥ β . Thus, let’s assume v is the selectednode in this while iteration with the increasing impact amountof ˆ x v . Due to greedy selection, we have: (cid:88) u ∈ V r P , x + s ,u ( s ou ) ≤ (cid:88) u ∈ V s ov + β ˆ x v r P , x + s ,v ( s ov ) ≤ (cid:107) s ∗ (cid:107) + βn ˆ x v r P , x + s ,v ( s ov ) Now, let’s assume the algorithm terminates after addingimpact amounts into nodes L times, denote ˆ x , ... ˆ x L as anadded amount at each times ( (cid:107) s (cid:107) = (cid:80) Lt =1 ˆ x t ). Also, denote s t , P t as s , P before adding ˆ x t at time t . Using the sametransformation as in proof of TE , we obtain the resursionrelationship between s t , P t as follows: (cid:88) p ∈P t +1 (cid:16) T − d x + s t +1 ( p ) (cid:17) ≤ (cid:16) − ˆ x t (cid:107) s ∗ (cid:107) + βn (cid:17) (cid:88) p ∈P t (cid:16) T − d x + s t ( p ) (cid:17) Using the same technique as in TE to discarding the termsfrom round t = 1 to L − , we have (cid:107) s (cid:107) ≤ (cid:0) (cid:107) s ∗ (cid:107) + βn (cid:1) O (ln |P| ε − ) The theorem follows given the fact that β = O ( (cid:107) s ∗ (cid:107) /n ) .Now the only question left is how to identify β = O ( (cid:107) s ∗ (cid:107) /n ) . The trivial answer is β = 0 but that does nothelp on the jump start step. To find a more reasonable lowerbound of the optimal solution (cid:107) s ∗ (cid:107) , we have the followinglemma. Lemma 3.
Given a impact vector x such that there exists p ∈P , d x ( p ) < T , there exist σ > such that with w ( σ ) = { σ } v , d x + w ( σ ) ( p ) < T and (cid:107) s ∗ (cid:107) ≥ σ Proof.
The first statement is trivial, so we will focus on thesecond statement. We have d x + s ∗ ( p ) > d x + w ( σ ) ( p ) . Thusthere should exist at least one entry in s ∗ that is at least σ . So (cid:107) s ∗ (cid:107) ≥ σ , which completes the proof.As d x + w ( σ ) ( p ) is monotone increasing w.r.t σ , we usebinary search to find σ and set β = σn .V. C RITICAL P ATH L ISTING O RACLE
In this section, we present two algorithms for the
CPL oracle, which are
Incremental Interdiction ( II ) and FeasibleSet Interdiction ( FI ). CPL ’s role is to reduce searching spacewhen constructing the returned solution x . CPL works as a backbone for the overall process of finding x , in which itreceives cLPI ’s input, then communicates back and forthwith TB to construct x and returns x when x guarantees d x ( s, t ) ≥ T (1 − ε ) for all ( s, t ) ∈ S . Algorithm 3
Incremental Interdiction
Input G, { f e } e , T, ε, S, TB Output x x = { } while ∃ ( s, t ) ∈ S that d x ( s, t ) < T (1 − ε ) do P = ∅ for each pair ( s, t ) ∈ S that d x ( s, t ) < T (1 − ε ) do K = k shortest paths from s to t under x Remove paths p that d x ( p ) ≥ T (1 − ε ) out of K P = P ∪ K s = run TB oracle with input G, { f v } v , P , T, ε, x x = x + s Return x A. Incremental Interdiction
In general, this algorithm works in rounds; and in eachrounds, impact amounts are added into nodes to guarantee aset of feasible paths getting length exceeding T (1 − ε ) . A setof paths are different and disjoint in each round. And to makeall paths of that set have length exceed T (1 − ε ) , II callsthe TB oracle to find an additional impact vector to its currentvector x . The algorithm iterates until finding no feasible pathsof length less than T (1 − ε ) .A set of paths in each round contains k shortest pathsconnecting each pair of S under its current impact vector x . k is a constant parameter inputted for the algorithm. Intuitively, k is desired to be neither too large or too small. Large k bring burdens on running time to find those shortest pathsand memory to store them. On the other hand, small k doesnot bring sufficient exposures for critical nodes, who appearfrequently on paths connecting pairs in S and are the ones thealgorithm should target to put impact on. The pseudocode ispresented in Alg. 3.Denote t as the number of outer rounds (line 2 Alg. 3) II ran before terminating. II ’s theoretical performance guaranteeis stated in the following theorem. Theorem 4.
Given an instance G, { f v } v , S, T of the cLPI problem and a TB oracle, if x is an output of II and x ∗ isthe optimal solution to the cLPI ’s instance, then (cid:107) x (cid:107) ≤ (cid:107) x ∗ (cid:107) O ( t ln |F| ε − t ) Proof.
Denote x i and P i as x and P obtained at iteration i ofthe loop at line 2. From approximation guarantee of the TB oracle, we have: (cid:107) x i \ x i − (cid:107) ≤ (cid:107) x ∗ (cid:107) O (ln( |P i | ε − )) Therefore: (cid:107) x (cid:107) = t (cid:88) i =1 (cid:107) x i \ x i − (cid:107) ≤ (cid:107) x ∗ (cid:107) t (cid:88) i =1 O (ln( |P i | ε − )) (2) = (cid:107) x ∗ (cid:107) O (ln t (cid:89) i =1 |P i | + t ln ε − ) (3) ≤ (cid:107) x ∗ (cid:107) O (ln (cid:16) (cid:80) ti =1 |P i | t (cid:17) t ) + O ( t ln ε − ) (4) ≤ (cid:107) x ∗ (cid:107) O ( t ln |F| ε − t ) (5)The inequality 4 is from AM-GM inequality while 5 is fromthe fact that L i s are disjoint sets of paths. Thus (cid:80) ti =1 |P i | ≤|F| , which completes the proof. B. Full Set Interdiction
In general, FI aims to construct a set P of feasible paths,which is a subset of F but, if being used as an input for TB ,can return s that is also an ε -feasible solution of cLPI .Different to II , which incrementally adds impact to inter-dict disjoint sets of feasible paths, FI aggregates all foundpath sets into a big one set called P ; and reset the impactvector x in order to find a new vector that can simultaneouslyinterdict all paths in P . A new path set is found by k shortestpaths algorithm with a same motive as II . The algorithmterminates when the output s of the TB oracle with input P is also ε -feasible to cLPI . The pseudocode is presented inAlg. 4 and FI ’s performance guarantee is presented by thefollowing theorem. Theorem 5.
Given an instance G, { f v } v , S, T of the cLPI problem and a TB oracle, if x is an output of FI and x ∗ isthe optimal solution to the cLPI ’s instance, then (cid:107) x (cid:107) ≤ (cid:107) x ∗ (cid:107) O (ln |F| ε − ) Proof.
Without loss of generality, let P denote as the final pathsets inputted to TB in the final iteration. From performanceguarantee of TB , we have that: (cid:107) x (cid:107) ≤ (cid:107) x ∗ (cid:107) O (ln |P| ε − ) The theorem trivially follows since there is no duplicated pathin P and P ⊆ F .Although FI shows to have a better performance guaranteethan II , in term of memory complexity, it could take FI O ( |F| ) to store P while II only takes O ( | S | k ) . That is thetrade-off between those two algorithms and it will be shownin more detail in our experiments.VI. E XPERIMENTAL A NALYSIS
In this section, we run simulation on network data setsto evaluate performance of different combination betweenalgorithms of the
CPL and TB oracle. We compare ouralgorithms’ performance to several methods modified fromexisting solutions to adapt to the context of cLPI . The resultsshow our algorithms outperform existing methods in mostcases. We further investigate advantages of each algorithm toreveal some insights on use cases of each technique. Algorithm 4
Full Set Interdiction
Input G, { f e } e , T, ε, S, TB Output x P = ∅ , x = { } v while ∃ ( s, t ) ∈ S that d x ( s, t ) < T (1 − ε ) in G do for each pair ( s, t ) ∈ S that d x ( s, t ) < T (1 − ε ) do K = k shortest paths from s to t under x Remove paths p that d x ( p ) ≥ T (1 − ε ) out of K P = P ∪ K x = { } s = run TB oracle with input G, { f v } v , P , T, ε, x x = s Return x A. Experimental Settings
We run experiments on a router network, collected fromSNAP [26] dataset. The network is constructed as a commu-nication network of who-talks-to-whom from the BGP (BorderGateway Protocol) logs. The network is undirected, containing6474 nodes and 13895 undirected links connecting nodes.Critical traffics are randomly sampled from pairs of endhosts in the networks. That critical traffics forms the set S asan input to cLPI .Due to lack of dataset information, for each experiment, welet f v be identical for all v , and be one of the following: • f v ( x ) = O ( x ) - a convex function in order to simulatethe relation between external impacts to a router latency. • f v ( x ) = O (log x ) - a concave function to simulate therelation between external impacts to packet drop/loss rateof a router. • f v ( x ) = O ( x ) - a linear function to compare ouralgorithms’ solution quality to an optimal solution, whichcan be found by using linear programming. • f v ( x ) = O ( (cid:98) x (cid:99) ) - a step function to compare our algo-rithms’ performance with an existing discrete method.We compare our algorithms with the following methods: • CUT - this method is adapted from [9]. In general, themethod works in an “all-or-nothing” manner that animpact amount put into a node is either or min { x | f v ( x ) ≥ T } . That amount guarantees any path containingthat node will have length at least T . • DISCRETE - this method discretizes the functions f v sas follows. If f v is a step function, the amount put intoa node is a positive integer. Otherwise, the amount putinto a node is among , x, x, x where x = min { x | f v (3 x ) ≥ T } . The method then apply the QoSD algo-rithm to solve the discretized instance. • OPT - this method is only applied when f v is a linear orstep function. We use CPLEX [27] to optimally solve thelinear programming modelling the TB oracle and combineit with FI in CPL to obtain the optimal solution to cLPI .With our algorithms, the most time-consuming part is onfinding global optimum of univariate functions, for example max x r P , x + s ,v ( x ) x in JSG . As “what is the best technique to find global optimum?” [28], [29] is still an open question,we measured the runtime of our algorithms in term of howmany times they have to query for finding global optimum ofa univariate function.Finally, in the
CPL oracle, we set k = 20 , which - in ourexperiment - balances the trade-off on running time to find k shortest path and the exposure of critical nodes. In TB , with TE , we initially set M = 1000000 if the function is non-differentiable (e.g. step function). ε = 0 . otherwise stated. We only present representative experimental results. Otherresults with similar behaviors are excluded.B. Results1) How algorithms perform with various T ?: In the firstset of experiments, we varied values of T to observe howdifferent algorithms performed. Figure 1 displays (cid:107) x (cid:107) returnedby our algorithms in comparison with CUT , DISCRETE and
OPT (only when f v is a linear or step function).In the concave case, we observe that our algorithms outper-formed existing methods by a huge margin. Existing methodswere totally undesirable in this case as their required impactwere approximately 100 times worse than ours. This can beexplained by: with the concave function, the contribution ofimpacts to the function expose diminishing return property,i.e. the function’s gain becomes insignificant as input impactgrows. That exposed the weakness of discretization steps in CUT and
DISCRETE as a discretized impact’s contribution isincomparable to the invested amount.On the other hand, our algorithms involving FI as the TB oracle returns comparable solution quality to OPT and
DISCRETE in non-concave functions. With non-concavity, thefunction’s gain benefits when input impact increases. Criticalnodes, which appear frequently on feasible paths connectingpairs in S , are tended to received large impact amount.Therefore, we observed FI-JSG and
DISCRETE behavesalmost similarly; and returns solution close to
OPT in linearand step cases. Although our algorithms involving II returnssolution larger than FI , they have advantages in running timeand memory, which will be shown in the next parts.
2) How our algorithms’ number of queries change withvarious T ?: In this experiment, we measured the number ofqueries each of our algorithms takes to solve a cLPI instance.Just to recall, a query is counted as a call to find global optimalof a univariate function. In algorithms involving
JSG , a queryis equivalent to finding max x r P , x + s ,v ( x ) x (line 5 Alg. 2). Inthe ones involving TE , a query is counted as a call to find max (cid:8) x ≥ | r P , x + s ,v ( x ) x ≥ M (cid:9) (line 5 Alg. 1). Figure2 shows the numbers of queries taken by each algorithm invarious T and different impact functions.From Figure 2, we can see that our algorithm involving II totally outperformed the ones with FI in term of queries.For example, with concave cases, with a same TB method,algorithms involving FI tends to take 100 times more queriesthan the one with II . With convex and step cases, this numberis around 2-3 and it is around 5 in linear cases. This canbe explained by the fact that II works in an incrementalmanner, in which impact amounts are accumulated when a , T (cid:107) x (cid:107) (concave) . . . . · , , T (cid:107) x (cid:107) (convex)
50 60 70 80 90 1005001 , , , , T (cid:107) x (cid:107) (linear)
50 60 70 80 90 1005001 , , T (cid:107) x (cid:107) (step) FI - TE FI - JSG II - TE II - JSG CUT DISCRETE OPT
Fig. 1: Algorithms’ returned solution with various T new feasible paths - whose lengths have not satisfied theproblem constraints - are found. Thus each query of algorithminvolving II play a role, even insignificant, in constructingthe final solution. Meanwhile FI resets its impact vector ifnew unsatisfactory feasible paths are found. Thus queries usedbefore resetting the vector become wasted.In comparison between algorithms of the TB oracle, it canbe seen that TE performed better in concave and linear caseswhile in convex and step, JSG is the better one. That can beexplained as follows: due to the trait of concave and linearfunctions,
JSG ’s query always returns an amount equal to thejump start step, i.e. β . Thus the algorithm required multiplequeries to reach satisfactory amount. In contrast, the query max (cid:8) x ≥ | r P , x + s ,v ( x ) x ≥ M (cid:9) of TE can reach to a largeramount in comparison with a jump start step. However, thatsituation does not happen when convexity is exposed. Withconvex functions, impact amounts are invested only on severalnodes, which exactly is how JSG behaves. Meanwhile, TE adds impact amounts to nodes sequentially, which makes TE ’simpact scattered and unnecessary on some nodes.However, there is an interesting fact about TE : TE ’s numberof queries does not depends on T in non-concave cases. Thatis the reason why TE ’s number of queries are constant in thosecases as shown in Figure. 2. That can be intuitively explainedby that: given a set of paths P which share a common node v ,the way TE increases impact amount on v by query max (cid:8) x ≥ | r P, x + s ,v ( x ) x ≥ M (cid:9) does not get affected by T ’s value.
3) How the number of stored paths change?:
In the nextexperiment, we compare how much memory our algorithmstook to process a cLPI instance. Feasible paths are critical todetermine feasibility of our solution. An obstacle on prevent-ing us to apply traditional constraint optimization on cLPI is listing all feasible paths, which could be exponential anda huge burden to computing storage. Therefore, we measuresthe memory efficiency of our algorithms in term of number ofpaths they need to store in memory in order to find a feasiblesolution. Figure 3 shows two kinds of charts of comparisonbetween our algorithm: (1) One shows the maximum numberof stored paths of each algorithms with various T ; (2) Theother one shows how the number of stored paths changesafter each round of each algorithm. A round of my algorithmis counted as one while iteration of checking feasibility ofobtained solutions. From how II works, it is trivial that algorithms involving II store at most O ( | S | k ) paths no matter value of T is. Thatis also shown in Fig. 3. On the other hand, the number ofstored paths of algorithms involving FI increases when T increases and is always much larger than this number in II . Tohave more insight, we look at how each algorithm accumulatespaths after each round. As FI works in the manner that collectsall feasible paths with unsatisfactory lengths in each round intoone large set of paths, its number of paths starts from O ( | S | k ) (the same as II ) and increases significantly with more andmore rounds to come. On the other hand, each round of II stores at most O ( | S | k ) feasible paths; its path set in each roundis disjoint and decreases in size. Therefore, II clearly showsits dominance to FI in term of memory.Similar to the number of queries for finding global optimumof a univariate function, in linear cases, the number of storedpaths of algorithms involving TE also stays constant and doesnot affected by value of T . The same reason is also applied.
4) Trade-off in term of ε : In the final experiment, weinvestigate how different values of ε impact our algorithms’performance. ε represents how “accurate” the returned so-lutions of our algorithms are to the requirement of cLPI .Intuitively, the smaller ε is, the more accurate the solutions are,the closer lower bounds of distances between pairs of nodeson S are to T . Fig. 4 shows how our algorithms’ returnedsolutions, their numbers of queries and stored paths changewith various (cid:15) .From Fig. 4, we can see that the algorithm’s returned impactamounts decrease with larger ε . This is intuitive since withmore relaxed constraint, a smaller impact amount suffices.That is also reflected in our algorithms’ theoretical approx-imation guarantee, in a way that the ratio is proportional to aterm of ln ε − .Beside the trade-off between solution accuracy and solutionsize, ε also shows changes in the number of queries and storedpaths of each algorithm. With algorithms involves II , large ε helps decreasing number of queries, which totally contrastswith the one with FI . The behavior of II with various ε isintuitively explained by the fact that: with a same path set,the more relaxed constraint should end up with the smalleroverall impact needed. However, we found this fact does notapplied with FI because the more relaxed constraint does notguarantee the fewer number of processed paths. That is shown T . . . . · . . . . · T
50 60 70 80 90 10010 T
50 60 70 80 90 100012345 · T FI - TE FI - JSG II - TE II - JSG
Fig. 2: Algorithms’ number of queries with various T . . · T , , , round T = 10 )
50 60 70 80 90 100200250300350400450
T round T = 100 ) FI - TE FI - JSG II - TE II - JSG
Fig. 3: Algorithms’ memory changes with various T in the third sub-figure in Fig. 4; we can see that the numberof stored paths of FI increases with ε grows. With morepaths to process, FI ’s behavior becomes more complicated.Meanwhile, II is stable with the cap on the number ofprocessing paths, which is at most O ( | S | k ) . C. Experiment Summary
We summarize experimental results, showing advantages ofour algorithms as follows: • Our algorithms outperform existing methods that needsan intermediate discretization step in most cases. Evenin the special instance of cLPI with “discrete” (step)function, one of our algorithm ( FI - JSG ) performed com-parably to the state-of-the-art solution. • Each of our algorithm has strengths in different aspects,to be specific: – With the TB oracle, algorithms involving JSG tendto get better solution quality. Meanwhile, the oneswith TE have advantage in the number of queries onglobal optimum of a univariate function. – With the
CPL oracle, FI has strengths in solutionquality while II shows to save memory in term ofthe number of stored feasible paths, which plays arole on saving the number of queries in the TB oracleas well. • ε allows user control the trade-off between solutionquality and accuracy to the input constraint. Moreover,algorithms involving II benefit from ε in the way thatlarger ε helps reduce their runtime. VII. C ONCLUSION
We studied the cLPI problem, in which we proposedmultiple algorithms with different performance guarantees.Theoretical evaluation and experimental analysis are provided,supporting users on deciding which combinations are thebest for their needs. Indeed, there are still significant worksto improve in the future. A node could be associated withmultiple functions, serving for multiple objectives of system’sfunctionality. Also, each function can have multiple variablesand each variable could appear on more than one function,making the problem become much more complicated. How tobalance those multiple objectives is still an open problem.R
EFERENCES[1] N. Garg, V. V. Vazirani, and M. Yannakakis, “Primal-dual approximationalgorithms for integral flow and multicut in trees,”
Algorithmica , vol. 18,no. 1, pp. 3–20, 1997.[2] S. Chawla, R. Krauthgamer, R. Kumar, Y. Rabani, and D. Sivakumar,“On the hardness of approximating multicut and sparsest-cut,” compu-tational complexity , vol. 15, no. 2, pp. 94–114, 2006.[3] Z. Svitkina and ´E. Tardos, “Min-max multiway cut,” in
Approximation,Randomization, and Combinatorial Optimization. Algorithms and Tech-niques . Springer, 2004, pp. 207–218.[4] E. Dahlhaus, D. S. Johnson, C. H. Papadimitriou, P. D. Seymour, andM. Yannakakis, “The complexity of multiway cuts,” in
Proceedingsof the twenty-fourth annual ACM symposium on Theory of computing .ACM, 1992, pp. 241–251.[5] T. N. Dinh and M. T. Thai, “Assessing attack vulnerability in networkswith uncertainty,” in
Computer Communications (INFOCOM), 2015IEEE Conference on . IEEE, 2015, pp. 2380–2388.[6] ——, “Network under joint node and link attacks: Vulnerability assess-ment methods and analysis,”
IEEE/ACM Transactions on Networking ,vol. 23, no. 3, pp. 1001–1011, 2015. . . . . . . . , , , ε (cid:107) x (cid:107) (concave) . . . . . ε . . . . . ε . . · ε ε = 0 . ) FI - TE FI - JSG II - TE II - JSG CUT DISCRETE
Fig. 4: Trade-off in term of ε [7] S. Checkoway, D. McCoy, B. Kantor, D. Anderson, H. Shacham,S. Savage, K. Koscher, A. Czeskis, F. Roesner, T. Kohno et al. ,“Comprehensive experimental analyses of automotive attack surfaces.”in USENIX Security Symposium . San Francisco, 2011, pp. 77–92.[8] Q. A. Chen, Y. Yin, Y. Feng, Z. M. Mao, and H. X. Liu, “Exposingcongestion attack on emerging connected vehicle based traffic signalcontrol,” in
Network and Distributed Systems Security (NDSS) Sympo-sium 2018 , 2018.[9] A. Kuhnle, V. G. Crawford, and M. T. Thai, “Network resilience andthe length-bounded multicut problem: Reaching the dynamic billion-scale with guarantees,”
Proceedings of the ACM on Measurement andAnalysis of Computing Systems , vol. 2, no. 1, p. 4, 2018.[10] L. N. Nguyen and M. T. Thai, “Network resilience assessment via qosdegradation metrics: An algorithmic approach,”
Proceedings of the ACMon Measurement and Analysis of Computing Systems , vol. 3, no. 1, p. 1,2019.[11] F. Safaei, M. Rezazad, A. Khonsari, M. Fathy, M. Ould-Khaoua, andN. Alzeidi, “Software-based fault-tolerant routing algorithm in multidi-mensional networks,” in
Proceedings 20th IEEE International Parallel& Distributed Processing Symposium . IEEE, 2006, pp. 8–pp.[12] R. Alvizu, A. Arcia, M. Hern´andez, M. Huerta, and I. T. Monroy,“Hybrid wdm–xdm pon architectures for future proof access networks,” networks , vol. 8, p. 17, 2012.[13] G. Wangen, A. Shalaginov, and C. Hallstensen, “Cyber security riskassessment of a ddos attack,” in
International Conference on InformationSecurity . Springer, 2016, pp. 183–202.[14] M. Gr¨otschel, L. Lov´asz, and A. Schrijver, “The ellipsoid method andits consequences in combinatorial optimization,”
Combinatorica , vol. 1,no. 2, pp. 169–197, 1981.[15] Y. Feng, C. Jayasundara, A. Nirmalathas, and E. Wong, “A feasibilitystudy of ieee 802.11 hcca for low-latency applications,”
IEEE Transac-tions on Communications , vol. 67, no. 7, pp. 4928–4938, 2019.[16] T. Clausen, P. Jacquet, C. Adjih, A. Laouiti, P. Minet, P. Muhlethaler,A. Qayyum, and L. Viennot, “Optimized link state routing protocol(olsr),” 2003.[17] D. Waitzman, C. Partridge, S. Deering et al. , “Distance vector multicastrouting protocol,” 1988.[18] J. T. Moy,
OSPF: anatomy of an Internet routing protocol . Addison-Wesley Professional, 1998.[19] D. Kreutz, F. M. Ramos, P. E. Verissimo, C. E. Rothenberg, S. Azodol-molky, and S. Uhlig, “Software-defined networking: A comprehensivesurvey,”
Proceedings of the IEEE , vol. 103, no. 1, pp. 14–76, 2014.[20] W. Xia, Y. Wen, C. H. Foh, D. Niyato, and H. Xie, “A surveyon software-defined networking,”
IEEE Communications Surveys &Tutorials , vol. 17, no. 1, pp. 27–51, 2014.[21] Y. Shen, N. P. Nguyen, Y. Xuan, and M. T. Thai, “On the discovery ofcritical links and nodes for assessing network vulnerability,”
IEEE/ACMTransactions on Networking , vol. 21, no. 3, pp. 963–973, 2013.[22] D. T. Nguyen, Y. Shen, M. T. Thai et al. , “Detecting critical nodesin interdependent power networks for vulnerability assessment.”
IEEETrans. Smart Grid , vol. 4, no. 1, pp. 151–159, 2013.[23] D. P. Bertsekas,
Constrained optimization and Lagrange multipliermethods . Academic press, 2014.[24] P. E. Gill, W. Murray, and M. A. Saunders, “Snopt: An sqp algorithmfor large-scale constrained optimization,”
SIAM review , vol. 47, no. 1,pp. 99–131, 2005. [25] T. P. Runarsson and X. Yao, “Stochastic ranking for constrained evolu-tionary optimization,”
IEEE Transactions on evolutionary computation ,vol. 4, no. 3, pp. 284–294, 2000.[26] J. Leskovec and A. Krevl, “SNAP Datasets: Stanford large networkdataset collection,” http://snap.stanford.edu/data.[27] I. I. CPLEX, “V12. 1: User’s manual for cplex,”
International BusinessMachines Corporation , vol. 46, no. 53, p. 157, 2009.[28] J. M. Calvin, Y. Chen, and A. ˇZilinskas, “An adaptive univariate globaloptimization algorithm and its convergence rate for twice continuouslydifferentiable functions,”
Journal of Optimization Theory and Applica-tions , vol. 155, no. 2, pp. 628–636, 2012.[29] D. Aaid, A. Noui, and M. Ouanes, “New technique for solving univariateglobal optimization,”
Archivum Mathematicum , vol. 53, no. 1, pp. 19–33,2017.
Lan N. Nguyen received his Degree of Engineer inInformation Technology from Hanoi University ofScience and Technology, Vietnam in 2014. He hasbeen a PhD student under the supervisor of Dr. MyT. Thai in the CISE department at the Universityof Florida since Spring 2017. His current researchinterests is on proposing lightweight algorithms tosolve large-scale problems with application on Ma-chine Learning or Network Optimization.
My T. Thai (M’06) is a UF Research FoundationProfessor at the Computer and Information Scienceand Engineering department, University of Florida.Her current research interests are on scalable al-gorithms, big data analysis, cybersecurity, and op-timization in network science and engineering, in-cluding communication networks, smart grids, socialnetworks, and their interdependency. The results ofher work have led to 6 books and 170+ articles,including IEEE MSN 2014 Best Paper Award, 2017,IEEE ICDM Best Papers Award, 2017 IEEE ICDCSBest Paper Nominee, and 2018 IEEE/ACM ASONAM Best Paper Runner up.Prof. Thai has engaged in many professional activities. She has been aTPC-chair for many IEEE conferences, has served as an associate editor for
IEEE Transactions on Parallel and Distributed Systems , IEEE Transactions on Network Science and
Engineering , and a series editor of
Springer Briefs in Optimization . She is a founding Editor-in-Chief of the
ComputationalSocial Networks journal, and Editor-in-Chief of