DOCSLIB.ORG

Write-Efficient Algorithms

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Write-Efficient Algorithms Write-efficient algorithms 15-853: Algorithms in the Real World Yan Gu, May 2, 2018 Classic Algorithms Research …has focused on settings in which reads & writes to memory have equal cost But what if they have very DIFFERENT costs? How would that impact Algorithm Design? Emerging Memory Technologies Motivation: DRAM is volatile DRAM energy cost is significant (~35% energy on data centers) DRAM density (bits/area) is limited Promising candidates: Phase-Change Memory (PCM) Spin-Torque Transfer Magnetic RAM (STT-RAM) Memristor-based Resistive RAM (ReRAM) 3D XPoint Conductive-bridging RAM (CBRAM) Key properties: Persistent, significantly lower energy, can be higher density (10x+) Read latencies approaching DRAM, random-access Another Key Property: Writes More Costly than Reads In these emerging memory technologies, bits are stored as “states” of the given material No energy to retain state Small energy to read state - Low current for short duration Large energy to change state - High current for long duration Writes incur higher energy costs, higherPCM latency, and lower per-DIMM bandwidth (power envelope constraints) Why does it matter? Consider the energy issue and assume a read costs 0.1 nJ and a write costs 10 nJ Sorting algorithm 1: Sorting algorithm 2: 100푛 reads and 100푛 200푛 reads and 2푛 writes writes on 푛 elements on 푛 elements We can sort <1 million We can sort 25 million entries per joule entries per joule read cost write cost read cost write cost Why does it matter? Writes are significantly more costly than reads due to the cost to change the phases of materials higher latency, lower per-chip bandwidth, higher energy costs Higher latency → Longer time for a write → Decrease per-chip (memory) bandwidth Let the parameter 흎 > ퟏ be the cost for writes relative to reads Expected to be between 5 to 30 Evolution on the memory hierarchy CPU New non-volatileExternal Mainmemory Memory memory(Storage class(SSD, L3 (DRAM)memory)HDD) L1 L2 1.5ns 5ns 20ns Read100ns latency ~1004ms ns 64KB 256KB 32MB from64GB 128GB to TBhuge level Common latency / size for a current computer (server) Impacts on Real-World Computation Databases: the data that is kept in the external memory can now be on the main memory Graph processing: large social networks nowadays contain ~billion vertices and >100 billion edges Geometry applications: can handle more precise meshes that support better effects Summary The new non-volatile memory raises the challenge to design write-efficient algorithms What we need: Modified cost models New algorithms New techniques to support efficient computation (cache policy, scheduling, etc.) Experiment New Cost Models Random-Access Machine (RAM) Unit cost for: Any instruction on Θ(log 푛)-bit words Read/write a single memory location from an infinite memory Memory 1 CPU 1 Read/write asymmetry in RAM? A single write cost 휔 instead of 1 But every instruction writes something… Memory 1 CPU write cost 휔 1 흎 (푴, 흎)-Asymmetric RAM (ARAM) Comprise of: a symmetric small-memory (cache) of size 푀, and an asymmetric large-memory (main memory) of unbounded size, and an integer write cost 휔 I/O cost 푄: instructions on cache are free Asymmetric Large-Memory Small-Memory 1 CPU 0 푀 words write cost 휔 흎 (푴, 흎)-Asymmetric RAM (ARAM) Comprise of: a symmetric small-memory (cache) of size 푀, and an asymmetric large-memory (main memory) of unbounded size, and an integer write cost 휔 I/O cost 푄: instructions on cache are free time 푇: instructions on cache take ퟏ unit of time Asymmetric Large-Memory Small-Memory 1 CPU 0 1 푀 words write cost 휔 흎 Lower and Upper Bounds Warm up: Asymmetric sorting Comparison sort on 푛 elements Read and comparison (without writes): Ω(푛 log 푛) Write complexity: Ω(푛) Question: how to sort 푛 elements using 푂(푛 log 푛) instructions (reads) and 푂(푛) writes? Swap-based sorting (i.e. quicksort, heap sort) does not seem to work Mergesort requires strictly 푛 writes for log 푛 rounds Selection sort uses linear write, but not work (read) efficiency Warm up: Asymmetric sorting Comparison sort on 푛 elements Read complexity: Ω(푛 log 푛) Write complexity: Ω(푛) 7 The algorithm: inserting each key in random order into a binary search 3 9 tree. In-order traversing the tree gives the sorted array. (푂 log 푛 tree depth 1 5 w.h.p.) 4 Using balanced BSTs (e.g. AVL trees) gives a deterministic algorithm, but more careful analysis is required Trivial upper bounds 푀 = 푂(1) I/O cost 푄(푛) and Reduction Problem time 푇(푛) ratio Comparison sort Θ(푛 log 푛 + 휔푛) 푂(log 푛) Search tree, priority queue Θ(log 푛 + 휔) 푂(log 푛) 2D convex hull, triangulation 푂(푛 log 푛 + 휔푛) 푂(log 푛) BFS, DFS, SCC, topological sort, block, bipartiteness, Θ(푚 + 푛휔) 푂(푚/푛) floodfill, biconnected components Lower bounds I/O cost Problem Classic Lower bound Algorithm log 푛 log 푛 Sorting network Θ 휔푛 Θ 휔푛 log 푀 log 휔푀 log 푛 log 푛 Fast Fourier Transform Θ 휔푛 Θ 휔푛 log 푀 log 휔푀 Diamond DAG (LCS, 푛2휔 푛2휔 Θ Θ edit distance) 푀 푀 An example of a diamond DAG: Longest common sequence (LCS) A C G T A T A T C G A T An example of Diamond DAG: Longest common sequence (LCS) A C G T A T A 1 1 1 1 1 1 T 1 1 1 2 2 2 C 1 2 2 2 2 2 G 1 2 3 3 3 3 A 1 2 3 3 4 4 T 1 2 3 4 4 5 Computation DAG Rule DAG Rule / pebbling game: To compute the value of a node, must have the values at all incoming nodes High-level proof idea To show that for the computational DAG, there exists a partitioning of the DAG that I/O cost is lower bounded However, since read and write has different cost, previous techniques (e.g. [HK81]) cannot directly apply Standard Observations on DAG 2 A C G T A T DAG (or DP table) has size 푛 (Input size is only 2푛) A Building table explicitly 2 writes, T ⇒ 푛 C but problem only inherently requires writing last value G A T Compute some nodes in cache but don’t write them out Storage lower bound of subcomputation (diamond DAG rule, Cook and Sethi 1976): Solving an 푘 × 푘 sub-DAG requires 푘 space to store intermediate value For 푘 > 푀, some values need to be written out Storage lower bound of subcomputation (diamond DAG rule, Cook and Sethi 1976): Solving an 푘 × 푘 sub-DAG requires 푘 space to store intermediate value 푘 For 푘 > 푀, some values need to be written out Proof sketch of lower bound Computing any 2푀 × 2푀 diamond requires 푀 writes to the large-memory 2푀 storage space, 푀 from small-memory To finish computation, every 2푀 × 2푀 sub-DAG needs to 푛2 be computed, which leads to Ω writes 푀 2푀 푛2 푛2 Θ ⋅ Ω(푀) = Ω 푀2 푀 #sub-problem #write A matching algorithm for the lower bound 푛2 Lower bound: Θ writes 푀 푀 푀 This lower bound is tight when breaking down into × 2 2 sub-DAGs, and read & write-out the boundary only 푀/2 푛 푛2 2 ⋅ ⋅ 푛 = 푂 푀/2 푀 #row/column #read/write Upper bounds on graph algorithms I/O cost 푄(푛, 푚) Problem Classic algorithms New algorithms 푂(min(푛 휔 + 푚/푀 , Single-source 푂 휔 푚 + 푛 log 푛 휔 푚 + 푛 log 푛 , shortest-path 푚(휔 + log 푛))) Minimum 푂(min(푚휔, 푂 푚휔 spanning tree 푚 min(log 푛 , 푛/푀) + 휔푛)) I/O cost of Dijkstra’s algorithm Compute an SSSP requires 푂 푚 DECREASE-KEYs and 푂 푛 EXTRACT-MINs in Dijkstra’s algorithm Classic Fibonacci heap: 푂 휔 푚 + 푛 log 푛 Balanced BST: 푂 푚 휔 + log 푛 Restrict the Fibonacci heap into the small-memory with size 푀: no writes to the large-memory to maintain the heap, 푂 푛/푀 rounds to finish, 푂 푛 휔 + 푚/푀 I/O cost in total small-memory Fibonacci Heap large-memory Parallel Computational Model and Parallel Write-efficient Algorithms 6 + 15 + 15 = 36 A = 1 2 3 4 5 6 7 8 Sum(A): 36 Cut the input array into smaller segments, sum each up individually, and finally sum up the sums Picking the appropriate number of segments can be annoying Machine parameter, runtime environment, algorithmic details A = 1 2 3 4 5 6 7 8 + + + + 3 7 11 15 + + 10 26 + Sum(A): 36 Function SUM(A) If |A| = 1 then return A(1) In Parallel a = SUM(first half of A) b = SUM(second half of A) return a + b A = 1 2 3 4 5 6 7 8 + + + + 3 7 11 15 + + 10 26 + Sum(A): 36 A work-stealing scheduler can run a computation on 푝 cores using time: 푛 푂 + log 푛 The work-stealing scheduler 푝 is used in OpenMP, CilkPlus, Intel TBB, MS PPL, etc. A = 1 2 3 4 5 6 7 8 + + + + 3 7 11 15 + + 10 26 + Sum(A): 36 A work-stealing scheduler can 푊: total run a computation on 푝 cores computation using time: 푊 퐷: longest + 푂 퐷 chain of 푝 all paths A = 1 2 3 4 5 6 7 8 + + + + 3 7 11 15 + + 10 26 + Sum(A): 36 A work-stealing scheduler can 푊: 푂(푛) run a computation on 푝 cores using time: 퐷: 푂(log 푛) 푊 푂 휔 + 퐷 푃 Our new results on scheduler Assumptions: Each processor has its symmetric private cache Each processor can request to access data in other processor’s cache, but cannot write anything All communications are via asymmetric main memory Any non-leaf task uses constant stack space Our new results on scheduler Assumptions: Each processor has its symmetric private cache Each processor can request to access data in other processor’s cache, but cannot write anything All communications are via asymmetric main memory Any non-leaf task uses constant stack space With non-trivial but simple modifications to the work- stealing scheduler, a computation on 푝 cores use time: 푊 + 푂 휔퐷 푝 with memory size 푀 = 푂 퐷 + 푀퐿 (memory for base case) Results of parallel algorithms Problem Work (푊) Depth (퐷) Reduction of writes Reduce Θ 푛 + 휔 Θ log 푛 + 휔 Θ(log 푛) Ordered filter Θ 푛 + 휔푘 ↟ 푂 휔 log 푛 ↟ Θ(log 푛) Comparison sort Θ 푛 log 푛 + 푛휔 ↟ 푂 휔 log 푛 ↟ Θ(log 푛) List and tree Θ 푛 푂 휔 log 푛 ↟ Θ(휔) contraction Minimum 푂(훼 푛 푚 푚/(푛 ⋅ 푂 휔 polylog 푛 ↟ spanning tree + 휔푛 log(min(푚/푛, 휔))) log(min(푚/푛,
Load more

Recommended publications
  • Interval Trees Storing and Searching Intervals
    Interval Trees Storing and Searching Intervals • Instead of points, suppose you want to keep track of axis-aligned segments: • Range queries: return all segments that have any part of them inside the rectangle. • Motivation: wiring diagrams, genes on genomes Simpler Problem: 1-d intervals • Segments with at least one endpoint in the rectangle can be found by building a 2d range tree on the 2n endpoints. - Keep pointer from each endpoint stored in tree to the segments - Mark segments as you output them, so that you don’t output contained segments twice. • Segments with no endpoints in range are the harder part. - Consider just horizontal segments - They must cross a vertical side of the region - Leads to subproblem: Given a vertical line, find segments that it crosses. - (y-coords become irrelevant for this subproblem) Interval Trees query line interval Recursively build tree on interval set S as follows: Sort the 2n endpoints Let xmid be the median point Store intervals that cross xmid in node N intervals that are intervals that are completely to the completely to the left of xmid in Nleft right of xmid in Nright Another view of interval trees x Interval Trees, continued • Will be approximately balanced because by choosing the median, we split the set of end points up in half each time - Depth is O(log n) • Have to store xmid with each node • Uses O(n) storage - each interval stored once, plus - fewer than n nodes (each node contains at least one interval) • Can be built in O(n log n) time. • Can be searched in O(log n + k) time [k = #
    [Show full text]
  • 14 Augmenting Data Structures
    14 Augmenting Data Structures Some engineering situations require no more than a “textbook” data struc- ture—such as a doubly linked list, a hash table, or a binary search tree—but many others require a dash of creativity. Only in rare situations will you need to cre- ate an entirely new type of data structure, though. More often, it will suffice to augment a textbook data structure by storing additional information in it. You can then program new operations for the data structure to support the desired applica- tion. Augmenting a data structure is not always straightforward, however, since the added information must be updated and maintained by the ordinary operations on the data structure. This chapter discusses two data structures that we construct by augmenting red- black trees. Section 14.1 describes a data structure that supports general order- statistic operations on a dynamic set. We can then quickly find the ith smallest number in a set or the rank of a given element in the total ordering of the set. Section 14.2 abstracts the process of augmenting a data structure and provides a theorem that can simplify the process of augmenting red-black trees. Section 14.3 uses this theorem to help design a data structure for maintaining a dynamic set of intervals, such as time intervals. Given a query interval, we can then quickly find an interval in the set that overlaps it. 14.1 Dynamic order statistics Chapter 9 introduced the notion of an order statistic. Specifically, the ith order statistic of a set of n elements, where i 2 f1;2;:::;ng, is simply the element in the set with the ith smallest key.
    [Show full text]
  • 2 Dynamization
    6.851: Advanced Data Structures Spring 2010 Lecture 4 — February 11, 2010 Prof. Andr´eSchulz Scribe: Peter Caday 1 Overview In the previous lecture, we studied range trees and kd-trees, two structures which support efficient orthogonal range queries on a set of points. In this second of four lectures on geometric data structures, we will tie up a loose end from the last lecture — handling insertions and deletions. The main topic, however, will be two new structures addressing the vertical line stabbing problem: interval trees and segment trees. We will conclude with an application of vertical line stabbing to a windowing problem. 2 Dynamization In our previous discussion of range trees, we assumed that the point set was static. On the other hand, we may be interested in supporting insertions and deletions as time progresses. Unfortunately, it is not trivial to modify our data structures to handle this dynamic scenario. We can, however, dynamize them using general techniques; the techniques and their application here are due to Overmars [1]. Idea. Overmars’ dynamization is based on the idea of decomposable searches. A search (X,q) for the value q among the keys X is decomposable if the search result can be obtained in O(1) time from the results of searching (X1,q) and (X2,q), where X1 ∪ X2 = X. For instance, in the 2D kd-tree, the root node splits R2 into two halves. If we want to search for all points lying in a rectangle q, we may do this by combining the results of searching for q in each half.
    [Show full text]
  • Lecture Notes of CSCI5610 Advanced Data Structures
    Lecture Notes of CSCI5610 Advanced Data Structures Yufei Tao Department of Computer Science and Engineering Chinese University of Hong Kong July 17, 2020 Contents 1 Course Overview and Computation Models 4 2 The Binary Search Tree and the 2-3 Tree 7 2.1 The binary search tree . .7 2.2 The 2-3 tree . .9 2.3 Remarks . 13 3 Structures for Intervals 15 3.1 The interval tree . 15 3.2 The segment tree . 17 3.3 Remarks . 18 4 Structures for Points 20 4.1 The kd-tree . 20 4.2 A bootstrapping lemma . 22 4.3 The priority search tree . 24 4.4 The range tree . 27 4.5 Another range tree with better query time . 29 4.6 Pointer-machine structures . 30 4.7 Remarks . 31 5 Logarithmic Method and Global Rebuilding 33 5.1 Amortized update cost . 33 5.2 Decomposable problems . 34 5.3 The logarithmic method . 34 5.4 Fully dynamic kd-trees with global rebuilding . 37 5.5 Remarks . 39 6 Weight Balancing 41 6.1 BB[α]-trees . 41 6.2 Insertion . 42 6.3 Deletion . 42 6.4 Amortized analysis . 42 6.5 Dynamization with weight balancing . 43 6.6 Remarks . 44 1 CONTENTS 2 7 Partial Persistence 47 7.1 The potential method . 47 7.2 Partially persistent BST . 48 7.3 General pointer-machine structures . 52 7.4 Remarks . 52 8 Dynamic Perfect Hashing 54 8.1 Two random graph results . 54 8.2 Cuckoo hashing . 55 8.3 Analysis . 58 8.4 Remarks . 59 9 Binomial and Fibonacci Heaps 61 9.1 The binomial heap .
    [Show full text]
  • Efficient Data Structures for Range Searching on a Grid MARK H
    JOURNAL OF ALGORITHMS 9,254-275 (1988) Efficient Data Structures for Range Searching on a Grid MARK H. OVERMARS Department of Computer Science, University of Utrecht, The Netherlands Received February 17,1987; accepted May 15.1987 We consider the 2-dimensional range searching problem in the case where all points lie on an integer grid. A new data structure is presented that solves range queries on a U * U grid in O( k + log log U) time using O( n log n) storage, where n is the number of points and k the number of reported answers. Although the query time is very good the preprocessing time of this method is very high. A second data structure is presented that can be built in time O( n log n) at the cost of an increase in query time to O(k + m). Similar techniques are used for solving the line segment intersection searching problem in a set of axis-parallel line segments on a grid. The methods presented also yield efficient structures for dominance searching and searching with half-infinite ranges that use only O(n) storage. A generalization to multi-dimensional space, using a normalization approach, yields a static solution to the general range searching problem that is better than any known solution when the dimension is at least 3. Q 1988 Academic Press, Inc. 1. INTRODUCTION One of the problems in computational geometry that has received a large amount of attention is the range searching problem. Given a set of n points in a d-dimensional space, the range searching problem asks to store these points such that for a given range ([A, * .
    [Show full text]
  • Geometric Algorithms 7.3 Range Searching
    Geometric search: Overview Types of data. Points, lines, planes, polygons, circles, ... Geometric Algorithms This lecture. Sets of N objects. Geometric problems extend to higher dimensions. ! Good algorithms also extend to higher dimensions. ! Curse of dimensionality. Basic problems. ! Range searching. ! Nearest neighbor. ! Finding intersections of geometric objects. Reference: Chapters 26-27, Algorithms in C, 2nd Edition, Robert Sedgewick. Robert Sedgewick and Kevin Wayne • Copyright © 2005 • http://www.Princeton.EDU/~cos226 2 1D Range Search 7.3 Range Searching Extension to symbol-table ADT with comparable keys. ! Insert key-value pair. ! Search for key k. ! How many records have keys between k1 and k2? ! Iterate over all records with keys between k1 and k2. Application: database queries. insert B B insert D B D insert A A B D insert I A B D I Geometric intuition. insert H A B D H I ! Keys are point on a line. insert F A B D F H I ! How many points in a given interval? insert P A B D F H I P count G to K 2 search G to K H I Robert Sedgewick and Kevin Wayne • Copyright © 2005 • http://www.Princeton.EDU/~cos226 4 1D Range Search Implementations 2D Orthogonal Range Search Range search. How many records have keys between k1 and k2? Extension to symbol-table ADT with 2D keys. ! Insert a 2D key. Ordered array. Slow insert, binary search for k1 and k2 to find range. ! Search for a 2D key. Hash table. No reasonable algorithm (key order lost in hash). ! Range search: find all keys that lie in a 2D range? ! Range count: how many keys lie in a 2D range? BST.
    [Show full text]
  • Geometric Search
    Geometric Search range search quad- and kD-trees • range search • quad and kd trees intersection search • intersection search VLSI rules checking • VLSI rules check References: Algorithms 2nd edition, Chapter 26-27 Intro to Algs and Data Structs, Section Copyright © 2007 by Robert Sedgewick and Kevin Wayne. 3 Overview 1D Range Search Types of data. Points, lines, planes, polygons, circles, ... Extension to symbol-table ADT with comparable keys. This lecture. Sets of N objects. ! Insert key-value pair. ! Search for key k. ! Geometric problems extend to higher dimensions. How many records have keys between k1 and k2? ! ! Good algorithms also extend to higher dimensions. Iterate over all records with keys between k1 and k2. ! Curse of dimensionality. Application: database queries. Basic problems. ! Range searching. insert B B ! Nearest neighbor. insert D B D insert A A B D ! Finding intersections of geometric objects. Geometric intuition. insert I A B D I ! Keys are point on a line. insert H A B D H I ! How many points in a given interval? insert F A B D F H I insert P A B D F H I P count G to K 2 search G to K H I 2 4 1D Range search: implementations 2D Orthogonal range Ssearch: Grid implementation Range search. How many records have keys between k1 and k2? Grid implementation. [Sedgewick 3.18] ! Divide space into M-by-M grid of squares. ! Ordered array. Slow insert, binary search for k1 and k2 to find range. Create linked list for each square. Hash table. No reasonable algorithm (key order lost in hash).
    [Show full text]
  • Lecture Range Searching II: Windowing Queries
    Computational Geometry · Lecture Range Searching II: Windowing Queries INSTITUT FUR¨ THEORETISCHE INFORMATIK · FAKULTAT¨ FUR¨ INFORMATIK Tamara Mchedlidze · Darren Strash 23.11.2015 1 Dr. Tamara Mchedlidze · Dr. Darren Strash · Computational Geometry Lecture Range Searching II Object types in range queries y0 y x x0 Setting so far: Input: set of points P (here P ⊂ R2) Output: all points in P \ [x; x0] × [y; y0] Data structures: kd-trees or range trees 2 Dr. Tamara Mchedlidze · Dr. Darren Strash · Computational Geometry Lecture Range Searching II Object types in range queries y0 y0 y x x0 y x x0 Setting so far: Further variant Input: set of points P Input: set of line segments S (here P ⊂ R2) (here in R2) Output: all points in Output: all segments in P \ [x; x0] × [y; y0] S \ [x; x0] × [y; y0] Data structures: kd-trees Data structures: ? or range trees 2 Dr. Tamara Mchedlidze · Dr. Darren Strash · Computational Geometry Lecture Range Searching II Axis-parallel line segments special case (e.g., in VLSI design): all line segments are axis-parallel 3 Dr. Tamara Mchedlidze · Dr. Darren Strash · Computational Geometry Lecture Range Searching II Axis-parallel line segments special case (e.g., in VLSI design): all line segments are axis-parallel Problem: Given n vertical and horizontal line segments and an axis-parallel rectangle R = [x; x0] × [y; y0], find all line segments that intersect R. 3 Dr. Tamara Mchedlidze · Dr. Darren Strash · Computational Geometry Lecture Range Searching II Axis-parallel line segments special case (e.g., in VLSI design): all line segments are axis-parallel Problem: Given n vertical and horizontal line segments and an axis-parallel rectangle R = [x; x0] × [y; y0], find all line segments that intersect R.
    [Show full text]
  • Geometric Structures 7 Interval Tree
    Geometric Structures 1. Interval, segment, range trees Martin Samuelčík [email protected], www.sccg.sk/~samuelcik, I4 Window and Point queries • For given points, find all of them that are inside given d-dimensional interval • For given d-dimensional intervals, find all of them that contain one given point • For given d-dimensional intervals, find all of them that have intersection with another d- dimensional interval • d-dimensional interval: interval, rectangle, box, • Example for 1D: – Input: set of n intervals, real value q – Output: k intervals containing value q Geometric Structures 2 Motivation Find all buildings in given rectangle. Geometric Structures 3 Motivation Find building under given point Geometric Structures 4 Motivation Find all points in viewing frustum. Geometric Structures 5 Motivation • Approximation of objects using axis-aligned bounding box (AABB) – used in many fields • Solving problem for AABB and after that solving for objects itself Geometric Structures 6 Interval tree • Binary tree storing intervals • Created for finding intervals containing given value • Input: Set S of closed one-dimensional intervals, real value xq • Output: all intervals I S such that xq I • S = {[li, ri] pre i = 1, …, n} Geometric Structures 7 Node of interval tree • X – value, used to split intervals for node • Ml – ordered set of intervals containing split value X, ascending order of minimal values of intervals • Mr– ordered set of intervals containing split value X, descending order of maximal values of intervals • Pointer to left
    [Show full text]
  • Enhanced Interval Trees for Dynamic IP Router-Tables ∗
    Enhanced Interval Trees for Dynamic IP Router-Tables ∗ Haibin Lu Sartaj Sahni {halu,sahni}@cise.ufl.edu Department of Computer and Information Science and Engineering University of Florida, Gainesville, FL 32611 Abstract We develop an enhanced interval tree data structure that is suitable for the representation of dynamic IP router tables. Several refinements of this enhanced structure are proposed for a variety of IP router tables. For example, the data structure called BOB (binary tree on binary tree) is developed for dynamic router tables in which the rule filters are nonintersecting ranges and in which ties are broken by selecting the highest-priority rule that matches a destination address. Prefix filters are a special case of nonintersecting ranges and the commonly used longest-prefix tie breaker is a special case of the highest-priority tie breaker. When an n-rule router table is represented using BOB, the 2 highest-priority rule that matches a destination address may be found in O(log n) time; a new rule may be inserted and an old one deleted in O(log n) time. For general ranges, the data structure CBOB (compact BOB is proposed). For the case when all rule filters are prefixes, the data structure PBOB (prefix BOB) permits highest-priority matching as well as rule insertion and deletion in O(W ) time, where W is the length of the longest prefix, each. When all rule filters are prefixes and longest-prefix matching is to be done, the data structures LMPBOB (longest matching-prefix BOB) permits longest- prefix matching in O(W ) time; rule insertion and deletion each take O(log n) time.
    [Show full text]
  • The Relational Interval Tree: Manage Interval Data Efficiently in Your Relational Database
    Database and Information Systems Institute for Computer Science University of Munich ______________________________________________________ The Relational Interval Tree: Manage Interval Data Efficiently in Your Relational Database Executive Summary & Technical Presentation June 2000 ______________________________________________________ Professor Hans-Peter Kriegel Institute for Computer Science, University of Munich Oettingenstr. 67, 80538 Munich Germany phone: ++49-89-2178-2191 (-2190) fax: ++49-89-2178-2192 e-mail: [email protected] http: www.dbs.informatik.uni-muenchen.de The Relational Interval Tree1: Manage Interval Data Efficiently in Your Relational Database Executive Summary Modern database applications show a growing demand for efficient and dynamic mana- gement of intervals, particularly for temporal and spatial data or for constraint handling. Common approaches require the augmentation of index structures which, however, is not supported by existing relational database systems. By design, the new Relational Interval Tree1 employs built-in indexes on an as-they-are basis and has a low implementation complexity. The relational database products you are offering already support the efficient integration of the Relational Interval Tree. There- fore, they can be easily provided with a sophisticated interval management that is dedi- cated to meet the demands of todays customers. Key Benefits • General applicability to all kinds of interval domains (e.g., temporal, spatial) • Superior performance to competing interval
    [Show full text]
  • Lecture 15: Windowing Queries
    Motivation Segment trees Windowing again Windowing queries Computational Geometry Lecture 15: Windowing queries Computational Geometry Lecture 15: Windowing queries Motivation Segment trees Windowing queries Windowing again Windowing Zoom in; re-center and zoom in; select by outlining Computational Geometry Lecture 15: Windowing queries Motivation Segment trees Windowing queries Windowing again Windowing Computational Geometry Lecture 15: Windowing queries Motivation Segment trees Windowing queries Windowing again Windowing Given a set of n axis-parallel line segments, preprocess them into a data structure so that the ones that intersect a query rectangle can be reported efficiently Computational Geometry Lecture 15: Windowing queries Motivation Segment trees Windowing queries Windowing again Windowing Given a set of n arbitrary, non-crossing line segments, preprocess them into a data structure so that the ones that intersect a query rectangle can be reported efficiently Computational Geometry Lecture 15: Windowing queries Motivation Segment trees Windowing queries Windowing again Windowing Two cases of intersection: An endpoint lies inside the query window; solve with range trees The segment intersects a side of the query window; solve how? Computational Geometry Lecture 15: Windowing queries Motivation Segment trees Windowing queries Windowing again Using a bounding box? If the query window intersects the line segment, then it also intersects the bounding box of the line segment (whose sides are axis-parallel segments) So we could search
    [Show full text]