Scalable and Secure Internet Services and Architecture PRESENTATION REPORT Semester: Winter 2015 Course: ECE 7650

Similar documents
Part II: Data Center Software Architecture: Topic 2: Key-value Data Management Systems. SkimpyStash: Key Value Store on Flash-based Storage

Speeding Up Cloud/Server Applications Using Flash Memory

SILT: A MEMORY-EFFICIENT, HIGH-PERFORMANCE KEY- VALUE STORE PRESENTED BY PRIYA SRIDHAR

Cheap and Large CAMs for High Performance Data-Intensive Networked Systems- The Bufferhash KV Store

ChunkStash: Speeding Up Storage Deduplication using Flash Memory

File system internals Tanenbaum, Chapter 4. COMP3231 Operating Systems

SILT: A Memory-Efficient, High- Performance Key-Value Store

Physical Disk Structure. Physical Data Organization and Indexing. Pages and Blocks. Access Path. I/O Time to Access a Page. Disks.

Storage and File Structure

Data Structure Lecture#22: Searching 3 (Chapter 9) U Kang Seoul National University

TSAR : A Two Tier Sensor Storage Architecture using Interval Skip Graphs

The Google File System

20-EECE-4029 Operating Systems Spring, 2013 John Franco

BUFFER HASH KV TABLE

File system internals Tanenbaum, Chapter 4. COMP3231 Operating Systems

arxiv: v1 [cs.db] 25 Nov 2018

COS 318: Operating Systems. NSF, Snapshot, Dedup and Review

Chapter 11: Storage and File Structure. Silberschatz, Korth and Sudarshan Updated by Bird and Tanin

Chapter 13: Indexing. Chapter 13. ? value. Topics. Indexing & Hashing. value. Conventional indexes B-trees Hashing schemes (self-study) record

COMP 346 WINTER 2018 MEMORY MANAGEMENT (VIRTUAL MEMORY)

CSE 4/521 Introduction to Operating Systems. Lecture 23 File System Implementation II (Allocation Methods, Free-Space Management) Summer 2018

Closing the Performance Gap Between Volatile and Persistent K-V Stores

Chapter 17. Disk Storage, Basic File Structures, and Hashing. Records. Blocking

BloomStore: Bloom-Filter based Memory-efficient Key-Value Store for Indexing of Data Deduplication on Flash

Darshan Institute of Engineering & Technology

CSE 120: Principles of Operating Systems. Lecture 10. File Systems. November 6, Prof. Joe Pasquale

HydraFS: a High-Throughput File System for the HYDRAstor Content-Addressable Storage System

Part II: Software Infrastructure in Data Centers: Key-Value Data Management Systems

CS370 Operating Systems

Database System Concepts

A New Key-Value Data Store For Heterogeneous Storage Architecture

Memory management. Last modified: Adaptation of Silberschatz, Galvin, Gagne slides for the textbook Applied Operating Systems Concepts

Database Technology. Topic 7: Data Structures for Databases. Olaf Hartig.

Bigtable. A Distributed Storage System for Structured Data. Presenter: Yunming Zhang Conglong Li. Saturday, September 21, 13

Main Memory (Part II)

JOURNALING techniques have been widely used in modern

Question Bank Subject: Advanced Data Structures Class: SE Computer

FILE SYSTEMS. CS124 Operating Systems Winter , Lecture 23

Hashing. Hashing Procedures

The What, Why and How of the Pure Storage Enterprise Flash Array. Ethan L. Miller (and a cast of dozens at Pure Storage)

COS 318: Operating Systems. Journaling, NFS and WAFL

Database Applications (15-415)

CSE 120: Principles of Operating Systems. Lecture 10. File Systems. February 22, Prof. Joe Pasquale

CMSC 424 Database design Lecture 13 Storage: Files. Mihai Pop

BzTree: A High-Performance Latch-free Range Index for Non-Volatile Memory

Chapter 12: File System Implementation

Data and File Structures Chapter 11. Hashing

HashKV: Enabling Efficient Updates in KV Storage via Hashing

Part II: Software Infrastructure in Data Centers: Key-Value Data Management Systems

A program execution is memory safe so long as memory access errors never occur:

Chapter 13: Query Processing

Cascade Mapping: Optimizing Memory Efficiency for Flash-based Key-value Caching

Topics. File Buffer Cache for Performance. What to Cache? COS 318: Operating Systems. File Performance and Reliability

Database Applications (15-415)

Disks and I/O Hakan Uraz - File Organization 1

Chapter 5 Hashing. Introduction. Hashing. Hashing Functions. hashing performs basic operations, such as insertion,

ECE 2035 Programming HW/SW Systems Fall problems, 5 pages Exam Three 28 November 2012

ECE 2035 Programming HW/SW Systems Fall problems, 5 pages Exam Three 19 November 2014

Operating Systems Design Exam 2 Review: Spring 2011

NPTEL Course Jan K. Gopinath Indian Institute of Science

CS 350 Algorithms and Complexity

Randomized Algorithms: Element Distinctness

2. PICTURE: Cut and paste from paper

e-pg Pathshala Subject: Computer Science Paper: Operating Systems Module 35: File Allocation Methods Module No: CS/OS/35 Quadrant 1 e-text

Memory Management. Dr. Yingwu Zhu

CS 416: Opera-ng Systems Design March 23, 2012

File System Interface and Implementation

Application Note: Heap Memory Management

HO #13 Fall 2015 Gary Chan. Hashing (N:12)

Why Is This Important? Overview of Storage and Indexing. Components of a Disk. Data on External Storage. Accessing a Disk Page. Records on a Disk Page

File Structures and Indexing

Non-Volatile Memory Through Customized Key-Value Stores

Dalí: A Periodically Persistent Hash Map

! A relational algebra expression may have many equivalent. ! Cost is generally measured as total elapsed time for

Chapter 13: Query Processing Basic Steps in Query Processing

Memory Management. Reading: Silberschatz chapter 9 Reading: Stallings. chapter 7 EEL 358

CSF Cache Introduction. [Adapted from Computer Organization and Design, Patterson & Hennessy, 2005]

L9: Storage Manager Physical Data Organization

Chapter 12: Query Processing

The Google File System (GFS)

Classifying Physical Storage Media. Chapter 11: Storage and File Structure. Storage Hierarchy (Cont.) Storage Hierarchy. Magnetic Hard Disk Mechanism

Classifying Physical Storage Media. Chapter 11: Storage and File Structure. Storage Hierarchy. Storage Hierarchy (Cont.) Speed

Disks, Memories & Buffer Management

File Systems: Interface and Implementation

SASS: A High-Performance Key-Value Store Design for Massive Hybrid Storage

Federated Array of Bricks Y Saito et al HP Labs. CS 6464 Presented by Avinash Kulkarni

Indexing. Jan Chomicki University at Buffalo. Jan Chomicki () Indexing 1 / 25

Chapter 8: Memory- Management Strategies. Operating System Concepts 9 th Edition

File Systems. Chapter 11, 13 OSPP

Google File System. By Dinesh Amatya

Hash-Based Indexing 1

1 Probability Review. CS 124 Section #8 Hashing, Skip Lists 3/20/17. Expectation (weighted average): the expectation of a random quantity X is:

File Systems: FFS and LFS

File System Internals. Jo, Heeseung

Introduction. hashing performs basic operations, such as insertion, better than other ADTs we ve seen so far

CSE 562 Database Systems

CS3600 SYSTEMS AND NETWORKS

Write-Optimized Dynamic Hashing for Persistent Memory

Disks & Files. Yanlei Diao UMass Amherst. Slides Courtesy of R. Ramakrishnan and J. Gehrke

Chapter 12: Query Processing

Transcription:

Scalable and Secure Internet Services and Architecture PRESENTATION REPORT Semester: Winter 2015 Course: ECE 7650 SUBMITTED BY: Yashwanth Boddu fq9316@wayne.edu

(1) Our base design uses less than 1 byte in RAM per key-value pair and our enhanced design takes slightly more than 1 byte per key-value pair. In FAWN, even a pointer to a KV pair needs a 4-byte pointer. How can possibly Skimpy Stash achieve such a low memory cost for metadata? Skimpy-Stash moves most of the pointers that locate each key value pair from RAM to the Flash itself. (2) Skimpy Stash uses a hash table directory in RAM to index key-value pairs stored in a log-structure on flash. Why are key-value pairs on the flash organized as a log? The key benefit of the log structured data organization on the Flash may be the high write throughput that can be obtained, since all the updates to the data and the metadata are written in a sequential order in the log. Here the metadata is pointer. (3) The average bucket size is the critical design parameter that serves as a powerful knob for making a continuum of tradeoffs between low RAM usage and low lookup latencies. Please explain this statement. If the bucket size is small, the linked list will be greater in size and therefore we have more lookup latency. And, if the bucket size is more, linked list will be shorter in size and we have less lookup latency but more the size of the bucket, more RAM space will be utilized which is again a backdrop. Hence bucket size is a powerful knob for making a continuum of tradeoffs between low RAM usage and low (4) The client [write] call returns only after the write buffer is flushed to flash. Why cannot such a call be acknowledged earlier? It can t be acknowledged earlier because the memory is still volatile in RAM write buffer. (5) Basic functions: Store, Lookup, Delete Use Figure to explain how these basic functions are executed? Store: A key insert (or, update) operation (set) writes the key-value pair into the RAM write buffer. When there are enough key-value pairs in RAM write buffer to fill a flash page (or, a configurable timeout interval since the client call has expired, say 1 msec), these entries are written to flash and inserted into the RAM HT directory and flash. Lookup: It firsts looks up the RAM write buffer, upon a miss there it lookups the Hash Table directory in RAM and searches the chained key value pair records on flash in the respective bucket.

Delete: A delete operation on a key is supported through insertion of null value for that key. Eventually the null entry and earlier inserted values of the key on flash will be garbage collected. (6) The chain of records on flash pointed to by each slot comprises the bucket of records corresponding to this slot in the HT directory. This is illustrated in Figure 3. Please use the figure to describe Skimpy Stash s data structure. Also explain how lookup, insert, and delete operations are executed. Skimpy Stash s data structure: Initially, a data structure is maintained in RAM that buffers key- value writes so that a write to flash happens only after there is enough data to fill a flash page. The directory structure, for the key value pairs stored on flash, is maintained in RAM and is organized as a hash table with each slot containing a pointer to a chain of records on flash. The chain of records on flash pointed to by each slot comprises the bucket of records corresponding to this slot in the HT directory. The flash store provides persistent storage for the key-value pairs and is organized as circular append log to the tail. In the enhanced design, we use two-choice based load balancing to reduce wide variations in bucket sizes and introduce a bloom filter in each ash table directory slot in RAM for summarizing the records in that bucket so that at most one bucket chain on flash needs to be searched during a lookup.

Lookup: A lookup operation on a key uses the hash function h to obtain the HT directory bucket that this key belongs to. It uses the pointer stored in that slot to follow the chain of records on flash to search the key; upon finding the first record in the chain whose key matches the search key, it returns the value. The number of flash reads for such a lookup is k/2 on the average, and at most the size of the bucket chain in the worst case. Insert: An insert (or, update) operation uses the hash function h to obtain the HT directory bucket that this key belongs to. Let a1 be the address on flash of the first record in this chain (i.e., what the pointer in this slot points to). Then a record is created corresponding to the inserted (or, updated) key-value pair with its next-pointer field equal to a1. This record is appended to the log on flash and its address on flash now becomes the value of the pointer in the respective slot in RAM. Effectively, this new record is inserted at the beginning of the chain corresponding to this bucket. Thus, if this insert operation corresponds to an update operation on an earlier inserted key, the most recent value of the key will be (correctly)read during a lookup operation (the old value being further down the chain and accumulating as garbage in the log). Delete: A delete operation is same as the insert (or, update) with null value for that key. Eventually the null entry on flash and old values of the key will be garbage collected in the log.

(7) Because we store the chain of key-value pairs in each bucket on flash, we incur multiple flash reads upon lookup of a key in the store. Please explain how this issue can be alleviated. [Hint: please refer to Section Compaction to Reduce Flash Reads during ] This can be done by periodically compacting the chain on flash in a bucket by placing the valid keys in the chain contiguously on one or more flash pages that are appended to the tail of log. (8)..two-choice based load balancing strategy is used to reduce variations in the number of keys assigned to each bucket. Explain how this is achieved. This strategy is used to reduce variations in the number of keys assigned to each bucket. With a load balanced design for HT directory, each key would be hashed to 2 candidate HT directory buckets using 2 hash functions h1 and h2, and actually inserted into the one that has currently fewer elements.

(9) when the last record in a bucket chain is encountered in the log during garbage collection, all valid records in that chain are compacted and relocated to the tail of the log.. Please explain how garbage is collected. When a certain configurable fraction of garbage accumulates in the log (in terms of space occupied), the pages on flash from the head of the log are recycled- valid entries from the head of the log are written back to end of the log while invalid entries can be skipped. This effectively leads to the design decision of garbage collecting entire bucket chains on flash at a time.