Towards a Scalable and Write-Free Multi-version Checkpointing Scheme in Solid State Drives

Most researches of Solid State Drives (SSDs) architectures rely on Flash Translation Layer (FTL) algorithms and wear-leveling; however, internal parallelism in Solid State Drives has not been well explored. In this research, we proposed a new strategy to improve SSD write performance by enhancing internal parallelism inside SSDs. A SDRAM buffer is added in the design for buffering and scheduling write requests. Because the same logical block numbers may be translated to different physical numbers at different times in FTL, the on-board SDRAM buffer is used to buffer requests at the lower level of FTL. When the buffer is full, same amount of data will be assigned to each storage package in SSDs to enhance internal parallelism. To accurately evaluate performance, we use both synthetic workloads and real-world applications in experiments. We compare the enhanced internal parallelism scheme with the traditional LRU strategy since it is unfair to compare an SSD having buffer with an SSD without a buffer. The simulation results demonstrate that the writing performance of our design is significantly improved compared with the LRU-cache strategy with the same amount of buffer sizes.

A comprehensive survey of issues in solid state drives

Recently, solid-state drives (SSDs) have been used in a wide range of emerging data processing systems. Essentially, an SSD is a complex embedded system that involves both hardware and software design. For the latter, firmware modules such as the flash translation layer (FTL) orchestrate internal operations and flash management, and are crucial to the overall I/O performance of an SSD. Despite the rapid development of new features of SSDs in the market, the research of flash firmware has been mostly simulation-based due to the lack of a realistic and extensible SSD development platform. In this paper, we propose SoftSSD, a software-defined SSD development platform for rapid flash firmware prototyping. The core of SoftSSD is a novel framework with an event-driven programming model. With the programming model, new FTL algorithms can be implemented and integrated into a full-featured flash firmware in a straightforward way. The resulting flash firmware can be deployed and evaluated on a hardware development board, which can be connected to a host system via PCIe and serve as a normal NVMe SSD. Different from existing hardware-oriented development platforms, SoftSSD implements the majority of SSD components (e.g., host interface controller) in software so that data flows and internal states that were once confined in the hardware can now be examined with a software debugger, providing the observability and the extensibility that are critical to the rapid prototyping and research of flash firmware. This paper describes the programming model and hardware design of SoftSSD. We also perform experiments with real application workloads on a prototype board to demonstrate the performance and usefulness of SoftSSD and released the open-source code of SoftSSD for public access.

MaCACH: An adaptive cache-aware hybrid FTL mapping scheme using feedback control for efficient page-mapped space management

Redundant arrays of independent disk (RAID) is an efficient approach to relieve reliability sacrifice caused by aggressive scale-out of solid state drives (SSDs). Unfortunately, RAID is unfriendly to SSDs due to redundant parity write and data rebuilding. This paper proposes a wear aware RAID design for SSDs, called WARD , which: 1) adaptively organizes RAID stripes according to real-time interblock unbalanced wear for relieving high performance and storage overhead caused by parity data and 2) migrates blocks about to break in advance and leaves these blocks unused to reduce data rebuilding overhead. An efficient block wear detection scheme is employed to detect block wear during the whole lifetime of SSDs. Beginning with a large stripe width RAID instead of the redundant worst-case RAID, WARD reorganizes RAID stripes once wear blocks with high bit error rates come out. WARD divides the original stripe into several short width RAID stripes according to the number of wear blocks and separates all wear blocks into different stripes. This not only reduces parity redundancy but also provides high reliability to avoid more than RAID recoverable error-prone chunks remaining in one stripe. For high wear blocks tending to wear-out, data in them are migrated in advance and then the blocks are left unused, which efficiently avoids performance shock caused by data rebuilding. A reliability model considering interblock unbalanced wear is proposed and reveals that WARD provides a high and stable reliability and greatly prolongs the lifetime of SSDs. Comprehensive experiments based on an SSDsim derivative simulator are carried out and experiment results show that WARD considerably improves system performance compared to the worst-case RAID.

Solid-State Drives (SSDs) have gained acceptance by providing the same block device abstraction as magnetic hard drives, at the cost of suboptimal resource utilisation and unpredictable performance. Recently, Open-Channel SSDs have emerged as a means to obtain predictably high performance, based on a clean break from the block device abstraction. Open-channel SSDs embed a minimal flash translation layer (FTL) and expose their internals to the host. The Linux open-channel SSD subsystem, LightNVM, lets kernel modules as well as user-space applications control data placement and I/O scheduling. This way, it is the host that is responsible for SSD management. But what kind of performance model should the host rely on to guide the way it manages data placement and I/O scheduling? For addressing this question we have defined uFLIP-OC, a benchmark designed to identify the I/O patterns that are best suited for a given open-channel SSD. Our experiments on a Dragon-Fire Card (DFC) SSD, equipped with the OX controller, illustrate the performance impact of media characteristics and parallelism. We discuss how uFLIP-OC can be used to guide the design of host-based data systems on open-channel SSDs.

Solid State Drives (SSDs) which connect NAND-flash memory in parallel is going to replace Hard Disk Drives (HDDs). The physical trait of SSD is different from HDD and it uses Flash Translation Layer (FTL) to emulate HDD. Garbage Collection is the process of making an available sphere in SSD which has no function of an over-write. In the case of general policy of FTL, both of valid and invalid pages are randomly mixed, but if it could be separated, an effect of Garbage Collection can be improved. This paper presents a double hot/cold clustering scheme that separates the frequently overwritten region from the opposite. The performance evaluation result shows that the improvement is between 44.3% in maximum and 3.9% in minimum.Keywordsgarbage collectionhot/cold clusteringpage mappingflash translation layerNAND flash memory

With the development of high-density flash memory, the price decreases, and the program/erase capability for each storage cell also decreases. Error correcting should be applied at all levels in SSD (Solid State Drive) based storage systems. This paper focuses on how to build a redundant array of Open-Channel SSDs, and proposes Log-ROC to enforce reliability at the drive level. Log-ROC adopts log structure, which means each write will be firstly buffered in the internal cache, and then the data in the cache are encoded in corresponding RAID level and flushed out in new locations as logs. Such mechanism is integrated with the host-side FTL (flash translation layer), effectively eliminating the parity update issue existing in RAID5 systems. We have built Log-ROC on 4 Open-Channel SSDs and evaluated Log-ROC with FIO and Filebench workloads. Compared with RAID5 on conventional SSDs, Log-ROC can achieve 1.91∼5.29× speedup in throughput on different workloads.

Solid state drives (SSDs) implement a log-structured write pattern, where obsolete data remains stored on flash pages until the flash translation layer (FTL) erases them. erase() operations, however, cannot erase a single page, but target entire flash blocks. Since these victim blocks typically store a mix of valid and obsolete pages, FTLs have to copy the valid data to a new block before issuing an erase() operation. This process therefore increases the latencies of concurrent I/Os and reduces the lifetime of flash memory. Data classification schemes identify data pages with similar update frequencies and group them together. FTLs can use this grouping to design garbage collection strategies to find victim blocks that have less valid data with respect to having no data classification, and therefore to significantly reduce the number of additional I/Os. Previous data classification algorithms have been designed without leveraging special features of flash memory and often rely on workload-specific configurations. Our classifier FADaC tunes its parameters online and operates on any given amount of memory by storing additional information within the metadata of flash pages. Additional read() requests for the classification are so few that FADaC reduces the internal flash overhead by up to 45% compared to the best classifier from previous work.

Many researchers have studied and proposed various kinds of host-level flash translation layer (FTL). Host-level FTL allows the host system to handle the internal architecture of solid state drives (SSDs), and thus tries to overcome the performance or the functionality failure of traditional SSDs which only handle the I/O requests with the block I/O interface. However, existing studies only focused on the functionalities of the host-level FTL while less researches have been done on how the FTL should work on the operating system (OS) rather than bare-metal firmware. From the observation, we found that existing host-level FTL suffers from the performance bottleneck caused by unscalable software design of FTL. Therefore, we propose an optimizing scheme which efficiently processes the I/O operations requested by multiple users and guarantees the scalability of the storage stack. Our experimental results show that the performance of our scheme improves the performance of software stack in twice or more compared to the existing host-level FTL.

Recent advancements in flash-based solid state drive (SSD) make it a highly desirable storage device, especially for data-intensive applications. There are significant more SSDs used in data centers and high performance computing systems. SSDs perform one or two orders better than traditional hard disk drives generally. However, the performance of random writes on SSDs, especially small random writes, is still largely limited due to the garbage collection (GC) process. Existing work tried to utilize the on-device RAM as a write cache to improve the write performance, however directly utilizing it as a normal write cache under utilizes the RAM cache. In this poster, we present our initial study of a cache management scheme that hides the GC latency.

Solid State Drives (SSDs) have become popular for mobile devices and PCs nowadays due to their advantages compared with conventional hard disk drives. However, they suffer from endurance problems. An effective approach to increase the endurance of an SSD is to improve the management algorithm of the RAM buffer, a cache-like structure inside the SSD. There are several previous studies of RAM buffer management algorithms which improve the I/O performance and endurance of SSDs by reordering the write operations and exploiting the temporal locality of the write stream. We observe that the sequential write patterns of the write stream can be exploited to reduce the number of expensive erase operations. Using this insight, we propose a new effective method for RAM buffer management algorithms to enhance the endurance of SSDs. We evaluate our proposed method by software simulation and the result shows that the proposed method reduces the number of erasures and average response time compared to the best existing method by up to 17.3% and 16.9% respectively.

Solid-State Drives (SSDs) are recently employed in enterprise servers and high-end storage systems in order to enhance performance of storage subsystem. Although employing high speed SSDs in the storage subsystems can significantly improve system performance, it comes with significant reliability threat for write operations upon power failures. In this paper, we present a comprehensive analysis investigating the impact of workload dependent parameters on the reliability of SSDs under power failure for variety of SSDs (from top manufacturers). To this end, we first develop a platform to perform two important features required for study: a) a realistic fault injection into the SSD in the computing systems and b) data loss detection mechanism on the SSD upon power failure. In the proposed physical fault injection platform, SSDs experience a real discharge phase of Power Supply Unit (PSU) that occurs during power failure in data centers which was neglected in previous studies. The impact of workload dependent parameters such as workload Working Set Size (WSS), request size, request type, access pattern, and sequence of accesses on the failure of SSDs is carefully studied in the presence of realistic power failures. Experimental results over thousands number of fault injections show that data loss occurs even after completion of the request (up to 700ms) where the failure rate is influenced by the type, size, access pattern, and sequence of IO accesses while other parameters such as workload WSS has no impact on the failure of SSDs.

The performance and lifetime of highperformance solid-state drives (SSDs) can be improved by data compression, which can reduce the amount of data physically transferred from/to flash memory. In this paper, we present our experience of building a high-performance solid-state drive using a hardware accelerated compression module called BlueZIP. In order to fully exploit the BlueZIP module, we devise a compression-aware flash translation layer (FTL), called CaFTL, which supports compressionaware address mapping and garbage collection for BlueZIP. For poorly compressed pages, CaFTL supports selective compression so that unnecessary compression can be avoided. We have implemented a complete SSD prototype with BlueZIP on an FPGA-based custom SSD platform and evaluated its effectiveness using realistic workloads. Our evaluation results show that BlueZIP can increase the lifetime of the SSD prototype by 26% as well as improve read and write performance by 20% and 27%, respectively, on average1.

The flash translation layer (FTL) of a modern solid-state drive (SSD) employs the address translation because a host system and a flash memory have different granularity units. For this reason, a large piece of data is broken into several pages, which contain partial-pages. Writing these partial-pages induces lots of read-modify-write operations that increase write amplification. If there is a locality among consecutive write accesses, delaying the cache eviction of partial pages can help reduce the number of flash writes. However, conventional cache replacement policies, which are not based on access characteristics, are not easy to take advantage of the delayed cache eviction. Therefore, in this paper, we propose the access characteristic-based cache replacement policy to reduce the number of cache evictions due to partial-page updates. First, the policy distinguishes eviction priority by data size because the access frequency of cache lines varies depending on the requested data size. Second, the policy manages eviction priority by receiving the data access characteristic, such as reusability, from the host. The proposed policy reduces the number of flash writes due to cache eviction by 10.6 % and 9.4 % on average, respectively, compared to FIFO and LRU policies.