DOCSLIB.ORG

External Sorting and Query Evaluation (R&G Ch

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
External Sorting and Query Evaluation (R&G Ch Faloutsos 15-415 CMU SCS CMU SCS Why Sort? Carnegie Mellon Univ. Dept. of Computer Science 15-415 - Database Applications Lecture 11: external sorting and query evaluation (R&G ch. 13 and 14) Faloutsos 15-415 1 Faloutsos 15-415 2 CMU SCS CMU SCS Why Sort? Outline • select ... order by – e.g., find students in increasing gpa order • two-way merge sort • bulk loading B+ tree index. • external merge sort • duplicate elimination (select distinct) • fine-tunings • select ... group by • B+ trees for sorting • Sort-merge join algorithm involves sorting. Faloutsos 15-415 3 Faloutsos 15-415 4 CMU SCS CMU SCS 2-Way Sort: Requires 3 Buffers Two-Way External Merge Sort • Pass 0: Read a page, sort it, write it. 3,4 6,2 9,4 8,7 5,6 3,1 2 Input file • Each pass we read + PASS 0 – only one buffer page is used 3,4 2,6 4,9 7,8 5,6 1,3 2 1-page runs write each page in file. PASS 1 4,7 1,3 • Pass 1, 2, 3, …, etc.: requires 3 buffer pages 2,3 2-page runs 4,6 8,9 5,6 2 – merge pairs of runs into runs twice as long PASS 2 2,3 – three buffer pages used. 4,4 1,2 4-page runs 6,7 3,5 8,9 6 PASS 3 INPUT 1 1,2 OUTPUT 2,3 INPUT 2 3,4 8-page runs 4,5 6,6 Main memory buffers Disk Disk 7,8 Faloutsos 15-415 5 Faloutsos 15-415 9 6 1 Faloutsos 15-415 CMU SCS CMU SCS Two-Way External Merge Sort Two-Way External Merge Sort 3,4 6,2 9,4 8,7 5,6 3,1 2 Input file 3,4 6,2 9,4 8,7 5,6 3,1 2 Input file • Each pass we read + PASS 0 • Each pass we read + PASS 0 3,4 2,6 4,9 7,8 5,6 1,3 2 1-page runs 3,4 2,6 4,9 7,8 5,6 1,3 2 1-page runs write each page in file. PASS 1 write each page in file. PASS 1 4,7 1,3 4,7 1,3 2,3 2-page runs 2,3 2-page runs 4,6 8,9 5,6 2 4,6 8,9 5,6 2 PASS 2 PASS 2 2,3 2,3 4,4 1,2 4-page runs 4,4 1,2 4-page runs 6,7 3,5 6,7 3,5 8,9 6 8,9 6 PASS 3 PASS 3 1,2 1,2 2,3 2,3 3,4 8-page runs 3,4 8-page runs 4,5 4,5 6,6 6,6 7,8 7,8 Faloutsos 15-415 9 7 Faloutsos 15-415 9 8 CMU SCS CMU SCS Two-Way External Merge Sort Two-Way External Merge Sort 3,4 6,2 9,4 8,7 5,6 3,1 2 Input file 3,4 6,2 9,4 8,7 5,6 3,1 2 Input file • Each pass we read + PASS 0 • Each pass we read + PASS 0 3,4 2,6 4,9 7,8 5,6 1,3 2 1-page runs 3,4 2,6 4,9 7,8 5,6 1,3 2 1-page runs write each page in file. PASS 1 write each page in file. PASS 1 4,7 1,3 4,7 1,3 2,3 2-page runs 2,3 2-page runs 4,6 8,9 5,6 2 • N pages in the file => 4,6 8,9 5,6 2 PASS 2 PASS 2 log2 N 1 2,3 2,3 4,4 1,2 4-page runs 4,4 1,2 4-page runs 6,7 3,5 • So total cost is: 6,7 3,5 8,9 6 8,9 6 PASS 3 2 N log2 N 1 PASS 3 1,2 1,2 2,3 • Idea: Divide and 2,3 3,4 8-page runs 3,4 8-page runs 4,5 conquer: sort subfiles 4,5 6,6 6,6 7,8 and merge 7,8 Faloutsos 15-415 9 9 Faloutsos 15-415 9 10 CMU SCS CMU SCS Outline External merge sort • two-way merge sort B > 3 buffers • external merge sort • Q1: how to sort? • fine-tunings • Q2: cost? • B+ trees for sorting Faloutsos 15-415 11 Faloutsos 15-415 12 2 Faloutsos 15-415 CMU SCS CMU SCS General External Merge Sort General External Merge Sort B>3 buffer pages. How to sort a file with N pages? – Pass 0: use B buffer pages. Produce N / B sorted runs of B pages each. – Pass 1, 2, …, etc.: merge B-1 runs. INPUT 1 INPUT 2 . OUTPUT . INPUT B-1 Disk Disk Disk B Main memory buffers Disk B Main memory buffers Faloutsos 15-415 13 Faloutsos 15-415 14 CMU SCS CMU SCS Sorting Sorting – create sorted runs of size B (how many?) – create sorted runs of size B – merge them (how?) – merge first B-1 runs into a sorted run of (B-1) *B, ... B B ….. ... ... ... ... Faloutsos 15-415 15 Faloutsos 15-415 16 CMU SCS CMU SCS Cost of External Merge Sort Sorting – How many steps we need to do? • Number of passes: 1 log B1 N / B „i‟, where B*(B-1)^i > N • Cost = 2N * (# of passes) – How many reads/writes per step? N+N B ….. ... ... Faloutsos 15-415 17 Faloutsos 15-415 18 3 Faloutsos 15-415 CMU SCS CMU SCS Number of Passes of External Cost of External Merge Sort Sort ( I/O cost is 2N times number of passes) • E.g., with 5 buffer pages, to sort 108 page N B=3 B=5 B=9 B=17 B=129 B=257 file: 100 7 4 3 2 1 1 – Pass 0: 108 / 5 = 22 sorted runs of 5 pages 1,000 10 5 4 3 2 2 each (last run is only 3 pages) 10,000 13 7 5 4 2 2 – Pass 1: 22 / 4 = 6 sorted runs of 20 pages 100,000 17 9 6 5 3 3 each (last run is only 8 pages) 1,000,000 20 10 7 5 3 3 – Pass 2: 2 sorted runs, 80 pages and 28 pages 10,000,000 23 12 8 6 4 3 – Pass 3: Sorted file of 108 pages 100,000,000 26 14 9 7 4 4 ┌ ┐ 1,000,000,000 30 15 10 8 5 4 Formula check: log 22 = 3 … + 1 4 passes √ 4 Faloutsos 15-415 19 Faloutsos 15-415 20 CMU SCS CMU SCS Outline Outline • two-way merge sort • two-way merge sort • external merge sort • external merge sort • fine-tunings • fine-tunings • B+ trees for sorting – which internal sort for Phase 0? – blocked I/O • B+ trees for sorting Faloutsos 15-415 21 Faloutsos 15-415 22 CMU SCS CMU SCS Internal Sort Algorithm Internal Sort Algorithm • Quicksort is a fast way to sort in memory. • Quicksort is a fast way to sort in memory. • But: we get B buffers, and produce 1 run of length • But: we get B buffers, and produce 1 run of length B. B. • Can we produce longer runs than that? • Can we produce longer runs than that? Heapsort: B=3 B=3 • Pick smallest • Output • Read from next buffer Faloutsos 15-415 23 Faloutsos 15-415 24 4 Faloutsos 15-415 CMU SCS CMU SCS details Internal Sort Algorithm Reminder: Heapsort • Quicksort is a fast way to sort in memory. • But: we get B buffers, and produce 1 run of length B. pick smallest, write to output buffer: • Can we produce longer runs than that? 10 • Alternative: “tournament sort” (a.k.a. “heapsort”, 14 11 “replacement selection”) • Produces runs of length ~ 2*B 15 17 18 16 • Clever, but not implemented, for subtle reasons: tricky memory management on variable length records Faloutsos 15-415 25 Faloutsos 15-415 26 CMU SCS CMU SCS details details Heapsort: Heapsort: 10 pick smallest, write to output buffer: get next key; put at top and ‘sink’ it ... 22 14 11 14 11 15 17 18 16 15 17 18 16 Faloutsos 15-415 27 Faloutsos 15-415 28 CMU SCS CMU SCS details details Heapsort: Heapsort: get next key; put at top and ‘sink’ it get next key; put at top and ‘sink’ it 11 11 14 22 14 16 15 17 18 16 15 17 18 22 Faloutsos 15-415 29 Faloutsos 15-415 30 5 Faloutsos 15-415 CMU SCS CMU SCS details Heapsort: Outline • two-way merge sort When done, pick top (= smallest) • external merge sort 11 and output it, if ‘legal’ (ie., >=10 in our example • fine-tunings 14 16 – which internal sort for Phase 0? This way, we can keep on reading – blocked I/O 15 17 18 22 new key values (beyond the B ones of quicksort) • B+ trees for sorting Faloutsos 15-415 31 Faloutsos 15-415 32 CMU SCS CMU SCS Blocked I/O & double-buffering Blocked I/O & double-buffering • So far, we assumed random disk access • So far, we assumed random disk access • Cost changes, if we consider that runs are • Cost changes, if we consider that runs are written (and read) sequentially written (and read) sequentially • What could we do to exploit it? • What could we do to exploit it? • A1: Blocked I/O (exchange a few r.d.a for several sequential ones) • A2: double-buffering Faloutsos 15-415 33 Faloutsos 15-415 34 CMU SCS CMU SCS Double Buffering Outline • To reduce wait time for I/O request to complete, can prefetch into `shadow block‟.
Load more

Recommended publications
  • The Influence of Caches on the Performance of Sorting
    The Influence of Caches on the Performance of Sorting Anthony LaMarca* & Richard E. Ladner Department of Computer Science and Engineering University of Washington Seattle, WA 98195 lamarcaQparc.xerox.com [email protected] Abstract quicksort [12], and radix sort*. Heapsort, mergesort, We investigate the effect that caches have on the per- and quicksort are all comparison based sorting algo- formance of sorting algorithms both experimentally and rithms while radix sort is not. analytically. To address the performance problems that For each of the four sorting algorithms we choose an high cache miss penalties introduce we restructure heap- implementation variant with potential for good overall sort, mergesort and quicksort in order to improve their performance and then heavily optimize this variant us- cache locality. For all three algorithms the improvement ing traditional techniques to minimize the number of in cache performance leads to a reduction in total ex- instructions executed. These heavily optimized algo- ecution time. We also investigate the performance of rithms form the baseline for comparison. For each of radix sort. Despite the extremely low instruction count the comparison sort baseline algorithms we develop and incurred by this linear sorting algorithm, its relatively apply memory optimizations in order to improve cache poor cache performance results in worse overall perfor- performance and, hopefully, overall performance. For mance than the efficient comparison based sorting algo- radix sort we optimize cache performance by varying rithms. the radix. In the process we develop some simple an- alytic techniques which enable us to predict the mem- 1 Introduction. ory performance of these algorithms in terms of cache misses.
    [Show full text]
  • 17. Chapter 11
    11 EXTERNALSORTING Good order is the foundation of all things. —Edmund Burke Sorting a collection of records on some (search) key is a very useful operation. The key can be a single attribute or an ordered list of attributes, of course. Sorting is required in a variety of situations, including the following important ones: Users may want answers in some order; for example, by increasing age (Section 5.2). Sorting records is the first step in bulk loading a tree index (Section 9.8.2). Sorting is useful for eliminating duplicate copies in a collection of records (Chapter 12). A widely used algorithm for performing a very important relational algebra oper- ation, called join, requires a sorting step (Section 12.5.2). Although main memory sizes are increasing, as usage of database systems increases, increasingly larger datasets are becoming common as well. When the data to be sorted is too large to fit into available main memory, we need to use an external sorting algorithm. Such algorithms seek to minimize the cost of disk accesses. We introduce the idea of external sorting by considering a very simple algorithm in Section 11.1; using repeated passes over the data, even very large datasets can be sorted with a small amount of memory. This algorithm is generalized to develop a realistic external sorting algorithm in Section 11.2. Three important refinements are discussed. The first, discussed in Section 11.2.1, enables us to reduce the number of passes. The next two refinements, covered in Section 11.3, require us to consider a more detailed model of I/O costs than the number of page I/Os.
    [Show full text]
  • External Sorting Why Sort? Sorting a File in RAM 2-Way Sort of N Pages
    Why Sort? A classic problem in computer science! Data requested in sorted order – e.g., find students in increasing gpa order Sorting is the first step in bulk loading of B+ tree External Sorting index. Sorting is useful for eliminating duplicate copies in a collection of records (Why?) Chapter 13 Sort-merge join algorithm involves sorting. Problem: sort 100Gb of data with 1Gb of RAM. – why not virtual memory? Take a look at sortbenchmark.com Take a look at main memory sort algos at www.sorting-algorithms.com Database Management Systems, R. Ramakrishnan and J. Gehrke 1 Database Management Systems, R. Ramakrishnan and J. Gehrke 2 Sorting a file in RAM 2-Way Sort of N pages Requires Minimum of 3 Buffers Three steps: – Read the entire file from disk into RAM Pass 0: Read a page, sort it, write it. – Sort the records using a standard sorting procedure, such – only one buffer page is used as Shell sort, heap sort, bubble sort, … (100’s of algos) – How many I/O’s does it take? – Write the file back to disk Pass 1, 2, 3, …, etc.: How can we do the above when the data size is 100 – Minimum three buffer pages are needed! (Why?) or 1000 times that of available RAM size? – How many i/o’s are needed in each pass? (Why?) And keep I/O to a minimum! – How many passes are needed? (Why?) – Effective use of buffers INPUT 1 – Merge as a way of sorting – Overlap processing and I/O (e.g., heapsort) OUTPUT INPUT 2 Main memory buffers Disk Disk Database Management Systems, R.
    [Show full text]
  • Efficient External Sorting on Flash Memory Embedded Devices
    International Journal of Database Management Systems ( IJDMS ) Vol.5, No.1, February 2013 EFFICIENT EXTERNAL SORTING ON FLASH MEMORY EMBEDDED DEVICES Tyler Cossentine and Ramon Lawrence Department of Computer Science, University of British Columbia Okanagan Kelowna, BC, Canada [email protected] [email protected] ABSTRACT Many embedded system applications involve storing and querying large datasets. Existing research in this area has focused on adapting and applying conventional database algorithms to embedded devices. Algorithms designed for processing queries on embedded devices must be able to execute given the small amount of available memory and energy constraints. Most embedded devices use flash memory to store large amounts of data. Flash memory has unique performance characteristics that can be exploited to improve algorithm performance. In this paper, we describe the Flash MinSort external sorting algorithm that uses an index, generated at runtime, to take advantage of fast random reads in flash memory. This algorithm adapts to the amount of memory available and performs best in applications where sort keys are clustered. Experimental results show that Flash MinSort is two to ten times faster than previous approaches for small memory sizes where external merge sort is not executable. KEYWORDS sorting, sensor node, flash memory, query processing 1. INTRODUCTION Embedded systems are devices that perform a few simple functions. Most embedded systems, such as sensor networks, smart cards and certain hand-held devices, are computationally constrained. These devices typically have a low-power microprocessor, limited amount of memory, and flash-based data storage. In addition, some battery-powered devices, such as sensor networks, must be deployed for months at a time without being replaced.
    [Show full text]
  • External Sorting
    External sorting R & G – Chapter 13 Brian Cooper Yahoo! Research A little bit about Y! Yahoo! is the most visited website in the world Sorry Google 500 million unique visitors per month 74 percent of U.S. users use Y! (per month) 13 percent of U.S. users’ online time is on Y! Why sort? Why sort? Users usually want data sorted Sorting is first step in bulk-loading a B+ tree Sorting useful for eliminating duplicates Sort-merge join algorithm involves sorting Banana Apple Grapefruit Banana Apple Blueberry Orange Grapefruit Mango Kiwi Kiwi Mango Strawberry Orange Blueberry Strawberry So? Don’t we know how to sort? Quicksort Mergesort Heapsort Selection sort Insertion sort Radix sort Bubble sort Etc. Why don’t these work for databases? Key problem in database sorting 4 GB: $300 480 GB: $300 How to sort data that does not fit in memory? Example: merge sort Banana Banana Banana Grapefruit Grapefruit Banana Grapefruit Grapefruit Apple Apple Apple Apple Orange Orange Orange Orange Mango Kiwi Mango Mango Kiwi Strawberry Kiwi Kiwi Mango Blueberry Strawberry Blueberry Strawberry Blueberry Blueberry Strawberry Example: merge sort Banana Apple Apple Grapefruit Banana Banana Grapefruit Blueberry Apple Orange Grapefruit Orange Kiwi Mango Orange Kiwi Strawberry Mango Blueberry Kiwi Blueberry Mango Strawberry Strawberry Isn’t that good enough? Consider a file with N records Merge sort is O(N lg N) comparisons We want to minimize disk I/Os Don’t want to go to disk O(N lg N) times! Key insight: sort based on pages, not records Read
    [Show full text]
  • Algorithms and Data Structures for External Memory Algorithms and Data Structures 2:4 for External Memory Jeffrey Scott Vitter
    TCSv2n4.qxd 4/24/2008 11:56 AM Page 1 FnT TCS 2:4 Foundations and Trends® in Theoretical Computer Science Algorithms and Data Structures for External MemoryAlgorithms and Data Structures for Vitter Scott Jeffrey Algorithms and Data Structures 2:4 for External Memory Jeffrey Scott Vitter Data sets in large applications are often too massive to fit completely inside the computer's internal memory. The resulting input/output communication (or I/O) between fast internal memory and slower external memory (such as disks) can be a major performance bottleneck. Algorithms and Data Structures Algorithms and Data Structures for External Memory surveys the state of the art in the design and analysis of external memory (or EM) algorithms and data structures, where the goal is to exploit locality in order to reduce the I/O costs. A variety of EM paradigms are considered for for External Memory solving batched and online problems efficiently in external memory. Jeffrey Scott Vitter Algorithms and Data Structures for External Memory describes several useful paradigms for the design and implementation of efficient EM algorithms and data structures. The problem domains considered include sorting, permuting, FFT, scientific computing, computational geometry, graphs, databases, geographic information systems, and text and string processing. Algorithms and Data Structures for External Memory is an invaluable reference for anybody interested in, or conducting research in the design, analysis, and implementation of algorithms and data structures. This book is originally published as Foundations and Trends® in Theoretical Computer Science Volume 2 Issue 4, ISSN: 1551-305X. now now the essence of knowledge Algorithms and Data Structures for External Memory Algorithms and Data Structures for External Memory Jeffrey Scott Vitter Department of Computer Science Purdue University West Lafayette Indiana, 47907–2107 USA [email protected] Boston – Delft Foundations and TrendsR in Theoretical Computer Science Published, sold and distributed by: now Publishers Inc.
    [Show full text]
  • 14.1 Sorting
    436 14. COMBINATORIAL PROBLEMS INPUT OUTPUT 14.1 Sorting Input description:Asetofn items. Problem description: Arrange the items in increasing (or decreasing) order. Discussion: Sorting is the most fundamental algorithmic problem in computer science. Learning the different sorting algorithms is like learning scales for a mu- sician. Sorting is the first step in solving a host of other algorithm problems, as shown in Section 4.2 (page 107). Indeed, “when in doubt, sort” is one of the first rules of algorithm design. Sorting also illustrates all the standard paradigms of algorithm design. The re- sult is that most programmers are familiar with many different sorting algorithms, which sows confusion as to which should be used for a given application. The following criteria can help you decide: • How many keys will you be sorting? – For small amounts of data (say n ≤ 100), it really doesn’t matter much which of the quadratic-time algorithms you use. Insertion sort is faster, simpler, and less likely to be buggy than bubblesort. Shellsort is closely related to, but much faster than, insertion sort, but it involves looking up the right insert sequences in Knuth [Knu98]. When you have more than 100 items to sort, it is important to use an O(n lg n)-time algorithm like heapsort, quicksort, or mergesort. There are various partisans who favor one of these algorithms over the others, but since it can be hard to tell which is fastest, it usually doesn’t matter. Once you get past (say) 5,000,000 items, it is important to start thinking about external-memory sorting algorithms that minimize disk access.
    [Show full text]
  • 8 File Processing and External Sorting
    8 File Processing and External Sorting In earlier chapters we discussed basic data structures and algorithms that operate on data stored in main memory. Sometimes the application at hand requires that large amounts of data be stored and processed, so much data that they cannot all fit into main memory. In that case, the data must reside on disk and be brought into main memory selectively for processing. You probably already realize that main memory access is much faster than ac- cess to data stored on disk or other storage devices. In fact, the relative difference in access times is so great that efficient disk-based programs require a different ap- proach to algorithm design than most programmers are used to. As a result, many programmers do a poor job when it comes to file processing applications. This chapter presents the fundamental issues relating to the design of algo- rithms and data structures for disk-based applications. We begin with a descrip- tion of the significant differences between primary memory and secondary storage. Section 8.2 discusses the physical aspects of disk drives. Section 8.3 presents basic methods for managing buffer pools. Buffer pools will be used several times in the following chapters. Section 8.4 discusses the C++ model for random access to data stored on disk. Sections 8.5 to 8.8 discuss the basic principles of sorting collections of records too large to fit in main memory. 8.1 Primary versus Secondary Storage Computer storage devices are typically classified into primary or main memory and secondary or peripheral storage.
    [Show full text]
  • External Sort in Data Structure with Example
    External Sort In Data Structure With Example Tawie and new Emmit crucified his stutter amuses impound inflexibly. Double-tongued Rad impressed jingoistically while Douglas always waver his eye chromatograph shallowly, he analyzing so evilly. Lexicographical Pate hutches salaciously. Thus it could be implemented, external sort exist, for satisfying conditions of the number of the number of adding one Any particular order as follows the items into the increased capacity in external data structure with a linked list in the heap before the web log file. Such loading and external sort in data structure with example, external sorting algorithms it can answer because all. For production work, I still suggest that you use a database. Many uses external sorting algorithms. The overall solution is found by describing a method to merge two sorted sequences. In the latter case, we copy this run to the appropriate tape. Repeatedly, the smallest item is removed from the selection tree and placed in the output stream, and the next item from the input file is inserted in its place as a leaf in the selection tree. We will do this for the randomized version. Was a run legths as is related data. In applications a gap using the example, the optimal sorting on the numbers from what is internal sorting algorithms are twice as popping the copies the practical. The external sorting. Till now, we saw that sorting is an important term in any database system. Note that in a rooted tree, the root has no parent and all other nodes have a single parent.
    [Show full text]
  • Leyenda: an Adaptive, Hybrid Sorting Algorithm for Large Scale Data with Limited Memory
    Leyenda: An Adaptive, Hybrid Sorting Algorithm for Large Scale Data with Limited Memory Yuanjing Shi Zhaoxing Li University of Illinois at Urbana-Champaign University of Illinois at Urbana-Champaign Abstract tems. Joins are the most computationally expensive among Sorting is the one of the fundamental tasks of modern data all SparkSQL operators [6]. With its distributed nature, Spark management systems. With Disk I/O being the most-accused chooses proper strategies for join based on joining keys and performance bottleneck [14] and more computation-intensive size of data. Overall, there are three different join implementa- workloads, it has come to our attention that in heterogeneous tions, Broadcast Hash Join, Shuffle Hash Join and Sort Merge environment, performance bottleneck may vary among differ- Join. Broadcast Hash Join is thefirst choice if one side of the ent infrastructure. As a result, sort kernels need to be adap- joining table is broadcastable, which means its size is smaller tive to changing hardware conditions. In this paper, we pro- than a preset ten-megabyte threshold. Although it is the most pose Leyenda, a hybrid, parallel and efficient Radix Most- performant, it is only applicable to a small set of real world Significant-Bit (MSB) MergeSort algorithm, with utilization use cases. Between Shuffle Hash Join and Sort Merge Join, of local thread-level CPU cache and efficient disk/memory since Spark 2.3 [2], Sort Merge Join is always preferred over I/O. Leyenda is capable of performing either internal or ex- Shuffle Hash Join. ternal sort efficiently, based on different I/O and processing The implementation of Sparks’ Sort Merge Join is simi- conditions.
    [Show full text]
  • Cache-Oblivious Sorting (1999; Frigo, Leiserson, Prokop, Ramachandran)
    Cache-Oblivious Sorting (1999; Frigo, Leiserson, Prokop, Ramachandran) Gerth Stølting Brodal, Universty of Aarhus, www.daimi.au.dk/˜gerth INDEX TERMS: Sorting, permuting, cache-obliviousness. SYNONYMS: Funnet sort 1 PROBLEM DEFINITION Sorting a set of elements is one of the most well studied computational problems. In the cache- oblivious setting the first study of sorting was presented in 1999 in the seminal paper by Frigo et al. [8] that introduced the cache-oblivious framework for developing algorithms aimed at machines with (unknown) hierarchical memory. Model In the cache-oblivious setting the computational model is a machine with two levels of memory: a cache of limited capacity and a secondary memory of infinite capacity. The capacity of the cache is assumed to be M elements and data is moved between the two levels of memory in blocks of B consecutive elements. Computations can only be performed on elements stored in cache, i.e. elements from secondary memory need to be moved to the cache before operations can access the elements. Programs are written as acting directly on one unbounded memory, i.e. programs are like standard RAM programs. The necessary block transfers between cache and secondary memory are handled automatically by the model, assuming an optimal offline cache replacement strategy. The core assumption of the cache-oblivious model is that M and B are unknown to the algorithm whereas in the related I/O model introduced by Aggarwal and Vitter [1] the algorithms know M and B and the algorithms perform the block transfers explicitly. A throughout discussion of the cache-oblivious model and its relation to multi-level memory hierarchies is given in [8].
    [Show full text]
  • Engineering a Cache Oblivious Sorting Algorithm Gerth Brodal, Rolf Fagerberg and Kristoffer Vinther
    Engineering A Cache Oblivious Sorting Algorithm Gerth Brodal, Rolf Fagerberg and Kristoffer Vinther Presenter: Rawn Henry February 25 2019 Memory Hierarchy Typical cache sizes: L1 Cache: 32kB – 64kB L2 Cache: 256kB – 512kB L3 Cache: 8MB – 32 MB Main Memory: 4GB – 32 GB Disk: Terabytes Observations ØMemory accesses are usually the bottleneck in algorithms since CPU is a lot faster than main memory ØWant to minimize the number of times we have get data from slow memory by maximizing data reuse Cache Aware vs Cache Oblivious ØBoth have cache friendly access patterns. ØCache aware algorithms depend on the parameters of the architecture such as cache size and depth of hierarchy whereas cache oblivious algorithms do not. ØCache aware algorithms tend to be faster but are not portable without retuning. Ø We want speed of cache friendly access but portability of cache oblivious algorithm. Funnel Sort Algorithm Description ØRecursively sort n⅓ contiguous arrays of n⅔ items ØMerge the sorted sequences using a n⅓ -merger ØBase case is a merger with k = 2 ØSimilar to merge sort but different merging routine Funnel Sort Picture Taken from 6.172 lecture 15 Fall 2018 Sorting bounds Quick sort Ø Work = O(nlgn) ØCache usage = O(n/B)lgn) Funnel sort ØWork = O(nlgn) ØCache = O((n/B)logMn) Issues with Funnel Sort ØIn practice it is not always possible to split K-Funnel into √K bottom funnels, it may lead to rounding errors. ØvEB layout performs well for binary trees but does not perform well for complex data structures. Lazy Funnel Sort ØTo overcome rounding
    [Show full text]