Log-structured File System Research Articles

ZoneTrace: A Zone Monitoring Tool for F2FS on ZNS SSDs

We present ZoneTrace , a runtime monitoring tool for the Flash-Friendly File System (F2FS) on Zoned Namespace (ZNS) SSDs. ZNS SSD organizes its storage into zones of sequential write access. Due to ZNS SSD’s sequential write nature, F2FS is a log-structured file system that has recently been adopted to support ZNS SSDs. To present the space management with the zone concept between F2FS and the underlying ZNS SSD, we developed ZoneTrace , a tool that enables users to visualize and analyze the space management of F2FS on ZNS SSDs. ZoneTrace utilizes the extended Berkeley Packet Filter (eBPF) to trace the updated segment bitmap in F2FS and visualize each zone space usage accordingly. Furthermore, ZoneTrace is able to analyze on file fragmentation in F2FS and provides users with informative fragmentation histogram to serve as an indicator of file fragmentation. Using ZoneTrace ’s visualization, we are able to identify the current F2FS space management scheme’s inability to fully optimize space for streaming data recording in autonomous systems, which leads to serious file fragmentation on ZNS SSDs. Our evaluations show that ZoneTrace is lightweight and assists users in getting useful insights for effortless monitoring on F2FS with ZNS SSD with both synthetic and realistic workloads. We believe ZoneTrace can help users analyze F2FS with ease and open up space management research topics with F2FS on ZNS SSDs.

Optimizing the Cost of Garbage Collection in F2FS Using Working Set Strategy

As an important part of the operating system, the file system has always received wide attention, and different types of file system architectures have been constantly proposed and practiced, this time, we mainly focus on the log structured file system (LFS) type flash friendly file system (F2FS) file system. The existing garbage collection algorithm has offered a interface for future improvement. Hence, we tried to improve existing garbage collection algorithms by implementing the working set strategy in victim select algorithm and analyze the existing deficiencies of the F2FS file system. Under the original strategy, when F2FS selects a segment, it will select the section with the fewest valid blocks. After we change it, we have completed the balance consideration of the change time, the number of valid blocks, and the proportion of changes. It is expected that the Flash device will have the longer life. By using the proposed technique, the cost of garbage collection has reduced by 10%. At the same time, based on the cold and hot data separation characteristics of the F2FS file system, we propose optimization suggestions for the cold and hot data separation strategy.

Magma

We present Magma, a write-optimized high data density key-value storage engine used in the Couchbase NoSQL distributed document database. Today's write-heavy data-intensive applications like ad-serving, internet-of-things, messaging, and online gaming, generate massive amounts of data. As a result, the requirement for storing and retrieving large volumes of data has grown rapidly. Distributed databases that can scale out horizontally by adding more nodes can be used to serve the requirements of these internet-scale applications. To maintain a reasonable cost of ownership, we need to improve storage efficiency in handling large data volumes per node, such that we don't have to rely on adding more nodes. Our current generation storage engine, Couchstore is based on a log-structured append-only copy-on-write B+Tree architecture. To make substantial improvements to support higher data density and write throughput, we needed a storage engine architecture that lowers write amplification and avoids compaction operations that rewrite the whole database files periodically. We introduce Magma, a hybrid key-value storage engine that combines LSM Trees and a segmented log approach from log-structured file systems. We present a novel approach to performing garbage collection of stale document versions avoiding index lookup during log segment compaction. This is the key to achieving storage efficiency for Magma and eliminates the need for random I/Os during compaction. Magma offers significantly lower write amplification, scalable incremental compaction, and lower space amplification while not regressing the read amplification. Through the efficiency improvements, we improved the single machine data density supported by the Couchbase Server by 3.3x and lowered the memory requirement by 10x, thereby reducing the total cost of ownership up to 10x. Our evaluation results show that Magma outperforms Couchstore and RocksDB in write-heavy workloads.

SCJ: Segment Cleaning Journaling for Log-Structured File Systems

The append-only write scheme of the log-structured file system (LFS), which does not permit in- place updates, is suitable for flash memory. Therefore, LFSs have been adopted to manage various flash-memory-based storage systems. However, LFSs amplify user write requests owing to segment cleaning and frequent metadata write operations. Hence, the IO performance is degraded and the life span of the flash memory is reduced. In particular, when each segment cleaning invokes checkpointing to store dirty metadata modified via block relocation, irrelevant dirty metadata are written by the checkpointing operation, and the metadata write overhead occupies a significant proportion of the segment cleaning latency. Hence, we propose segment cleaning journaling (SCJ), which logs the block relocation information of segment cleaning at a specific journal area without invoking checkpointing. We implemented and evaluated the proposed SCJ by modifying F2FS. Experimental results show that SCJ can improve file system performance by 1.13–1.63 times compared with normal segment cleaning.

Pruning Deep Reinforcement Learning for Dual User Experience and Storage Lifetime Improvement on Mobile Devices

Background segment cleaning in log-structured file system has a significant impact on mobile devices. A low triggering frequency of the cleaning activity cannot reclaim enough free space for subsequent I/O, thus incurring foreground segment cleaning and impacting the user experience. In contrast, a high triggering frequency could generate excessive block migrations (BMs) and impair the storage lifetime. Prior works address this issue either by performance-biased solutions or incurring excessive memory overhead. In this article, a pruned reinforcement learning-based approach, MOBC, is proposed. Through learning the behaviors of I/O workloads and the statuses of logical address space, MOBC adaptively reduces the number of BMs and the number of triggered foreground segment cleanings. In order to integrate MOBC to resource-constraint mobile devices, a structured pruning method is proposed to reduce the time and space cost. The experimental results show that the pruned MOBC can reduce the worst case latency by 32.5%-68.6% at the 99.9th percentile, and improve the storage endurance by 24.3% over existing approaches, with significantly reduced overheads.

A Case for Application-Managed Flash

We propose a new I/O architecture for NAND flash-based SSDs, called application-managed flash (AMF) and present two case studies to show its usefulness. In a typical SSD controller, an intermediate software layer, called the flash translation layer (FTL), is employed between NAND flash chips and a host interface. The main responsibility of an FTL is to provide interoperability with conventional HDDs, but this interoperability comes at the cost of extra hardware resources and degraded I/O performance. The proposed AMF refactors the flash storage architecture so that an SSD controller exposes append-only segments, which do not permit overwriting. This refactoring dramatically improves performance of applications and reduces hardware costs by allowing applications to directly manage flash storage with minimal supports from the SSD controller. In order to understand the benefits of AMF, we study two popular applications: a log-structured file system (F2FS) and a key-value store (RocksDB). Our experiments show that the DRAM in the flash controller is reduced by 128X and the performances of the file system and the key-value store improve by 80 and 54 percent, respectively, over conventional SSDs.

Anti-Aging LFS: Self-Defragmentation With Fragmentation-Aware Cleaning

For several decades, filesystem aging has been widely studied, but nonetheless, it still remains an unsolved problem. Among various filesystems, log-structured filesystems have been reported to be vulnerable to fragmentation due to their append-only write policy. Fragmentation hinders various I/O activities such as sequential read and trim operations, regardless of the underlying storage types. This paper extensively analyzes the rationale behind performance degradation incurred by fragmentation on various types of storage devices. To eliminate fragmentation without additional I/O overhead, we propose an anti-aging log-structured filesystem, called AALFS. During segment cleaning, AALFS re-arranges the order of valid blocks based on inode number and file offset to eliminate existing fragmentation. To enhance the efficacy of the re-ordering process, the new victim selection policy of AALFS reflects the fragmentation degree of each segment in the selection of victim segments. Our experimental results show that AALFS effectively eliminates fragmentation by up to 99.8% and significantly improves sequential read performance on various types of storage devices. Particularly, AALFS improves the sequential read throughput of IOzone on hard disk drives by up to 22.8 times.

OrcFS

In this work, we develop the Orchestrated File System (OrcFS) for Flash storage. OrcFS vertically integrates the log-structured file system and the Flash-based storage device to eliminate the redundancies across the layers. A few modern file systems adopt sophisticated append-only data structures in an effort to optimize the behavior of the file system with respect to the append-only nature of the Flash memory. While the benefit of adopting an append-only data structure seems fairly promising, it makes the stack of software layers full of unnecessary redundancies, leaving substantial room for improvement. The redundancies include (i) redundant levels of indirection (address translation), (ii) duplicate efforts to reclaim the invalid blocks (i.e., segment cleaning in the file system and garbage collection in the storage device), and (iii) excessive over-provisioning (i.e., separate over-provisioning areas in each layer). OrcFS eliminates these redundancies via distributing the address translation, segment cleaning (or garbage collection), bad block management, and wear-leveling across the layers. Existing solutions suffer from high segment cleaning overhead and cause significant write amplification due to mismatch between the file system block size and the Flash page size. To optimize the I/O stack while avoiding these problems, OrcFS adopts three key technical elements. First, OrcFS uses disaggregate mapping , whereby it partitions the Flash storage into two areas, managed by a file system and Flash storage, respectively, with different granularity. In OrcFS, the metadata area and data area are maintained by 4Kbyte page granularity and 256Mbyte superblock granularity. The superblock-based storage management aligns the file system section size, which is a unit of segment cleaning, with the superblock size of the underlying Flash storage. It can fully exploit the internal parallelism of the underlying Flash storage, exploiting the sequential workload characteristics of the log-structured file system. Second, OrcFS adopts quasi-preemptive segment cleaning to prohibit the foreground I/O operation from being interfered with by segment cleaning. The latency to reclaim the free space can be prohibitive in OrcFS due to its large file system section size, 256Mbyte. OrcFS effectively addresses this issue via adopting a polling-based segment cleaning scheme. Third, the OrcFS introduces block patching to avoid unnecessary write amplification in the partial page program. OrcFS is the enhancement of the F2FS file system. We develop a prototype OrcFS based on F2FS and server class SSD with modified firmware (Samsung 843TN). OrcFS reduces the device mapping table requirement to 1/465 and 1/4 compared with the page mapping and the smallest mapping scheme known to the public, respectively. Via eliminating the redundancy in the segment cleaning and garbage collection, the OrcFS reduces 1/3 of the write volume under heavy random write workload. OrcFS achieves 56% performance gain against EXT4 in varmail workload.

StrongBox

Full-drive encryption (FDE) is especially important for mobile devices because they contain large quantities of sensitive data yet are easily lost or stolen. Unfortunately, the standard approach to FDE-the AES block cipher in XTS mode-is 3--5× slower than unencrypted storage. Authenticated encryption based on stream ciphers is already used as a faster alternative to AES in other contexts, such as HTTPS, but the conventional wisdom is that stream ciphers are unsuitable for FDE. Used naively in drive encryption, stream ciphers are vulnerable to attacks, and mitigating these attacks with on-drive metadata is generally believed to ruin performance. In this paper, we argue that recent developments in mobile hardware invalidate this assumption, making it possible to use fast stream ciphers for FDE. Modern mobile devices employ solid-state storage with Flash Translation Layers (FTL), which operate similarly to Log-structured File Systems (LFS). They also include trusted hardware such as Trusted Execution Environments (TEEs) and secure storage areas. Leveraging these two trends, we propose StrongBox, a stream cipher-based FDE layer that is a drop-in replacement for dm-crypt, the standard Linux FDE module based on AES-XTS. StrongBox introduces a system design and on-drive data structures that exploit LFS»s lack of overwrites to avoid costly rekeying and a counter stored in trusted hardware to protect against attacks. We implement StrongBox on an ARM big.LITTLE mobile processor and test its performance under multiple popular production LFSes. We find that StrongBox improves read performance by as much as 2.36× (1.72× on average) while offering stronger integrity guarantees.

로그 구조 파일 시스템의 파일 단편화 해소를 위한 클리닝 기법

로그 구조 파일 시스템에서는 쓰기 작업을 처리할 때 새로운 블록들이 순차적으로 할당된다. 그러나, 다수의 프로세스가 번갈아가며 동기적 쓰기 작업을 요청할 경우, 파일 시스템 상에서는 각 프로세스가 생성한 파일이 단편화될 수 있다. 이 파일 단편화는 읽기 요청을 처리할 때 다수의 블록 I/O를 발생시키기 때문에 읽기 성능을 저하시킨다. 게다가, 미리 읽기 기능은 한 번에 요청되는 데이터의 양을 증가시킴으로써 성능 저하를 더욱 심화시킨다. 이에, 본 논문에서는 파일 단편화 문제를 해결하기 위해 로그구조 파일 시스템의 새로운 클리닝 기법을 제안한다. 제안 기법은 로그 구조 파일 시스템의 클리닝 과정 중 유효 데이터 블록을 아이노드 번호 순으로 정렬함으로써 한 파일의 데이터 블록들을 인접하게 재배치한다. 실험 결과, 제안한 클리닝 기법이 클리닝 전에 비해 약 60%의 파일 단편화를 제거하였고, 그 결과로 미리 읽기 기능을 적용했을 때 읽기 성능을 최고 21%까지 향상시키는 것을 확인하였다.

Design and Implementation of a Journaling File System for Phase-Change Memory

Journaling file systems are widely used in modern computer systems as they provide high reliability at reasonable cost. However, existing journaling file systems are not efficient for emerging PCM (phase-change memory) storage because they are optimized for hard disks. Specifically, the large amount of data that they write during journaling degrades the performance of PCM storage seriously as it has a long write latency. In this paper, we present a new journaling file system for PCM, called Shortcut-JFS, that reduces write traffic to PCM by more than half of existing journaling file systems running on block I/O interfaces. To do this, we devise two novel schemes that can be used under byte-addressable I/O interfaces: 1) differential logging that journals only the modified part of a block and 2) in-place checkpointing that eliminates the overhead of block copying. We implement Shortcut-JFS on Linux 2.6.32 and measure the performance of Shortcut-JFS compared to those of existing journaling and log-structured file systems. The results show that the performance improvement of Shortcut-JFS against Ext4 and LFS is 54 and 96 percent, respectively, on average.

부분 가비지 컬렉션을 이용한 로그 구조 파일시스템의 쓰기 성능 개선

Recently, flash storages devices have become popular. Log-structured file systems (LFS) are suitable for flash storages since these can provide high write performance by only generating sequential writes to the flash device. However, LFS should perform garbage collections (GC) in order to reclaim obsolete space. Recently, a slack space recycling (SSR) technique was proposed to reduce the GC overhead. However, since SSR generates random writes, write performance can be negatively impacted if the random write performance is significantly lower than sequential write performance of the target device. This paper proposes a partial garbage collection technique that copies only a part of valid blocks in a victim segment in order to increase the size of the contiguous invalid space to be used by SSR. The experiments performed in this study show that the write performance in an SD card improves significantly as a result of the partial GC technique.

Design and Implementation of a Log-Structured File System for Flash-Based Solid State Drives

Even in modern SSDs, the disparity between random and sequential write bandwidth is more than 10-fold. Moreover, random writes can shorten the limited lifespan of SSDs because they incur more NAND block erases per write. To overcome the problems of random writes, we propose a new file system, SFS, for SSDs. SFS is similar to the traditional log-structured file system (LFS) in that it transforms all random writes at the file system level to sequential ones at the SSD level, as a way to exploit the maximum write bandwidth of the SSD. But, unlike the traditional LFS, which performs hot/cold data separation on segment cleaning, SFS takes a new on writing data grouping strategy. When data blocks are to be written, SFS puts those with similar update likelihood into the same segment for sharper bimodal distribution of segment utilization, and thus aims at minimizing the inevitable segment cleaning overhead that occurs in any log-structured file system. We have implemented a prototype SFS by modifying Linux-based NILFS2 and compared it with three state-of-the-art file systems using several realistic workloads. Our experiments on SSDs show that SFS outperforms LFS by up to 2.5 times in terms of throughput. In comparison to modern file systems, SFS drastically reduces the block erase count inside SSDs by up to 23.3 times. Although SFS was targeted for SSDs, its data grouping on writing would also work well in HDDs. To confirm this, we repeated the same set of experiments over HDDs, and found that SFS is quite promising in HDDs: although the slow random reads in HDDs make SFS slightly less effective, SFS still outperforms LFS by 1.7 times.

A Log-Structured File System Based on LevelDB

Traditional file systems have some shortages in storing small files, such as randomness of data layout, waste of disk space and lack of inode resources. In this thesis, a log-structured file system named LevelFS based on LevelDB is presented. By setting the write buffer, it can make disk randomized writes of small files into disk sequential writes, and reduce the distance of related data, so as to improve the read and write performance of file system. Experiments show that LevelFS can greatly improve read and write performance of small files without affect the large ones.

Slack Space Recycling: Delaying On-Demand Cleaning in LFS for Performance and Endurance

The Log-structured File System (LFS) transforms random writes to a huge sequential one to provide superior write performance on storage devices. However, LFS inherently suffers from overhead incurred by cleaning segments. Specifically, when file system utilization is high and the system is busy, write performance of LFS degenerates significantly due to high cleaning cost. Also, in the newer flash memory based SSD storage devices, cleaning leads to reduced SSD lifetime as it incurs more writes. In this paper, we propose an enhancement to the original LFS to alleviate the performance degeneration due to cleaning when the system is busy. The new scheme, which we call Slack Space Recycling (SSR), allows LFS to delay on-demand cleaning during busy hours such that cleaning may be done when the load is much lighter. Specifically, it writes modified data directly to invalid areas (slack space) of used segments instead of cleaning on-demand, pushing back cleaning for later. SSR also has the added benefit of increasing the lifetime of the now popular SSD storage devices. We implement the new SSR-LFS file system in Linux and perform a large set of experiments. The results of these experiments show that the SSR scheme significantly improves performance of LFS for a wide range of storage utilization settings and that the lifetime of SSDs is extended considerably.

Parallel File System Analysis Through Application I/O Tracing

Input/Output (I/O) operations can represent a significant proportion of the run-time of parallel scientific computing applications. Although there have been several advances in file format libraries, file system design and I/O hardware, a growing divergence exists between the performance of parallel file systems and the compute clusters that they support. In this paper, we document the design and application of the RIOT I/O toolkit (RIOT) being developed at the University of Warwick with our industrial partners at the Atomic Weapons Establishment and Sandia National Laboratories. We use the toolkit to assess the performance of three industry-standard I/O benchmarks on three contrasting supercomputers, ranging from a mid-sized commodity cluster to a large-scale proprietary IBM BlueGene/P system. RIOT provides a powerful framework in which to analyse I/O and parallel file system behaviour—we demonstrate, for example, the large file locking overhead of IBM's General Parallel File System, which can consume nearly 30% of the total write time in the FLASH-IO benchmark. Through I/O trace analysis, we also assess the performance of HDF-5 in its default configuration, identifying a bottleneck created by the use of suboptimal Message Passing Interface hints. Furthermore, we investigate the performance gains attributed to the Parallel Log-structured File System (PLFS) being developed by EMC Corporation and the Los Alamos National Laboratory. Our evaluation of PLFS involves two high-performance computing systems with contrasting I/O backplanes and illustrates the varied improvements to I/O that result from the deployment of PLFS (ranging from up to 25× speed-up in I/O performance on a large I/O installation to 2× speed-up on the much smaller installation at the University of Warwick).

Improving data integrity and performance of cryptographic log structured file systems

Improving data integrity and performance of cryptographic log structured file systems

Performance of greedy garbage collection in flash-based solid-state drives

In flash-based solid-state drives (SSD) and log-structured file systems, new data is written out-of-place, which over time exhausts the available free space. New free space is created by the garbage-collection process, which reclaims the space occupied by invalidated data. The write amplification, incurred because of the additional write operations performed by the garbage-collection mechanism is a critical factor that negatively affects the lifetime and endurance of SSDs. We develop two complementary theoretical models of the SSD operation for uniformly-distributed random small user writes: a Markov chain model, which is useful to explore the performance characteristics of small and medium-sized systems, and a second model that captures the behavior of large systems. The combination of both models allows us to comprehensively characterize the system operation and behavior. Results of theoretical and practical importance are analytically derived and confirmed by means of simulation. Our results demonstrate that (i) as the system occupancy increases, the write amplification increases; (ii) as the number of blocks increases, the write amplification decreases and approaches a lower bound; and (iii) as the number of pages contained in a block increases, the write amplification increases and approaches an upper bound. They also show that, for large systems, the number of free pages reclaimed by the greedy garbage-collection mechanism after each block recycling takes one of two successive values, which provides a quasi-deterministic performance guarantee.

FRASH

In this work, we develop a novel hybrid file system, FRASH, for storage-class memory and NAND Flash. Despite the promising physical characteristics of storage-class memory, its scale is an order of magnitude smaller than the current storage device scale. This fact makes it less than desirable for use as an independent storage device. We carefully analyze in-memory and on-disk file system objects in a log-structured file system, and exploit memory and storage aspects of the storage-class memory to overcome the drawbacks of the current log-structured file system. FRASH provides a hybrid view storage-class memory. It harbors an in-memory data structure as well as a on-disk structure. It provides nonvolatility to key data structures which have been maintained in-memory in a legacy log-structured file system. This approach greatly improves the mount latency and effectively resolves the robustness issue. By maintaining on-disk structure in storage-class memory, FRASH provides byte-addressability to the file system object and metadata for page, and subsequently greatly improves the I/O performance compared to the legacy log-structured approach. While storage-class memory offers byte granularity, it is still far slower than its DRAM counter part. We develop a copy-on-mount technique to overcome the access latency difference between main memory and storage-class memory. Our file system was able to reduce the mount time by 92% and file system I/O performance was increased by 16%.

A Buffer Management Issue in Designing SSDs for LFSs

This letter introduces a buffer management issue in designing SSDs for log-structured file systems (LFSs). We implemented a novel trace-driven SSD simulator in SystemC language, and simulated several SSD architectures with the NILFS2 trace. From the results, we give two major considerations related to the buffer management as follows. (1) The write buffer is used as a buffer not a cache, since all write requests are sequential in NILFS2. (2) For better performance, the main architectural factor is the bus bandwidth, but 332MHz is enough. Instead, the read buffer makes a key role in performance improvement while caching data. To enhance SSDs, accordingly, it is an effective way to make efficient read buffer management policies, and one of the examples is tracking the valid data zone in NILFS2, which can increase the data hit ratio in read buffers significantly.