Yongseok Son

Optimizing file systems for fast storage devices

Emerging high-performance storage devices have attractive features such as low latency and high throughput. This leads to a rapid increase in the demand for fast storage devices in cloud platforms, social network services, etc. However, there are few block-based file systems that are capable of utilizing superior characteristics of fast storage devices. In this paper, we find that the I/O strategy of modern operating systems prevents file systems from exploiting fast storage devices. To address this problem, we propose several optimization techniques for block-based file systems. Then, we apply our techniques to two well-known file systems and evaluate them with multiple benchmarks. The experimental results show that our optimized file systems achieve 32% on average and up to 54% better performance than existing file systems.

Efficient Memory-Mapped I/O on Fast Storage Device

In modern operating systems, memory-mapped I/O (mmio) is an important access method that maps a file or file-like resource to a region of memory. The mapping allows applications to access data from files through memory semantics (i.e., load/store) and it provides ease of programming. The number of applications that use mmio are increasing because memory semantics can provide better performance than file semantics (i.e., read/write). As more data are located in the main memory, the performance of applications can be enhanced owing to the effect of a large cache. When mmio is used, hot data tend to reside in the main memory and cold data are located in storage devices such as HDD and SSD; data placement in the memory hierarchy depends on the virtual memory subsystem of the operating system. Generally, the performance of storage devices has a direct impact on the performance of mmio. It is widely expected that better storage devices will lead to better performance. However, the expectation is limited when fast storage devices are used since the virtual memory subsystem does not reflect the performance feature of those devices. In this article, we examine the Linux virtual memory subsystem and mmio path to determine the influence of fast storage on the existing Linux kernel. Throughout our investigation, we find that the overhead of the Linux virtual memory subsystem, negligible on the HDD, prevents applications from using the full performance of fast storage devices. To reduce the overheads and fully exploit the fast storage devices, we present several optimization techniques. We modify the Linux kernel to implement our optimization techniques and evaluate our prototyped system with low-latency storage devices. Experimental results show that our optimized mmio has up to 7x better performance than the original mmio. We also compare our system to a system that has enough memory to keep all data in the main memory. The system with insufficient memory and our mmio achieves 92% performance of the resource-rich system. This result implies that our virtual memory subsystem for mmap can effectively extend the main memory with fast storage devices.

Design and evaluation of a user-level file system for fast storage devices

Lately, fast storage devices are rapidly increasing in social network services, cloud platforms, etc. Unfortunately, the traditional Linux I/O stack is designed to maximize performance on disk-based storage. Emerging byte-addressable and low-latency non-volatile memory technologies (e.g., phase-change memories, MRAMs, and the memristor) provide very different characteristics, so the disk-based I/O stack cannot lead to high performance. This paper presents a high performance I/O stack for the fast storage devices. Our scheme is to remove the concept of block and to simplify the whole I/O path and software stack, which results in only two layers that are the byte-capable interface and the byte-aware file system called BAFS. We aim to minimize I/O latency and maximize bandwidth by eliminating the unnecessary layers and supporting byte-addressable I/O without requiring changes to applications. We have implemented a prototype and evaluated its performance with multiple benchmarks. The experimental results show that our I/O stack achieves 6.2 times on average and up to 17.5 times performance gains compared to the existing Linux I/O stack.

Optimizing the file system with variable-length I/O for fast storage devices

Recently, the demand for fast storages is rapidly increasing in HPC environments such as cloud platforms, social network services and desktop users. But HDD-based storages cannot satisfy these demands, and a variety of high performance storages providing lower I/O latency and higher I/O bandwidth have been eagerly developed. Although merely adopting these fast devices in the storage system can take some advantages, it cannot fully utilize their high performance. So, proper optimizations are needed. In this work, we focus on the granularity of the I/O request from the application layer to the block layer. We found that the I/O operation at the page granularity causes huge performance degradation in the case of small size random I/O patterns that are often observed during the execution of mail servers, DB servers, etc. This is because it allows non-requested data to be transferred. Therefore, we propose new file system design that contains two optimizations; 1) an extended I/O interface maintaining user requested data size over all the layers in I/O subsystem, and 2) sub-page mechanism for minimizing non-requested data transfer effectively. We have implemented our approach in the Linux file system. The experimental results show that our solution achieves 1.6 to 6.3 times performance gains.

SSD-Assisted Backup and Recovery for Database Systems

Backup and recovery is an important feature of database systems since it protects data against unexpected hardware and software failures. Database systems can provide data safety and reliability by creating a backup and restoring the backup from a failure. Database administrators can use backup/recovery tools that are provided with database systems or backup/recovery methods with operating systems. However, the existing tools perform time-consuming jobs and the existing methods may negatively affect run-time performance during normal operation even though high-performance SSDs are used. In this paper, we present an SSD-assisted backup/recovery scheme for database systems. In our scheme, we extend the out-of-place update characteristics of flash-based SSDs for backup/recovery operations. To this end, we exploit the resources (e.g., flash translation layer and DRAM cache with supercapacitors) inside SSDs, and we call our SSD with new backup/recovery features BR-SSD. We design and implement the backup/recovery functionality in the Samsung enterprise-class SSD (i.e., SM843Tn) for more realistic systems. Furthermore, we conduct a case study of BR-SSDs in replicated database systems and modify MySQL with replication to integrate BR-SSDs. The experimental result demonstrates that our scheme provides fast recovery while it does not negatively affect the run-time performance during normal operation.

A User-Level File System for Fast Storage Devices

Lately, fast storage devices are rapidly increasing in social network services, cloud platforms, etc. Unfortunately, the traditional Linux I/O stack is designed to maximize performance on disk-based storage. Emerging byte-addressable and low-latency non-volatile memory (NVM) technologies (e.g., Phase-change memories, spin-transfer torque MRAMs, and the memristor) provides very different characteristics, so the disk-based I/O stack cannot lead to high performance. This paper presents a high performance I/O stack for the fast storage devices. Our scheme is to remove the concept of block and to simplify the whole I/O path and software stack, which results in only two layers that are composed of the byte-capable interface and the byte-aware file system called BAFS. We aim to minimize I/O latency and maximize bandwidth by eliminating the unnecessary layers and supporting byte-addressable I/O without requiring changes to applications. We have implemented a prototype and evaluated its performance with multiple benchmarks. The experimental results show that our I/O stack achieves 6.2 times on average and up to 17.5 times performance gains compared to existing Linux I/O stack.

An Empirical Evaluation of NVM Express SSD

Emerging Non-Volatile Memory (NVM) technology with high throughput and scalability has considerable attraction in cloud and enterprise storage systems. The industry and academic communities made the NVMe specification to elicit the highest performance on NVM devices. While the technology is commercially viable, it is important to consider the performance of NVM devices with NVMe specification according to different I/O configurations and analyze workloads on the storage to exploit better performance. This paper presents the features and results of our performance study on a recent NVM express solid state drive (NVMe SSD) developed by Samsung electronics. It is a flash-based PCIe attached SSD built to follow NVMe specification. The maximum throughput is 2.5GB/s and 800MB/s for reading and writing 4KB, respectively. We analyze the performance of NVMe SSD in terms of different performance metrics with microbenchmarks and database workloads.

A log-structured buffer for database systems using non-volatile memory

Emerging next-generation non-volatile memory (NVM) technologies, including PCM and STT-MRAM, provide low latency, high bandwidth, non-volatility, and high capacity. Recently, NVM has drawn much attention from the database community to improve transaction processing (e.g., write-ahead logging). As a complement to existing work, we investigate NVM for atomic page updates in database systems. Atomic page update is required for consistent recovery, and database systems generally use redundant writes to support atomic page update (e.g., doublewrite buffer in MySQL/InnoDB). However, redundant writes negatively affect the database and lifetime of storage devices (e.g., flash-based SSD). In this paper, we present LSBM, a log-structured buffer manager which updates pages atomically and efficiently using NVM. LSBM updates pages in an out-of-place manner to achieve atomicity and performs page buffering to improve performance. LSBM also reclaims the buffered pages on the fly to reduce the write traffic to storage. We implement LSBM using an NVDIMM as NVM and ported it to MySQL/InnoDB. The experimental results demonstrate that LSBM improves database performance and reduces write traffic on OLTP workloads.

An Empirical Evaluation of Enterprise and SATA-Based Transactional Solid-State Drives

In most file systems, performance is usually sacrificed in exchange for crash consistency, which ensures that data and metadata are restored consistently in the event of a system crash. To escape this trade-off between performance and crash consistency, recent researchers designed and implemented the transactional functionality inside Solid State Drives (SSDs). However, in order to investigate its benefit in a more realistic and standard fashion, this scheme should be re-evaluated in enterprise storage with standard interface. This paper explores the challenges and implications of a transactional SSD with extensive experiments. To evaluate the potential benefit of transactional SSD, we design and implement the transaction functionality in Samsung enterprise-class and SATA-based SSD (i.e., SM843TN) and name it TxSSD. We then modify the existing file systems (i.e., ext4 and btrfs) on topof TxSSD, making both file systems crash-consistent without redundant writes. We perform performance evaluation of two filesystems by using file I/O and OLTP benchmarks with a database. We also disclose and analyze the overhead of transactional functionality inside SSD. The experimental results show that TxSSD-aware file systems exhibit better performance compared to crash-consistent modes (i.e., data journaling mode of ext4 and cow mode of btrfs) but worse performance compared to weak consistent modes (i.e., ordered mode of ext4 and no datacow mode of btrfs).

A low-latency storage stack for fast storage devices

Modern storage systems are facing an important challenge of making the best use of fast storage devices. Even though the underlying storage devices are being enhanced, the traditional storage stack falls short of utilizing the enhanced characteristics, as it has been optimized specifically for hard disk drives. In this article, we optimize the storage stack to maximize the benefit of low latency that fast storage devices provide. Our approach is to simplify the I/O path from application to the fast storage device by removing inefficient layers and the conventional block I/O. The proposed stack consists of three layers: an optimized device driver, a low-latency file system called L2FS, and a simplified VFS. The device driver provides a simple file I/O API to the file system instead of the existing block I/O API. L2FS, a variant of EXT4, performs low-latency I/O operations by using the file I/O API that our optimized device driver provides. We implement our storage stack on Linux 3.14.3 and evaluate it with multiple benchmarks. The results show that our system improves the throughput by up to 6.6 times and reduces the latency by an average of 54% compared to the existing storage stack on fast storage.