A Sorted Partitioning Approach to High- speed and Fast-update - PowerPoint PPT Presentation

24th IEEE International Conference on Network Protocols (ICNP 2016) github.com/sorrachai/ParHtonSort A Sorted Partitioning Approach to High- speed and Fast-update OpenFlow Classification Sorrachai Yingchareonthawornchai, James Daly, Alex X. Liu, Eric Torng November 9 th , 2016

Motivation • SoIware-defined networking: • Performance boPleneck: lookup process • OpenFlow places new demands on packet classifiers • Incremental Update ( ~ 1 microseconds per update) • Dimensional Scalability ( 5 in tradiHonal, up-to 45 fields in OpenFlow 1.5 and higher) • TradiHonal packet classificaHon focus on fast classificaHon • but not for so fast on update • Current pracHces (e.g., Open vSwitch) use Tuple Space Search (TSS) • which has fast update, but slow classificaHon

Problem Statement New challenges for OpenFlow packet classificaHon, (1) Dynamism of Rules (2) High number of dimensions/fields *Figures from [Pankaj Gupta, et al, Algorithms for Packet ClassificaHon]

Related Work • Decision Trees (HiCuts, HyperCuts, HyperSplit) • Fast classificaHon, but slow update (rule replicaHon) • ParHHoning Methods • Fast update, but slow classificaHon (too many parHHons) (Tuple Space Search) • Slow update, fast classificaHon (SAX-PAC, Independent Set) • Decision Trees + ParHHoning (EffiCuts, SmartSplit) • Slow update

Algorithms Classifica0on Update Space Linear Search O(dn) O(d) O(dn) Tuple Space O(dT) O(d) O(dn) Search Ω (n 2 ) Decision Trees O(log n) O(n) Challenge : achieving both (1) fast packet classificaHon and (2) fast rule update d – number of fields n – number of rules T – number of sub-partitions

Algorithms Classifica0on Update Space Linear Search O(dn) O(d) O(dn) Tuple Space O(dT) O(d) O(dn) Search Ω (n 2 ) Decision Trees O(log n) O(n) Proposed: O(dT’+ T’ log n) O(dT’ + T’ log n) O(dn) ParHHonSort d – number of fields n – number of rules T – number of sub-partitions

Algorithms Classifica0on Update Space Linear Search O(dn) O(d) O(dn) Tuple Space O(dT) O(d) O(dn) Search Ω (n 2 ) Decision Trees O(log n) O(n) Proposed: O(dT’+ T’ log n) O(dT’ + T’ log n) O(dn) ParHHonSort fast classificaHon and fast update if T’ is small

Current state of the art 100 Decision Trees Update Time 2 1 Tuple Space Search 1 2 3 Classification Time

Current state of the art 100 Decision Trees Update Time 2 1 Proposed Tuple Space Search 1 2 3 Classification Time

Proposed Approach Define “Sortable” Rules r 1 r 2 … < f < f r n < f Fast search and update with linear space

PartitionSort 1. Ruleset Sortability r 1 r 2 < f Fast Matching 2. MulH-dimensional Interval Tree Fast Update (MITree) Linear Memory 3. Sortable Ruleset ParHHoning Graph Coloring: 1 color, 1 BST 4. Online ParHHoning Sequence of Intermixed InserHons and DeleHons

Ruleset Sortability: Lexical Field Order Comparison Defini0on : Given field order F, rule 1 < rule 2 if on projecHon on F[1] If non-intersecHng, interval 1 < interval 2 If idenHcal, rule 1 < rule2 on projecHon on of next field recursively Else, rule 1 || rule 2 Defini0on : Rules are sortable if there exists field ordering that has total order

Ruleset Sortability: Lexical Field Order Comparison y X(r 2 ) = X(r 3 ) r 3 r 1 r 2 r 1 r 2 x r 1 r 2 r 1 || r 2 < XY < XY r 3

Sortable Ruleset Partitioning

Sortable Ruleset Partitioning • ObjecHve: minimize number of sortable subsets • Main Idea: • repeatedly find the maximal sortable subset • Challenges: • d! field ordering! • Need an efficient algorithm for maximal sortable subset • Proposed: • Greedy field selecHon: repeatedly find a field with maximum sortability • For each unselected field, sortability = number of maximum non-intersecHng intervals • Pick a field with maximum sortability

Example (a) Selected field: {} r 3 r 4 r 5 r 6 r 7 r 1 r 2 X: r 3 r 6 r 7 Y: r 5 r 4 r 2 r 1

Example Discarded (a) Selected field: {} r 3 r 4 r 5 r 6 r 7 r 1 r 2 X: MWIS: 4 Partition 1 Partition 2 r 3 r 6 r 7 Y: r 5 MWIS : 3 r 4 r 2 r 1

Example Discarded (a) Selected field: {} r 3 r 4 r 5 r 6 r 7 r 1 r 2 X: MWIS: 4 Partition 1 Partition 2 r 3 r 6 r 7 Y: r 5 MWIS : 3 r 4 r 2 r 1 (b) Selected field: x Partition 2 r 7 r 6 Y: MWIS: 4 r 2 r 1 Partition 1 (c) Selected fields: xy with {r 1 r 2 r 7 r 6 } in total order xy

Properties of GreedyFieldSelection • Discover “good” field order and • Find maximal sortable subset simultaneously • Complexity: O(d 2 n log n)

Online Sortable Ruleset Partitioning • How to perform update? • Given rule r, test for each tree if r can insert • If not, create a new tree of the rule r • Problem: • Number of trees can be large • Ad-hoc soluHon: • periodically reparHHon using the previous algorithm • Not acceptable in OpenFlow packet classificaHon!

Online Sortable Ruleset Partitioning • Proposed SoluHon: Adap(ve Field Ordering • Given rule r, test for each tree if r can insert • Once inserted, if tree size is less than T, run sortable parHHoning on this subset to find a bePer ordering • This is fast due to small size of tree (T = 10) • Work in completely online manner • No need to know a sequence of rules a priori

Experimental Results • Compare with SmartSplit, TupleSpace, SAX-PAC • ClassificaHon Time, Update Time, Memory usage, ConstrucHon Time • Internal comparison: Offline vs. Online ParHHon • Run over 500 rulesets consisHng of ACL, FW, IPC from ClassBench • Ranging number from 1k,2k,4k,8k,16k,32k,64k • Ranging dimensions from 5,10,15,20 • Each size has mulHple of 5 rulesets • Classify 1m packets, update 1m intermixed requests • We run online construcHon by default

On average, ParHHonSort is 7.2x faster on classificaHon, but 1.7x slower on update On average, ParHHonSort can classify 4.5 Mpps with 0.65 microsecond update Hme

Conclusion 100 SmartSplit Update Time 2 1 PartitionSort Tuple Space Search 1 2 3 Classification Time

Final Note • ParHHonSort is available on Github hPps://github.com/sorrachai/ParHtonSort • SimulaHon and benchmark are available including implementaHons of other packet classifiers • Packet generator (by Classbench API) • Rule generator (by Classbench API) • Packet ClassificaHon Simulator (New) • You can implement your own packet classifier and compare! • QuesHons?

Appendix

PartitionSort vs. SaxPac