DOCSLIB.ORG

Performance Evaluation of Approximate Priority Queues

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Performance Evaluation of Approximate Priority Queues Performance Evaluation of Approximate Priority Queues y z Yossi Matias Suleyman Cenk Sahinalp Neal E Young June Abstract We rep ort on implementation and a mo dest exp erimental evaluation of a recently intro duced priorityqueue data structure The new data structure is designed to takeadvantage of fast op erations on machine words and as appropriate reduced keyuniverse size andor tolerance of approximate answers to queries In addition to standard priorityqueue op erations the data structure also supp orts successor and predecessor queries Our results suggest that the data structure is practical and can b e faster than traditional priority queues when holding a large number of keys and that tolerance for approximate answers can lead to signicant increases in sp eed Bell Lab oratories Mountain Ave Murray Hill NJ matiasresearchb elll abscom y Bell Lab oratories Mountain Ave Murray Hill NJ jenkresearchb ellla bscom The author was also aliated with Department of Computer Science University of Maryland College Park MD when the exp eriments were conducted z Department of Computer Science Dartmouth College Hanover NH neycsdartmouthedu speedup n An employers demand for accelerated output without increasedpay Websters dictionary Intro duction A priority queue is an abstract data typ e consisting of a dynamic set of data items with the following op erations inserting an item deleting the item whose key is the maximum or minimum among the keys of all items The variants describ ed in this pap er also supp ort the following op erations deleting an item with any given key nding the item with the minimum or the maximum key checking for an item with a given key checking for the item with the largest key smaller than a given key and checking for the item with the smallest key larger than a given key Priority queues are widely used in many applications including shortest path algorithms com putation of minimum spanning trees and heuristics for NPhard problems eg TSP For many applications priority queue op erations esp ecially deleting the minimum or maximum key are the dominant factor in the p erformance of the application Priority queues have b een extensively ana lyzed and numerous implementations and empirical studies exist see eg AHU Meh Jon SV LL This note presents an exp erimental evaluation of one of the priority queues recently intro duced in MVY the wordbased radix tree This data structure is qualitativ ely dierent than tra ditional priority queues in that its time p er op eration do es not increase as the number of keys grows in fact it can decrease Instead as in the van Emde Boas data structure vKZ the running time dep ends on the size of the universe the set of p ossible keys which is assumed to b e f Ug for some integer U Most notably the data structure is designed to take advantage of any tolerance the application has for working with approximate rather than exact key values The greater the tolerance for approximation the smaller the eective universe size and so the greater the sp eedup More sp ecically supp ose that the data structure is implemented on a machine whose basic word size is b bits When no approximation error is allowed the running time of each op eration on the data structure is exp ected to b e close to c lg U lg b for some c It is exp ected to b e signicantly faster when a relative error tolerance is allowed In this case eachkey k is mapp ed to a smaller approximate key k dlg k e resulting in an eective universe U that is b and the relative considerably smaller In particular when the universe size U is smaller than j error is for nonnegativeinteger j then the running time of each op eration on the data structure is exp ected to b e close to c j lg b for some constant c The data structure is also unusual in that it is designed to takeadvantage of fast bitbased op erations on machine words Previouslysuch op erations were used in the context of theoretical priority queues such as those of Fredman and Willard FWa FWb Wil which are often considered nonpractical In contrast the data structure considered here app ears to b e simple to implement and to have small constants it is therefore exp ected at least in theory to b e a candidate for a comp etitive practical implementation as long as the bitbased op erations can b e supp orted eciently In this pap er wereportonanimplementation of the wordbased radix tree on a demonstration of the eectiveness of approximation for improved p erformance and on a mo dest exp erimental testing whichwas designed to study to what extent the ab ove theoretical exp ectations hold in practice Sp ecically our exp erimental study considers the following questions What maybeatypical constant c for the radix tree data structure with no approximation tolerance in the estimated running time of c lg U lg b What maybeatypical constant c for the radix tree data structure with approximation error for which the estimated running time is approximately c lg b and How do es the p erformance of the radix tree implementations compare with traditional priority queue implementations and what maybeatypical range of parameters for whichitmay b ecome comp etitive in practice We study two implementations of the radix tree one topdown the other bottomup The latter variant is more exp ensive in terms of memory usage but it has b etter time p erformance The main b o dy of the tests timed these two implementations on numerous randomly generated sequences varying the universe size U over the set f g the n umb er of op erations N over the set f g and the approximation tolerance over the set f U g where the case corresp onds to no tolerance for approximation The tests were p erformed on a single no de of an SGI Power Challenge with Gbytes of main memory The sequences are of three given typ es inserts only insertsfollowed by deleteminimums and inserts followed by mixed op erations Based on the measured running times we identify reasonable estimates to the constants c and c for which the actual running time deviates from the estimated running time byatmostabout The b ottomup radix tree was generally faster than the topdown one sometimes signicantly so For sequences with enough insertions the radix trees were faster than the traditional priority queues sometimes signicantly so The Data Structure We describ e the the topdown and the bottomup variants of the wordbased radix tree priority queue Both implementations are designed to takeadvantage of any tolerance of approximation in the application Sp ecically if an approximation error of is tolerated then each given key k is mapp ed b efore use to the approximate key k dlg k e details are given b elow This ensures that for instance the findminimum op eration will return an element at most times the true minimum Op erating on approximate keys reduces the universe size to the eective universe size U For completeness wegive the following general expression for U according to our implementation dlgdlgU eedlge if U U if Both the topdown and b ottomup implementations of the wordbased radixtree maintain a complete bary tree with U leaves where b is the numb er of bits p er machine word on the host computer here we test only b Each leaf holds the items having a particular approximate key value k The time p er op eration for b oth implementations is upp er b ounded by a constant times the number of levels in the tree whichis lg lg U lg if b b levels U dlg U e b lg U if b b For U and for b apower of two weget d lg be if levels U d lg U lg be if For all parameter values we test the ab ove inequality is tight with the number of levels ranging from to and the numb er of leaves ranging from to As mentioned ab ove each leaf of the tree holds the items having a particular approximate key value Eachinterior no de holds a single machine word whose ith bit indicates whether the ith subtree is empty The topdown variant allo cates memory only for no des with nonempty subtrees Each such no de in addition to the machine word also holds an arrayof b pointers to its children An item with a giv en key is found by starting at the ro ot and following p ointers to the appropriate leaf It examines a no des word to navigate quickly through the no de For instance to nd the index of the leftmost nonempty subtree it determines the most signicant bit of the word If a leaf is inserted or deleted the bits of the ancestors words are up dated as necessary The b ottomup variant preallo cates a single machine word for every interior no de emptyor not The word is stored in a xed p osition in a global arraysonopointers are needed The items with identical keys are stored in a doubly linked list which is accessible from the corresp onding leaf Each op eration is executed by up dating the appropriate item of the leaf and then up dating the ancestors words bymoving up the tree This typically will terminate b efore reaching the ro ot for instance an insert needs only to up date the ancestors whose subtrees were previously empty Details on implementations of the data structure and word op erations Belowwe describ e how the basic op erations are implemented in each of our data structures We also describ e implementations of the wordbased op erations we require Computing approximate keys j Given a key k this is howwe compute the approximate key k assuming for some nonnegativeinteger j Leta a a b e the binary representation of a key k U where B B B dlg U e Let m maxfi a g b e
Load more

Recommended publications
  • KP-Trie Algorithm for Update and Search Operations
    The International Arab Journal of Information Technology, Vol. 13, No. 6, November 2016 KP-Trie Algorithm for Update and Search Operations Feras Hanandeh1, Mohammed Akour2, Essam Al Daoud3, Rafat Alshorman4, Izzat Alsmadi5 1Dept. of Computer Information Systems, Faculty of Prince Al-Hussein Bin Abdallah II For Information Technology, Hashemite University, Zarqa, Jordan, [email protected] 2,5Dept. of Computer Information Systems, Faculty of Information Technology, Yarmouk University, Irbid, Jordan, [email protected], [email protected] 3,4Computer Science Department, Zarqa University [email protected]; [email protected] Abstract: Radix-Tree is a space optimized data structure that performs data compression by means of cluster nodes that share the same branch. Each node with only one child is merged with its child and is considered as space optimized. Nevertheless, it can't be considered as speed optimized because the root is associated with the empty string . Moreover, values are not normally associated with every node; they are associated only with leaves and some inner nodes that correspond to keys of interest. Therefore, it takes time in moving bit by bit to reach the desired word. In this paper we propose the KP-Trie which is consider as speed and space optimized data structure that is resulted from both horizontal and vertical compression. Keywords: Trie, radix tree, data structure, branch factor, indexing, tree structure, information retrieval. 1- Introduction The concept of Data structures such as trees has developed since the 19th century. Tries evolved from trees. They have different names Data structures are a specialized format for such as: Radix tree, prefix tree compact trie, efficient organizing, retrieving, saving and bucket trie, crit bit tree, and PATRICIA storing data.
    [Show full text]
  • The Adaptive Radix Tree
    Department of Informatics, University of Z¨urich MSc Basismodul The Adaptive Radix Tree Rafael Kallis Matrikelnummer: 14-708-887 Email: [email protected] September 18, 2018 supervised by Prof. Dr. Michael B¨ohlenand Kevin Wellenzohn 1 1 Introduction The goal of this project is to study and implement the Adaptive Radix Tree (ART), as proposed by Leis et al. [2]. ART, which is a trie based data structure, achieves its performance, and space efficiency, by compressing the tree both vertically, i.e., if a node has no siblings it is merged with its parent, and horizontally, i.e., uses an array which grows as the number of children increases. Vertical compression reduces the tree height and horizontal compression decreases a node's size. In Section 3 we describe how ART is constructed by applying vertical and horizontal compression to a trie. Next, we describe the point query procedure, as well as key deletion in Section 4. Finally, a benchmark of ART, a red-black tree and a hashtable is presented in Section 5. 2 Background - Tries A trie [1] is a hierarchical data structure which stores key-value pairs. Tries can answer both point and range queries efficiently since keys are stored in lexicographic order. Unlike a comparison-based search tree, a trie does not store keys in nodes. Rather, the digital representation of a search key is split into partial keys used to index the nodes. When constructing a trie from a set of keys, all insertion orders result in the same tree. Tries have no notion of balance and therefore do not require rebalancing operations.
    [Show full text]
  • Artful Indexing for Main-Memory Databases
    Indexing for Main-Memory data systems: The Adaptive Radix Tree (ART) Ivan Sinyagin Memory Wall Why indexes ? Best data structure O(1) ? Binary Search ! Binary Search • Cache utilization is low • Only first 3-5 cache lines have good temporal locality • Only the last cache line has spacial locality • Updates in a sorted array are expensive Trees T-tree • Sorted array split into balanced BST with fat nodes (~ cache lines) • Better than RB/AVL • Updates faster, but still expensive • Similar to BS: useless data movement to CPU (useful only min and max) • Developed in mid 80s and still(!) used in many DBMS B+ tree • B+ tree • Fanout => minimize random access by shallowing the tree • Keys fit into a cache line • Increased cache utilization (all keys are useful) • 1 useful pointer • Pipeline stalls - conditional logic • Still expensive updates: splitting & rebalancing CSB+ tree CSB+ tree • ~ 1999-2000 • Improved space complexity • Great cache line utilization: keys + 1 pointer • Node size ~ cache line • Update overhead - more logic to balance Can we do better ? • Less conditional logic • Cheap updates: no rebalancing, no splitting • Preserve order => tree • Preserve few random accesses (low height) • Preserve cache line utilization • Preserve space complexity Tries Radix Tree Implicit keys Space complexity Radix Tree span • k bits keys => k/s inner levels and 2^s pointers • 32 bit keys & span=1 => 32 levels & 2 pointers • 32 bit keys & span=2 => 16 levels & 4 pointers • 32 bit keys & span=3 => 11 levels & 8 pointers • 32 bit keys & span=4 => 8
    [Show full text]
  • STAT 534 Lecture 4 April, 2019 Radix Trees C 2002 Marina Meil˘A [email protected]
    STAT 534 Lecture 4 April, 2019 Radix trees c 2002 Marina Meil˘a [email protected] Reading CLRS Exercise 12–2 page 269. 1 Representing sets of strings with radix trees Radix trees are used to store sets of strings. Here we will discuss mostly binary strings, but they can be extended easily to store sets of strings over any alphabet. Below is an example of a radix tree that stores strings over the alphabet {0, 1} (binary strings). Each left-going edge is labeled with a 0 and each right-going edge with a 1. Thus, the path to any node in the tree is uniquely described as a string of 0’s and 1’s. The path to the root is the empty string “–”. For example, the path to the leftmost node in the tree is the string “0”; the path to the lowest node in the tree is the string “1011”. Note that there can be at most 2 strings of length 1, at most 4 strings of length 2, and at most 2h strings of length h. All the strings of a given length are at the same depth in the tree. A prefix of the string a =(a1a2 ...an) is any “beginning part” of a, i.e any ′ ′ ′ ′ ′ string a = (a1a2 ...ak) with k < n such that ai = ai for i = 1,...k. Ina radix tree, if node b is an ancestor of node a, then the string represented by b is a prefix of the string (represented by) a. For example, “10” is a prefix and an ancestor of “100”.
    [Show full text]
  • Wormhole: a Fast Ordered Index for In-Memory Data Management
    Wormhole: A Fast Ordered Index for In-memory Data Management Xingbo Wu†, Fan Ni‡, and Song Jiang‡ †University of Illinois at Chicago ‡University of Texas at Arlington Abstract 94% of query execution time in today’s in-memory databases [17]. Recent studies have proposed many op- In-memory data management systems, such as key-value timizations to improve them with a major focus on hash- stores, have become an essential infrastructure in today’s table-based key-value (KV) systems, including efforts big-data processing and cloud computing. They rely on on avoiding chaining in hash tables, improving memory efficient index structures to access data. While unordered access through cache prefetching, and exploiting paral- indexes, such as hash tables, can perform point search lelism with fine-grained locking [10, 21, 35]. With these with O(1) time, they cannot be used in many scenarios efforts the performance of index lookup can be pushed where range queries must be supported. Many ordered close to the hardware’s limit, where each lookup needs indexes, such as B+ tree and skip list, have a O(logN) only one or two memory accesses to reach the requested lookup cost, where N is number of keys in an index. For data [21]. an ordered index hosting billions of keys, it may take Unfortunately, the O(1) lookup performance and ben- more than 30 key-comparisons in a lookup, which is an efits of the optimizations are not available to ordered order of magnitude more expensive than that on a hash indexes used in important applications, such as B+ tree table.
    [Show full text]
  • (Fall 2019) :: Tree Indexes II
    Tree Indexes 08 Part II Intro to Database Systems Andy Pavlo 15-445/15-645 Computer Science Fall 2019 AP Carnegie Mellon University 2 UPCOMING DATABASE EVENTS Vertica Talk → Monday Sep 23rd @ 4:30pm → GHC 8102 CMU 15-445/645 (Fall 2019) 3 TODAY'S AGENDA More B+Trees Additional Index Magic Tries / Radix Trees Inverted Indexes CMU 15-445/645 (Fall 2019) 4 B+TREE: DUPLICATE KEYS Approach #1: Append Record Id → Add the tuple's unique record id as part of the key to ensure that all keys are unique. → The DBMS can still use partial keys to find tuples. Approach #2: Overflow Leaf Nodes → Allow leaf nodes to spill into overflow nodes that contain the duplicate keys. → This is more complex to maintain and modify. CMU 15-445/645 (Fall 2019) 5 B+TREE: APPEND RECORD ID 5 9 <5 <9 ≥9 1 3 6 7 8 9 13 <Key,RecordId> CMU 15-445/645 (Fall 2019) 5 B+TREE: APPEND RECORD ID Insert 6 5 9 <5 <9 ≥9 1 3 6 7 8 9 13 <Key,RecordId> CMU 15-445/645 (Fall 2019) 5 B+TREE: APPEND RECORD ID Insert <6,(Page,Slot)> 5 9 <5 <9 ≥9 1 3 6 7 8 9 13 <Key,RecordId> CMU 15-445/645 (Fall 2019) 5 B+TREE: APPEND RECORD ID Insert <6,(Page,Slot)> 5 9 <5 <9 ≥9 1 3 6 7 8 9 13 <Key,RecordId> CMU 15-445/645 (Fall 2019) 5 B+TREE: APPEND RECORD ID Insert <6,(Page,Slot)> 5 9 <5 <9 1 3 6 7 8 7 8 9 13 <Key,RecordId> CMU 15-445/645 (Fall 2019) 5 B+TREE: APPEND RECORD ID Insert <6,(Page,Slot)> 5 97 9 <5 <9 1 3 6 7 8 7 8 9 13 <Key,RecordId> CMU 15-445/645 (Fall 2019) 5 B+TREE: APPEND RECORD ID Insert <6,(Page,Slot)> 5 97 9 <5 <9 <9 ≥9 1 3 6 76 8 7 8 9 13 <Key,RecordId> CMU 15-445/645 (Fall 2019) 6 B+TREE: OVERFLOW LEAF NODES Insert 6 5 9 <5 <9 ≥9 1 3 6 7 8 9 13 6 CMU 15-445/645 (Fall 2019) 6 B+TREE: OVERFLOW LEAF NODES Insert 6 5 9 Insert 7 <5 <9 ≥9 1 3 6 7 8 9 13 6 7 CMU 15-445/645 (Fall 2019) 6 B+TREE: OVERFLOW LEAF NODES Insert 6 5 9 Insert 7 <5 <9 ≥9 Insert 6 1 3 6 7 8 9 13 6 7 6 CMU 15-445/645 (Fall 2019) 7 DEMO B+Tree vs.
    [Show full text]
  • Hyperion: Building the Largest In-Memory Search Tree
    Hyperion: Building the largest in-memory search tree MARKUS MÄSKER, Johannes Gutenberg University Mainz TIM SÜSS, Johannes Gutenberg University Mainz LARS NAGEL, Loughborough University LINGFANG ZENG, Huazhong University of Science and Technology ANDRÉ BRINKMANN, Johannes Gutenberg University Mainz Indexes are essential in data management systems to increase the Search trees have been used to index large data sets since speed of data retrievals. Widespread data structures to provide fast the 1950s [19]; examples are binary search trees [29], AVL and memory-efficient indexes are prefix tries. Implementations like trees [1], red-black trees [8], B-trees [9] and B+-trees. These Judy, ART, or HOT optimize their internal alignments for cache trees have the disadvantage of always storing complete keys and vector unit efficiency. While these measures usually improve inside their nodes and hence large parts of the keys many the performance substantially, they can have a negative impact on times. Binary trees also show bad caching behavior and do memory efficiency. not adapt well to new hardware architectures [44]. The result- In this paper we present Hyperion, a trie-based main-memory key-value store achieving extreme space efficiency. In contrast to ing performance issues become worse due to the increasing other data structures, Hyperion does not depend on CPU vector divergence between CPU and memory speed [42][46]. units, but scans the data structure linearly. Combined with a custom More memory-efficient data structures are tries [19][21] memory allocator, Hyperion accomplishes a remarkable data density which distribute the individual parts of a key over multiple while achieving a competitive point query and an exceptional range nodes to reduce redundancies.
    [Show full text]
  • START – Self-Tuning Adaptive Radix Tree
    START – Self-Tuning Adaptive Radix Tree Philipp Fent∗, Michael Jungmair∗, Andreas Kipf, Thomas Neumann Technische Universitat¨ Munchen¨ ffent,jungmair,kipf,[email protected] Abstract—Index structures like the Adaptive Radix Tree (ART) are a central part of in-memory database systems. However, we found that radix nodes that index a single byte are not optimal for read-heavy workloads. In this work, we introduce START, a cost self-tuning variant of ART that uses nodes spanning multiple key- model bytes. To determine where to introduce these new node types, we propose a cost model and an optimizer. These components optimizer allow us to fine-tune an existing ART, reducing its overall height, introduce and improving performance. As a result, START performs on multilevel nodes average 85 % faster than a regular ART on a wide variety of read-only workloads and 45 % faster for read-mostly workloads. ART START Fig. 1. Self-tuning ART results in a shallow and more efficient tree I. INTRODUCTION One of the go-to index structures for main-memory database offline mode, but the concept can also be applied online. To systems is the Adaptive Radix Tree (ART) [13]. Several aspects introduce multilevel nodes, we take an existing ART, determine make ART very favorable: It is almost as efficient to query as a the most suitable subtrees, and transform those. Figure 1 shows hash table [1], while still storing entries in-order, which allows this analysis and transformation process. supporting range queries. Furthermore, it supports efficient inserts [13], which makes it overall one of the best index Our self-tuning approach deduces its configuration from first structures.
    [Show full text]
  • Virtual Memory Algorithm Improvement
    VIRTUAL MEMORY ALGORITHM IMPROVEMENT Kamleshkumar Patel B.E., Sankalchand Patel College of Engineering, 2005 PROJECT Submitted in partial satisfaction of the requirements for the degree of MASTER OF SCIENCE in COMPUTER SCIENCE at CALIFORNIA STATE UNIVERSITY SACRAMENTO FALL 2009 VIRTUAL MEMORY ALGORITHM IMPROVEMENT A Project by Kamleshkumar Patel Approved by: _______________________________, Committee Chair Dr. Chung-E Wang _______________________________, Second Reader Dick Smith, Emeritus Faculty, CSUS ____________________ Date: ii Student: Kamleshkumar Patel I certify that this student has met the requirements for format contained in the University format manual, and that this project is suitable for shelving in the Library and credit is to be awarded for the thesis. __________________________, Graduate Coordinator _____________________ Dr. Cui Zhang, Ph.D. Date Department of Computer Science iii Abstract of VIRTUAL MEMORY ALGORITHM IMPROVEMENT by Kamleshkumar Patel The central component of any operating system is the Memory Management Unit (MMU). As the name implies, memory-management facilities are responsible for the management of memory resources available on a machine. Virtual memory (VM) in MMU allows a program to execute as if the primary memory is larger than its actual size. The whole purpose of virtual memory is to enlarge the address space, the set of addresses a program can utilize. A program would not be able to fit in main memory all at once when it is using all of virtual memory. Nevertheless, operating system could execute such a program by copying required portions into main memory at any given point during execution. To facilitate copying virtual memory into real memory, operating system divides virtual memory into pages.
    [Show full text]
  • File Processing & Organization Course No: 5901227-3
    File Processing & Organization Course No: 5901227-3 Lecture 8 Tries and Splay Trees Tries • A trie, also called digital tree/radix tree/prefix tree. • It is an ordered tree that is used to store a set of strings. • The term trie comes from retrieval. • Properties of a trie: – It is a multi-way tree. – The root of the tree is associated with the empty string . – Each edge of the tree is labeled with a character. – Each leaf node corresponds to the stored string, which is a concatenation of characters on a path from the root to this node. Trie Example 1 • Set of strings: {bear, bid, bulk, bull, sun, sunday}. s • all strings end with “$” b e u u i a n d r l d $ $ l a $ k y $ $ $ • In some trees the nodes can store the keys, that is, the characters on the path from root to the node. Trie Example 2 [nodes store the keys] A trie for keys "A", "tea", "to", "ted", "ten", "i", "in", and "inn". Trie Example 3 • For strings – { bear, bell, bid, bull, buy, sell, stock, stop } b s e i u e t a l d l y l o r l l l c p k • Tries are most commonly used for character strings. But they can be used for other data as well. • A bitwise trie is keyed on the individual bits making up an integer number or memory address. Compact/ Compressed Tries – Replace a chain of one-child nodes with an edge labeled with a string – Each non-leaf node (except root) has at least two children b s b sun e u u i ear$ a n day$ id$ ul $ r d l d $ $ l l$ $ a k k$ y $ $ $ Compact Tries • Compact representation of a compressed trie • Approach – For an array of strings S = S[0], … S[S-1] – Store ranges of indices at each node • Instead of substring – Represent as a triplet of integers (i, j, k) • Such that X = s[i][j..k] – Example: S[0] = “abcd”, (0,1,2) = “bc” • Properties – Uses O(s) space, where s = number of strings in the array – Serves as an auxiliary index structure Compact Representation Example • .
    [Show full text]
  • Advanced Data Structures – SCSA1304
    UNIT - II Advanced Data Structures – SCSA1304 1 ADVANCED TREE CONCEPTS THREADED BINARY TREE A binary tree is represented using array representation or linked list representation. When a binary tree is represented using linked list representation, if any node is not having a child, we use NULL pointer in that position. In any binary tree linked list representation, there are a greater number of NULL pointers than actual pointers. Generally, in any binary tree linked list representation, if there are 2N number of reference fields, then N+1 number of reference fields are filled with NULL (N+1 is NULL out of 2N). This NULL pointer does not play any role except indicating there is no link (no child). A. J. Perlis and C. Thornton have proposed new binary tree called "Threaded Binary Tree", which make use of NULL pointer to improve its traversal processes. In threaded binary tree, NULL pointers are replaced by references to other nodes in the tree, called threads. A threaded binary tree is defined as follows: "A binary tree is threaded by making all right child pointers that would normally be null point to the inorder successor of the node (if it exists), and all left child pointers that would normally be null point to the inorder predecessor of the node." Why do we need Threaded Binary Tree? Binary trees have a lot of wasted space: the leaf nodes each have 2 null pointers. We can use these pointers to help us in inorder traversals. Threaded binary tree makes the tree traversal faster since we do not need stack or recursion for traversal.
    [Show full text]
  • DART: Distributed Adaptive Radix Tree for Efficient Affix-Based
    DART: Distributed Adaptive Radix Tree for Eicient Aix-based Keyword Search on HPC Systems Wei Zhang Houjun Tang Texas Tech University Lawrence Berkeley National Laboratory Lubbock, Texas Berkeley, California [email protected] [email protected] Suren Byna Yong Chen Lawrence Berkeley National Laboratory Texas Tech University Berkeley, California Lubbock, Texas [email protected] [email protected] ABSTRACT 1 INTRODUCTION Ax-based search is a fundamental functionality for storage systems. Ax-based keyword search is a typical search problem, where It allows users to nd desired datasets, where attributes of a dataset resulting data records match a given prex, sux, or inx. For match an ax. While building inverted index to facilitate ecient ax- contemporary parallel and distributed storage systems in HPC en- based keyword search is a common practice for standalone databases vironments, searching string-based metadata is a frequent use case and for desktop le systems, building local indexes or adopting index- for users and applications to nd desired information. For instance, ing techniques used in a standalone data store is insucient for high- the ax-based keyword search on string-based identiers, such performance computing (HPC) systems due to the massive amount of as “name=chem*” and “date=*/2017”, is a common requirement in data and distributed nature of the storage devices within a system. In searching through the metadata among terabytes to petabytes of this paper, we propose Distributed Adaptive Radix Tree (DART), to data generated by various HPC applications [1, 7, 22, 23, 27, 32]. address the challenge of distributed ax-based keyword search on It is a common practice to build trie-based inverted index to ac- HPC systems.
    [Show full text]