ALTO WG K. Gao Internet-Draft Tsinghua University Intended status: Standards Track X. Wang Expires: September 3, 2018 Tongji University Q. Xiang Tongji/Yale University C. Gu Tongji University Y. Yang Yale University G. Chen Huawei March 2, 2018 Compressing ALTO Path Vectors draft-gao-alto-routing-state-abstraction-08.txt Abstract The path vector extension [I-D.ietf-alto-path-vector] has extended the base ALTO protocol [RFC7285] with the ability to represent a more detailed view of the network which contains not only end-to-end costs but also information about shared bottlenecks. However, the view computed by straw man algorithms can contain redundant information and result in unnecessary communication overhead. The situation gets even worse when certain ALTO extensions are enabled, for example, the incremental update extension [I-D.ietf-alto-incr-update-sse] which continuously pushes data changes to ALTO clients. Redundant information can trigger unnecessary updates. In this document, several algorithms are described which can effectively reduce the redundancy in the network view while still providing the same information as in the original path vectors. Requirements Language The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [RFC2119]. Status of This Memo This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79. Gao, et al. Expires September 3, 2018 [Page 1]

Internet-Draft Compressing Path Vectors March 2018 Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet- Drafts is at http://datatracker.ietf.org/drafts/current/. Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress." This Internet-Draft will expire on September 3, 2018. Copyright Notice Copyright (c) 2018 IETF Trust and the persons identified as the document authors. All rights reserved. This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License. Table of Contents 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3 2. Changes Since Version -03, -04, -05, -06 and -07 . . . . . . 4 3. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 4 4. Compressing Path Vectors . . . . . . . . . . . . . . . . . . 4 4.1. Equivalent Aggregation . . . . . . . . . . . . . . . . . 5 4.2. Redundant Network Elements . . . . . . . . . . . . . . . 6 4.3. Equivalent Decomposition . . . . . . . . . . . . . . . . 7 5. Compression Algorithms . . . . . . . . . . . . . . . . . . . 8 5.1. Equivalent Aggregation . . . . . . . . . . . . . . . . . 9 5.2. Redundant Network Element Identification . . . . . . . . 11 5.3. Equivalent Decomposition . . . . . . . . . . . . . . . . 13 5.4. Execution Order . . . . . . . . . . . . . . . . . . . . . 16 6. Encoding/Decoding Path Vectors . . . . . . . . . . . . . . . 16 6.1. Decoding Path Vectors . . . . . . . . . . . . . . . . . . 17 6.2. Encoding Path Vectors . . . . . . . . . . . . . . . . . . 20 6.3. Compatibility . . . . . . . . . . . . . . . . . . . . . . 23 7. Security Considerations . . . . . . . . . . . . . . . . . . . 23 8. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 23 9. Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . 23 Gao, et al. Expires September 3, 2018 [Page 2]

Internet-Draft Compressing Path Vectors March 2018 10. References . . . . . . . . . . . . . . . . . . . . . . . . . 23 10.1. Normative References . . . . . . . . . . . . . . . . . . 23 10.2. Informative References . . . . . . . . . . . . . . . . . 23 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 24 1. Introduction The path vector extension [I-D.ietf-alto-path-vector] has extended the base ALTO protocol [RFC7285] with the ability to present more complex network views than the simple abstraction used by Cost Map or Endpoint Cost Service. ALTO clients can query more sophisticated information such as shared bottlenecks, and schedule their flows properly to avoid congestion and to better utilize network resources. Meanwhile, the extension itself does not specify how an ALTO server should respond to a path-vector query. A straw man approach, as in the context of Software Defined Networking (SDN) where network providers have a global view, can compute the path vectors by retrieving the paths for all requested flows and returning the links on those paths as abstract network elements. However, this approach has several drawbacks: o The resultant network view may lead to privacy leaks. Since the paths constitute a sub-graph of the global network topology, they may contain sensitive information without further processing. o The resultant network view may contain redundant information. The path vector information is primarily used to avoid network bottlenecks. Thus, if a link cannot become the bottleneck, as demonstrated in Section 4, it is considered as redundant. Redundant links not only increase the communication overhead of the path vector extension, but also trigger false-positive data change events when the incremental update extension [I-D.ietf-alto-incr-update-sse] is activated. To overcome these limitations, this document describes equivalent transformation algorithms that identify redundant abstract network elements and reduce them as much as possible. The algorithm can be integrated with any implementation of the path vector extension as a post-processing step. As the name suggests, this algorithm conducts equivalent transformations on the original path vectors, removes redundant information and obtains a more compact view. This document is a supplement to the path vector extension and can be optionally turned on and off without affecting the correctness of responses. A crucial part of the equivalent transformation algorithm is how to find redundant abstract network elements. By tuning the redundancy check algorithm, one can make different trade-off Gao, et al. Expires September 3, 2018 [Page 3]

Internet-Draft Compressing Path Vectors March 2018 decisions between efficiency and privacy. A reference implementation of redundancy check algorithm is also described in this document. This document is organized as follows. Section 4 gives a concrete example to demonstrate the importance of compressing path vectors. The compression algorithms are specified in Section 5 and Section 6 discusses how one can use these algorithms on existing path vector responses. Finally, Section 7 and Section 8 discuss security and IANA considerations. 2. Changes Since Version -03, -04, -05, -06 and -07 In early versions of this draft, a lot of contents are shared with the path vector draft. From version -04, the authors have adjusted the structure and target this document as a supplement of the path vector extension with o practical compression algorithms which can effectively reduce the leaked information and the communication overhead; and o detailed instructions on how an original path vector response can be processed by these algorithms. The -06 version fixed some minor issues in -04 and -05. The -07 version has focused on improving the clarity of the algorithms with more examples. The -08 version has improved the overall quality of the draft, especially the clarity of the algorithms using simpler symbols. 3. Terminology This document uses the same terms as in [I-D.ietf-alto-path-vector]. 4. Compressing Path Vectors We use the example shown in Figure 1 to demonstrate the importance of compressing path vectors. The network has 6 switches (sw1 to sw6) forming a dumbbell topology where switches sw1/sw3 provide access on the left hand side, s2/s4 provide access on the right hand side, and sw5/sw6 form the backbone. End hosts eh1 to eh4 are connected to access switches sw1 to sw4 respectively. Assume that the bandwidth of each link is 100 Mbps, and that the network is abstracted with 4 PIDs each representing a host at one access switch. Gao, et al. Expires September 3, 2018 [Page 4]

Internet-Draft Compressing Path Vectors March 2018 PID1 +-----+ +-----+ PID2 eh1__| |_ ____| |__eh2 | sw1 | \ +------+ +------+ / | sw2 | +-----+ \ | | | |/ +-----+ \_| sw5 +---------+ sw6 | PID3 +-----+ / | | | |\ +-----+ PID4 eh3__| |__/ +------+ +------+ \____| |__eh4 | sw3 | | sw4 | +-----+ +-----+ Figure 1: Raw Network Topology +--------+---------------+ | Link | Description | +--------+---------------+ | link1 | sw1 <==> sw5 | | link2 | sw2 <==> sw6 | | link3 | sw3 <==> sw5 | | link4 | sw4 <==> sw6 | | link5 | sw5 <==> sw6 | +--------+---------------+ Table 1: Description of the Links Three cases are identified when path vectors can be further compressed and an example is provided for each case. 4.1. Equivalent Aggregation Consider an application which schedules the traffic consisting of two flows, eh1 -> eh2 and eh3 -> eh4. The application can query the path vectors and a straw man implementation will return all 5 links (abstract network elements) as shown in Figure 2. path vectors: eh1: [ eh2: [ane:l1, ane:l5, ane:l2]] eh3: [ eh4: [ane:l3, ane:l5, ane:l4]] abstract network element property map: ane:l1 : 100 Mbps ane:l2 : 100 Mbps ane:l3 : 100 Mbps ane:l4 : 100 Mbps ane:l5 : 100 Mbps Figure 2: Path Vectors Returned by a Straw Man Implementation Gao, et al. Expires September 3, 2018 [Page 5]

Internet-Draft Compressing Path Vectors March 2018 The resultant path vectors represent the following linear constraints on the available bandwidth for the two flows: bw(eh1->eh2) <= 100 Mbps (ane:l1) bw(eh1->eh2) <= 100 Mbps (ane:l2) bw(eh3->eh4) <= 100 Mbps (ane:l3) bw(eh3->eh4) <= 100 Mbps (ane:l4) bw(eh1->eh2) + bw(eh3->eh4) <= 100 Mbps (ane:l5) Figure 3: Linear Constraints Represented by the Path Vectors It can be seen that the constraints of ane:l1 and ane:l2 are exactly the same, and so are those of ane:l3 and ane:l4. Intuitively, we can replace ane:l1 and ane:l2 with a new abstract network element ane:1, and similarly replace ane:l3 and ane:l4 with ane:2. The new path vectors are shown in Figure 4. path vectors: eh1: [ eh2: [ane:1, ane:l5]] eh3: [ eh4: [ane:2, ane:l5]] abstract network element property map: ane:1 : 100 Mbps ane:2 : 100 Mbps ane:l5 : 100 Mbps Figure 4: Path Vectors after Merging ane:l1/ane:l2 and ane:l3/ane:l4 4.2. Redundant Network Elements Consider the same case as in Section 4.1. Taking a deeper look at Figure 3, one can conclude that constraints of ane:1 (ane:l1/ane:l2) and ane:2 (ane:l3/ane:l4) can be implicitly derived from that of ane:l5. Thus, these constraints are considered _redundant_ and the path vectors in Figure 4 can be further reduced. We replace ane:l5 with a new ane:3 and the new path vectors are shown in Figure 5. path vectors: eh1: [ eh2: [ane:3]] eh3: [ eh4: [ane:3]] abstract network element property map: ane:3 : 100 Mbps Figure 5: Path Vectors after Removing Redundant Elements It is clear that the new path vectors (Figure 5) are much more compact than the original path vectors (Figure 2) but they contain Gao, et al. Expires September 3, 2018 [Page 6]

Internet-Draft Compressing Path Vectors March 2018 just as much information. Meanwhile, the application can hardly infer anything about the original topology with the compact path vectors. 4.3. Equivalent Decomposition However, it is not always possible to directly remove all redundant network elements. For example, consider the case when both bandwidth and routingcost are requested, and the values are as shown in Figure 6. Note that we have changed the bandwidth for ane:l5 for demonstration purpose. path vectors: eh1: [ eh2: [ane:l1, ane:l5, ane:l2]] eh3: [ eh4: [ane:l3, ane:l5, ane:l4]] abstract network element property map: ane:l1 : 100 Mbps, 1 ane:l2 : 100 Mbps, 2 ane:l3 : 100 Mbps, 1 ane:l4 : 100 Mbps, 1 ane:l5 : 200 Mbps, 1 Figure 6: Path Vectors Returned by a Straw Man Implementation bw(eh1->eh2) <= 100 Mbps (ane:l1) bw(eh1->eh2) <= 100 Mbps (ane:l2) bw(eh3->eh4) <= 100 Mbps (ane:l3) bw(eh3->eh4) <= 100 Mbps (ane:l4) bw(eh1->eh2) + bw(eh3->eh4) <= 200 Mbps (ane:l5) Figure 7: Bandwidth Constraints in the Original Path Vectors rc(eh1->eh2) = rc(ane:l1) + rc(ane:l2) + rc(ane:l5) = 4 rc(eh3->eh4) = rc(ane:l3) + rc(ane:l4) + rc(ane:l5) = 3 Figure 8: Routingcost Information in the Original Path Vectors Figure 7 and Figure 8 demonstrate the bandwidth and routingcost information one can obtain from the original path vector. Again, ane:l1/ane:l2 and ane:l3/ane:l4 can still be aggregated in a similar way as in Figure 4 by setting the routingcost of ane:1 and ane:2 to 3 and 2 respectively. However, we cannot remove the redundant network element (ane:l5 in this case) directly because the resultant path vectors (Figure 9) would not provide the same routingcost information as in the original path vector. Gao, et al. Expires September 3, 2018 [Page 7]

Internet-Draft Compressing Path Vectors March 2018 path vectors: eh1: [ eh2: [ane:1]] eh3: [ eh4: [ane:2]] abstract network element property map: ane:1 : 100 Mbps, 3 ane:2 : 100 Mbps, 2 Figure 9: Path Vectors after Removing Redundant Network Element A further observation is that since the bandwidth constraint of ane:l5 is redundant, it can be equally represented as two abstract network elements ane:a5 and ane:b5, as shown in Figure 10. path vectors: eh1: [ eh2: [ane:1, ane:a5]] eh3: [ eh4: [ane:2, ane:b5]] abstract network element property map: ane:1 : 100 Mbps, 3 ane:2 : 100 Mbps, 2 ane:a5 : 200 Mbps, 1 ane:b5 : 200 Mbps, 1 Figure 10: Path Vectors after Decomposing ane:l5 Since ane:1/ane:a5 and ane:2/ane:b5 can be aggregated as ane:3 and ane:4 respectively, the final path vectors only contain two network elements, as shown in Figure 11. path vectors: eh1: [ eh2: [ane:1]] eh3: [ eh4: [ane:2]] abstract network element property map: ane:1 : 100 Mbps, 4 ane:2 : 100 Mbps, 3 Figure 11: Path Vectors after Merging ane:1/ane:a5 and ane:2/ane:b5 One can verify that this path vector response has just the same information as in Figure 6 but contains much less contents. 5. Compression Algorithms To provide a guideline on how path vectors MIGHT be compressed, this section describes the details of the algorithms for the three aforementioned cases: Gao, et al. Expires September 3, 2018 [Page 8]

Internet-Draft Compressing Path Vectors March 2018 1. Equivalent aggregation (EQUIV_AGGR), which compresses the original path vectors by aggregating the network elements with the same set of pairs as shown in Section 4.1; 2. Identification of redundant constraints (IS_REDUNDANT), which compresses the original path vectors by removing the network elements that provide only redundant information as shown in Section 4.2; 3. Equivalent decomposition (EQUIV_DECOMP), which compresses the original path vectors by decomposing redundant network elements to obtain the same end-to-end routing metrics as shown in Section 4.3. 5.1. Equivalent Aggregation 5.1.1. Parameters and Variables The equivalent aggregation algorithm takes 3 parameters: the set of network elements "V", the set of relevant host pairs "P" and the set of metrics "M". Set of network elements V: The set of network elements consists of all the network elements that exists in the original path vectors. The "i"-th network element in "V" is denoted as "v_i". Set of relevant host pairs P: The "i"-th element in "P" is denoted as "p_i". It represents the set of (src, dst) pairs whose paths traverse "v_i" in the original path vectors. Set of metrics M: The "i-th" element in "M" is denoted as "m_i". It represents the set of metrics associated with network element "v_i". The output of the equivalent aggregation algorithm is a new set of network elements "V'", a new set of relevant host pairs "P'" and a new set of metrics "M'", i.e., "V', P', M' = EQUIV_AGGR(V, P, M)". 5.1.2. Algorithm Description 1. Set "V'", "P'", "M'" to empty sets. Set "k" to 0. Go to step 2. 2. If "V" is empty, go to step 6. Otherwise, go to step 3. 3. Select an arbitrary element "v_i" from "V", remove "v_i" from "V" and go to step 4. Gao, et al. Expires September 3, 2018 [Page 9]

Internet-Draft Compressing Path Vectors March 2018 4. For any element "v_j" in "V", if "p_i = p_j", remove "v_j" from "V" and update "m_i" with "m_j", i.e., "m_i = UPDATE(m_i, m_j)" (which will be explained later). Go to step 5. 5. Increment "k" by 1, let "v'_k = v_i", "p'_k = p_i" and "m'_k = m_i". Go to step 2. 6. Return "V'", "P'", and "M'" The process of update "m_i" with "m_j" depends on the metric types. For example, for routingcost and hopcount, the update is numerical addition, while for bandwidth, the update is calculating the minimum. The UPDATE function for some common metrics are listed in Table 2. +--------------+------------------------+------------+ | metric | UPDATE(x, y) | default | +--------------+------------------------+------------+ | hopcount | x + y | 0 | | routingcost | x + y | 0 | | bandwidth | min(x, y) | +infinity | | loss rate | 1 - (1 - x) * (1 - y) | 0 | +--------------+------------------------+------------+ Table 2: UPDATE Function of Different Metrics 5.1.3. Example Consider the path vectors in Figure 2 which can be represented as: V = { ane:l1, ane:l2, ane:l3, ane:l4, ane:l5 } p_1 = { eh1->eh2 } p_2 = { eh1->eh2 } p_3 = { eh3->eh4 } p_4 = { eh3->eh4 } p_5 = { eh1->eh2, eh3->eh4 } m_1 = 100 Mbps m_2 = 100 Mbps m_3 = 100 Mbps m_4 = 100 Mbps m_5 = 100 Mbps As "p_1 = p_2" and "p_3 = p_4", the resultant attributes after the aggregation become: Gao, et al. Expires September 3, 2018 [Page 10]

Internet-Draft Compressing Path Vectors March 2018 V' = { ane:1, ane:2, ane:l5 } p'_1 = { eh1->eh2 } = p_1 = p_2 p'_2 = { eh3->eh4 } = p_3 = p_4 p'_3 = { eh1->eh2, eh3->eh4 } = p_5 m'_1 = 100 Mbps = UPDATE(m_1, m_2) m'_2 = 100 Mbps = UPDATE(m_3, m_4) m'_3 = 100 Mbps = m_5 5.2. Redundant Network Element Identification 5.2.1. Parameters and Variables The redundant network element identification algorithm is based on the algorithm introduced by Telgen [TELGEN83]. It takes 3 parameters: the set of network elements "V", the set of relevant host pairs "P" and the set of available bandwidth values "B". "V", "v_i", "P" and "p_i" are defined the same way as in Section 5.1.1. Set of available bandwidth values B: The "i"-th element in "B" is denoted as "b_i". It represents the available bandwidth for network element "v_i". The output of the IS_REDUNDANT function is a set of indices "R", which represents the indices of network elements whose bandwidth constraints are redundant, i.e., "R = IS_REDUNDANT(V, P, B)". In addition to the parameters and output values, the algorithm also maintains the following variables: Set of host pairs H: The "i"-th element of "H" is denoted as "h_i". It represents a (src, dst) pair ever appeared in the path vector query. "H" is the union of all "p_i" in "P". Set of bandwidth constraints C: The "i"-th element of "C" is denoted as "c_i". It represents a linear bandwidth constraint on the flows between the end host pairs. The constraint "c_i" has the form of "a_i x <= b_i" where "a_i" is a row vector of 0-1 coefficients derived from "p_i", "x" is a column vector representing the bandwidth of all the host pairs, and "b_i" is the available bandwidth of "v_i". Gao, et al. Expires September 3, 2018 [Page 11]

Internet-Draft Compressing Path Vectors March 2018 5.2.2. Algorithm Description 1. The first step is to convert a network element to its bandwidth constraint "c_i". The bound "b_i" is directly obtained as the available bandwidth and the coefficients "a_i" are computed as: 1 if h_j in p_i a_ij = 0 otherwise. Set "R" to an empty set. Go to step 2. 2. For each "i", solve the following linear programming problem: y_i = max a_i x subject to: a_j x <= b_j, j = 1..|V|, i <> j Go to step 3. 3. For each "i", if "y_i <= b_i", "c_i" is redundant and we say "v_i" is redundant, "R = UNION(R, {i})". Go to step 4. 4. Return "R". 5.2.3. Example Consider the path vectors in Figure 4 such that the input to the IS_REDUNDANT algorithm is as follows. V = { ane:1, ane:2, ane:l5 } p_1 = { eh1->eh2 } p_2 = { eh3->eh4 } p_3 = { eh1->eh2, eh3->eh4 } b_1 = 100 Mbps b_2 = 100 Mbps b_3 = 100 Mbps With that information, one can follow the algorithm and get: Gao, et al. Expires September 3, 2018 [Page 12]

Internet-Draft Compressing Path Vectors March 2018 c_1: x1 <= 100 c_2: x2 <= 100 c_3: x1 + x2 <= 100 y_1 = 100 Mbps <= b_1 y_2 = 100 Mbps <= b_2 y_3 = 200 Mbps > b_3 R = IS_REDUNDANT(V, P, B) = { 1, 2 } 5.3. Equivalent Decomposition 5.3.1. Parameters and Variables The equivalent decomposition algorithm takes 4 parameters: the set of network elements "V", the set of relevant host pairs "P", the set of metrics "M" and the set of redundant network elements "R". "V", "P" and "M" are as defined as in Section 5.1.1. If the "j"-th metric is bandwidth, we can construct the set of available bandwidth values "B" as "b_i = m_ij" and "R" is the output of the redundant network element identification procedure, i.e. "R = IS_REDUNDANT(V, P, B)". Otherwise, if bandwidth is not included in the metrics, "R" is {1, ..., |V|}. The output of the function EQUIV_DECOMP is a new set of network elements "V'", a new set of relevant host pairs "P'", and a new set of metrics "M'", i.e., "V', P', M' = EQUIV_DECOMP(V, P, M, R)". 5.3.2. Algorithm Description 1. Set "V'", "P'", "M'" to empty sets. Set "k" to 0. Go to step 2. 2. For each "i" such that "i" in "R", go to step 3. After processing each "i", go to step 7. 3. For each "j" such that "j <> i", go to step 4. After processing each "j", go to step 6. 4. If "p_j" is a subset of "p_i", go to step 5. Otherwise go to step 3. 5. Let "p_i = p_i \ p_j" and "m_j = UPDATE(m_j, m_i)". Go to step 3. 6. If "p_i" is not empty, increment "k" by 1 and let "v'_k = v_i", "p'_k = p_i" and "m'_k = m_i". Go to step 2. Gao, et al. Expires September 3, 2018 [Page 13]

Internet-Draft Compressing Path Vectors March 2018 7. For each "i" such that "i" is not in "R", go to step 8. After processing each "i", go to step 9. 8. Increment "k" by 1 and let "v'_k = v_i", "p'_k = p_i", "m'_k = m_i". Go to step 7. 9. Return "V'", "P'" and "M'". 5.3.3. Example Consider the case in Section 4.3. Before the decomposition, the input to the algorithm is as follows: V = { ane:1, ane:2, ane:l5 } p_1 = { eh1->eh2 } p_2 = { eh3->eh4 } p_3 = { eh1->eh2, eh3->eh4 } m_1 = { bw: 100 Mbps, rc: 3 } m_2 = { bw: 100 Mbps, rc: 2 } m_3 = { bw: 200 Mbps, rc: 1 } R = { 3 } Since there is only one element in "R", "v_i = ane:l5". After the first iteration of steps 3-5 with "v_j = ane:1": V = { ane:1, ane:2, ane:l5 } p_1 = { eh1->eh2 } p_2 = { eh3->eh4 } p_3 = { eh3->eh4 } m_1 = { bw: 100 Mbps, rc: 4 } m_2 = { bw: 100 Mbps, rc: 2 } m_3 = { bw: 200 Mbps, rc: 1 } V' = { } k = 0 After the second iteration of steps 3-5 with "v_j = ane:2": Gao, et al. Expires September 3, 2018 [Page 14]

Internet-Draft Compressing Path Vectors March 2018 V = { ane:1, ane:2, ane:l5 } p_1 = { eh1->eh2 } p_2 = { eh3->eh4 } p_3 = { } m_1 = { bw: 100 Mbps, rc: 4 } m_2 = { bw: 100 Mbps, rc: 3 } m_3 = { bw: 200 Mbps, rc: 1 } V' = { } k = 0 After step 6, since "p_3" is now empty, it just goes back to step 2. At step 2, since all indices in "R" has been processed, it goes to step 7. After the first iteration of steps 7-8 with "i = 1": V = { ane:1, ane:2, ane:l5 } p_1 = { eh1->eh2 } p_2 = { eh3->eh4 } p_3 = { } m_1 = { bw: 100 Mbps, rc: 4 } m_2 = { bw: 100 Mbps, rc: 3 } m_3 = { bw: 200 Mbps, rc: 1 } V' = { ane:1 } k = 1 p'_1 = { eh1->eh2 } = p_1 m'_1 = { bw: 100 Mbps, rc: 4 } = m_1 After the second iteration of steps 7-8 with "i = 2": Gao, et al. Expires September 3, 2018 [Page 15]

Internet-Draft Compressing Path Vectors March 2018 V = { ane:1, ane:2, ane:l5 } p_1 = { eh1->eh2 } p_2 = { eh3->eh4 } p_3 = { } m_1 = { bw: 100 Mbps, rc: 4 } m_2 = { bw: 100 Mbps, rc: 3 } m_3 = { bw: 200 Mbps, rc: 1 } V' = { ane:1, ane:2 } k = 2 p'_1 = { eh1->eh2 } p'_2 = { eh3->eh4 } = p_2 m'_1 = { bw: 100 Mbps, rc: 4 } m'_2 = { bw: 100 Mbps, rc: 3 } = m_2 So the final output of EQUIV_DECOMP is: V' = { ane:1, ane:2 } p'_1 = { eh1->eh2 } p'_2 = { eh3->eh4 } m'_1 = { bw: 100 Mbps, rc: 4 } m'_2 = { bw: 100 Mbps, rc: 3 } 5.4. Execution Order As the examples demonstrate, the three algorithms MUST be executed in the same order as they are introduced, i.e., one MUST conduct "EQUIV_AGGR" before "IS_REDUNDANT" or "EQUIV_DECOMP", and conduct "IS_REDUNDANT" before "EQUIV_DECOMP". Otherwise, the results of the compressed path vectors MAY NOT be correct. 6. Encoding/Decoding Path Vectors The three algorithms work mostly with network elements. Existing path vectors must be decoded before they can be passed on to the algorithms and the compressed results must be encoded as path vectors before they are sent to the clients. The decoding and encoding processes are specified as below. Gao, et al. Expires September 3, 2018 [Page 16]

Internet-Draft Compressing Path Vectors March 2018 6.1. Decoding Path Vectors 6.1.1. Parameters and Variables The decoding algorithm DECODE takes a path vector response, which consists of the path vector part "PV" and the element property part "E". Path vectors PV: The path vector part has a format of a CostMap (EndpointCostMap) where the cost value is a list of abstract network element names. We say a PID (endpoint address) "i" is IN "PV" if and only if there is an entry "i" in the cost-map (endpoint-cost-map), and denote the entry value as "PV[i]". Similarly, we say a PID (endpoint address) "j" is IN "PV[i]" if and only if there is an entry "j" in the DstCosts of "i", whose value is denoted as "PV[i][j]". Element property map E: The element property map "E" maps an abstract network element name to its properties. We denote "E[n]" as the properties of element with name "n" and "E[n][pn]" as the value of property "pn". The algorithm returns the set of elements "V", the set of relevant host pairs "P", the set of metrics "M" and the available bandwidth "B", as defined in Section 5.1.1 and Section 5.2.1. The algorithm uses a "SET" function which transforms a list into a set, and uses a "NAME" function which maps an integer in [1, K] to a unique property name where there are K properties in "E". 6.1.2. Algorithm Description 1. Set "V", "P", "M" and "B" to empty sets. Set "k" to 0. Go to step 2. 2. For each "i IN PV", go to step 3. After processing each "i", go to step 8. 3. For each "j IN PV[i]", go to step 4. After processing each "j", go to step 2. 4. For each "n" in "SET(PV[i][j])", go to step 5. After processing each "n", go to step 3. 5. If "n" is not in "V", go to step 6. Otherwise, go to step 7. 6. Increment "k" by 1 and let "v_k = n", "p_k = { i->j }". Go to step 4. Gao, et al. Expires September 3, 2018 [Page 17]

Internet-Draft Compressing Path Vectors March 2018 7. Find the index of "n" in "V" denoted as "a", let "p_a = UNION(p_a, {i->j})". Go to step 4. 8. For each "i" from 1 to |V|, go to step 9. After processing all "i", go to step 11. 9. For each "j" from 1 to K, go to step 10. After processing all "j", go back to step 8. 10. If "NAME(j) = 'availbw'", let "b_i = E[v_i][NAME(j)]". Let "m_ij = E[v_i][NAME(j)]". 11. Return "V", "P", "M" and "B". 6.1.3. Example Consider the following example: HTTP/1.1 200 OK Content-Length: [TBD] Content-Type: multipart/related; boundary=example-2 --example-2 Content-Type: application/alto-endpointcost+json { "meta": { "cost-types": [ {"cost-mode": "array", "cost-metric": "ane-path"} ] } "endpoint-cost-map": { "ipv4:192.0.2.2": { "ipv4:192.0.2.89": [ "ane:L1", "ane:L3", "ane:L4" ], "ipv4:203.0.113.45": [ "ane:L1", "ane:L4", "ane:L5" ] } } } Gao, et al. Expires September 3, 2018 [Page 18]

Internet-Draft Compressing Path Vectors March 2018 --example-2 Content-Type: application/alto-propmap+json { "property-map": { "ane:L1": { "availbw": 50 }, "ane:L3": { "availbw": 48 }, "ane:L4": { "availbw": 55 }, "ane:L5": { "availbw": 60 }, "ane:L7": { "availbw": 35 } } } --example-2-- After the first iteration of Lines 2-5: V = { ane:L1, ane:L3, ane:L4 } p_1 = { ipv4:192.0.2.2->ipv4:192.0.2.89 } p_2 = { ipv4:192.0.2.2->ipv4:192.0.2.89 } p_3 = { ipv4:192.0.2.2->ipv4:192.0.2.89 }. After the second iteration of Lines 2-5: V = { ane:L1, ane:L3, ane:L4, ane:L5 } p_1 = { ipv4:192.0.2.2->ipv4:192.0.2.89, ipv4:192.0.2.2->ipv4:203.0.113.45 } p_2 = { ipv4:192.0.2.2->ipv4:192.0.2.89, ipv4:192.0.2.2->ipv4:203.0.113.45 } p_3 = { ipv4:192.0.2.2->ipv4:192.0.2.89 } p_4 = { ipv4:192.0.2.2->ipv4:203.0.113.45 }. After the first iteration of Lines 6-9 with "i = 1": m_1 = [50] b_1 = 50 After all four iterations of Lines 6-9: Gao, et al. Expires September 3, 2018 [Page 19]

Internet-Draft Compressing Path Vectors March 2018 m_1 = [50] m_2 = [48] m_3 = [55] m_4 = [60] b_1 = 50 b_2 = 48 b_3 = 55 b_4 = 60 The decoded information can be passed on to "EQUIV_AGGR", "IS_REDUNDANT" and "EQUIV_DECOMP" for compression. 6.2. Encoding Path Vectors 6.2.1. Parameters and Variables The algorithm ENCODE is the reverse process of DECODE. It takes the parameters "V", "P", "M" and constructs the path vector results. The parameters are defined as in Section 5.1.1 and Section 5.2.1. The algorithm also uses the NAME function in Section 6.1.1 which MUST return the same results in a paired ENCODE/DECODE process, and the "APPEND(L, e)" function which adds element "e" to list "L". 6.2.2. Algorithm Description 1. Set "PV={}", "E = {}". Go to step 2. 2. For each "v_i" in "V", go to step 3. If all "v_i" is processed, go to step XX. 3. For each "a->b" in "p_i", go to step 4. If all such "a->b" is processed, go to step 6. 4. If "a" is not in "PV", let "PV[a] = {}". Go to step 5. 5. If "b" is not in "PV[a]", let "PV[a][b] = [v_i]". Otherwise, let "PV[a][b] = APPEND(PV[a][b], v_i)". Go to step 2. 6. For each index "k" in [1, K], go to step 7. If all "k" is processed, go to step 1. 7. Set "E[v_i][NAME(k)] = m_ik". Go to step 6. 8. Return "PV" and "E". Gao, et al. Expires September 3, 2018 [Page 20]

Internet-Draft Compressing Path Vectors March 2018 6.2.3. Example We consider the encoding of the decoded example in Section 6.1.3. V = { ane:L1, ane:L3, ane:L4, ane:L5 } p_1 = { ipv4:192.0.2.2->ipv4:192.0.2.89, ipv4:192.0.2.2->ipv4:203.0.113.45 } p_2 = { ipv4:192.0.2.2->ipv4:192.0.2.89, ipv4:192.0.2.2->ipv4:203.0.113.45 } p_3 = { ipv4:192.0.2.2->ipv4:192.0.2.89 } p_4 = { ipv4:192.0.2.2->ipv4:203.0.113.45 } m_1 = [50] m_2 = [48] m_3 = [55] m_4 = [60] After the first iteration of steps 2-7: PV[ipv4:192.0.2.2][ipv4:192.0.2.89 ] = [ane:L1] PV[ipv4:192.0.2.2][ipv4:203.0.113.45] = [ane:L1] E[ane:L1]["availbw"] = 50 After the second iteration: PV[ipv4:192.0.2.2][ipv4:192.0.2.89 ] = [ane:L1, ane:L3] PV[ipv4:192.0.2.2][ipv4:203.0.113.45] = [ane:L1, ane:L3] E[ane:L1]["availbw"] = 50 E[ane:L3]["availbw"] = 48 After the third iteration: PV[ipv4:192.0.2.2][ipv4:192.0.2.89 ] = [ane:L1, ane:L3, ane:L4] PV[ipv4:192.0.2.2][ipv4:203.0.113.45] = [ane:L1, ane:L3] E[ane:L1]["availbw"] = 50 E[ane:L3]["availbw"] = 48 E[ane:L4]["availbw"] = 55 After the fourth iteration: Gao, et al. Expires September 3, 2018 [Page 21]

Internet-Draft Compressing Path Vectors March 2018 PV[ipv4:192.0.2.2][ipv4:192.0.2.89 ] = [ane:L1, ane:L3, ane:L4] PV[ipv4:192.0.2.2][ipv4:203.0.113.45] = [ane:L1, ane:L3, ane:L5] E[ane:L1]["availbw"] = 50 E[ane:L3]["availbw"] = 48 E[ane:L4]["availbw"] = 55 E[ane:L5]["availbw"] = 60 Eventually, one can use the previous information to construct the endpoint cost service response. HTTP/1.1 200 OK Content-Length: [TBD] Content-Type: multipart/related; boundary=example-2 --example-2 Content-Type: application/alto-endpointcost+json { "meta": { "cost-types": [ {"cost-mode": "array", "cost-metric": "ane-path"} ] } "endpoint-cost-map": { "ipv4:192.0.2.2": { "ipv4:192.0.2.89": [ "ane:L1", "ane:L3", "ane:L4" ], "ipv4:203.0.113.45": [ "ane:L1", "ane:L4", "ane:L5" ] } } } --example-2 Content-Type: application/alto-propmap+json { "property-map": { "ane:L1": { "availbw": 50 }, "ane:L3": { "availbw": 48 }, "ane:L4": { "availbw": 55 }, "ane:L5": { "availbw": 60 }, } } --example-2-- Gao, et al. Expires September 3, 2018 [Page 22]

Internet-Draft Compressing Path Vectors March 2018 6.3. Compatibility When the path vector extension is used with other extensions, such as [I-D.ietf-alto-cost-calendar] and [I-D.ietf-alto-multi-cost], the decoding and the encoding MUST only apply on the path vector part and leave the other attributes as they are. Hence, this extension does not change the compatibility between the original path vector extension and other extensions. 7. Security Considerations This document does not introduce any privacy or security issue on ALTO servers not already present in the base ALTO protocol or in the path vector extension. The algorithms specified in this document can even help protect the privacy of network providers by conducting irreversible transformations on the original path vector. 8. IANA Considerations This document does not define any new media type or introduce any new IANA consideration. 9. Acknowledgments The authors would like to thank Dr. Qiao Xiang, Mr. Jingxuan Zhang (Tongji University), Prof. Jun Bi (Tsinghua University) and Dr. Andreas Voellmy (Yale University) for their early engagement and discussions. 10. References 10.1. Normative References [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997, <http://www.rfc-editor.org/info/rfc2119>. 10.2. Informative References [I-D.ietf-alto-cost-calendar] Randriamasy, S., Yang, Y., Wu, Q., Lingli, D., and N. Schwan, "ALTO Cost Calendar", draft-ietf-alto-cost- calendar-01 (work in progress), February 2017. Gao, et al. Expires September 3, 2018 [Page 23]

Internet-Draft Compressing Path Vectors March 2018 [I-D.ietf-alto-incr-update-sse] Roome, W. and Y. Yang, "ALTO Incremental Updates Using Server-Sent Events (SSE)", draft-ietf-alto-incr-update- sse-02 (work in progress), April 2016. [I-D.ietf-alto-multi-cost] Randriamasy, S., Roome, W., and N. Schwan, "Multi-Cost ALTO", draft-ietf-alto-multi-cost-10 (work in progress), April 2017. [I-D.ietf-alto-path-vector] Bernstein, G., Chen, S., Gao, K., Lee, Y., Roome, W., Scharf, M., Yang, Y., and J. Zhang, "ALTO Extension: Path Vector Cost Mode", draft-ietf-alto-path-vector-00 (work in progress), May 2017. [RFC7285] Alimi, R., Ed., Penno, R., Ed., Yang, Y., Ed., Kiesel, S., Previdi, S., Roome, W., Shalunov, S., and R. Woundy, "Application-Layer Traffic Optimization (ALTO) Protocol", RFC 7285, DOI 10.17487/RFC7285, September 2014, <http://www.rfc-editor.org/info/rfc7285>. [TELGEN83] Telgen, J., "Identifying Redundant Constraints and Implicit Equalities in Systems of Linear Constraints", Management Science , Volume 29, Issue 10, DOI 10.1287/mnsc.29.10.1209, 1983, <http://pubsonline.informs.org/doi/abs/10.1287/ mnsc.29.10.1209>. Authors' Addresses Kai Gao Tsinghua University 30 Shuangqinglu Street Beijing 100084 China Email: gaok12@mails.tsinghua.edu.cn Xin (Tony) Wang Tongji University 4800 CaoAn Road Shanghai 210000 China Email: xinwang2014@hotmail.com Gao, et al. Expires September 3, 2018 [Page 24]

Internet-Draft Compressing Path Vectors March 2018 Qiao Xiang Tongji/Yale University 51 Prospect Street New Haven, CT USA Email: qiao.xiang@cs.yale.edu Chen Gu Tongji University 4800 CaoAn Road Shanghai 210000 China Email: gc19931011jy@gmail.com Y. Richard Yang Yale University 51 Prospect St New Haven CT USA Email: yry@cs.yale.edu G. Robert Chen Huawei Nanjing China Email: chenguohai@huawei.com Gao, et al. Expires September 3, 2018 [Page 25]