single I/O completes. F2FS however suffers from severe lock contention
overheads, where the performance of the multi-headed logging is nearly fully
deprecated due to the serialization of data updates [157]. In particular, as
data has to be written persistently before inode and other metadata can be
written. Furthermore, F2FS suffers from contention of the in-memory data
structures, for which it uses reader-writer semaphores for read and write
operations from the user (termed external I/O operations), and reader-writer
locks for writing of checkpoints and other metadata (termed internal
operations) [157]. As lock counters are shared among all cores, cache
coherence adds a significant overhead that increases with more cores. Max
[157] extends F2FS to increase the concurrency scalability with three main
modifications.

Firstly, in order to eliminate cache coherence overheads, it introduces a
Reader Pass-through Semaphore (RPS) that uses a per-process counter. Secondly,
the shared data structures in memory are partitioned by the inode, such that
concurrent accessing does not require locking on parts of the radix tree, but
instead on an inode basis. Lastly, it utilizes multiple independent logs,
called a Minor Log (mlog), which are accessed concurrently. The different
between mlog and multi-headed logging in F2FS is that atomic data blocks are
mapped to the same mlog, eliminating the need to ensure concurrency control
across different logs. Ordering for persistence, ensuring data blocks are
written before metadata, is delegated to the recovery mechanism using a global
versioning number in each inode to identify ordering across mlog s, and
recover the most recent version number in case of a system crash. These
mechanisms eliminate much of the needed concurrency control, which
sequentialized major parts of operations and hindered multicore scalability.

With this increased concurrency capabilities, the file system can issue more
I/O requests to the device, allowing to leverage a higher degree of on-device
parallelism. Similarly, DevFS [117] utilizes the parallel capabilities by
exploiting the high number of I/O queues supported by NVMe. It maps I/O queues
to individual files, allowing single file operations to submit I/O s
concurrently without interfering on the I/O queue, therefore increasing the
per-file concurrency as well. Likewise to the concept of mlog, SpanFS [114]
maps files and directories to different domains, such that individual domains
can be accessed in parallel. Such methods have a higher lock granularity,
where concurrency below the lock granularity is not possible, as a single
process is holding the lock. Therefore, instead of holding locks for
individual inodes or files, preventing concurrent writing to the same inode or
file, Lee et al. [142] extend F2FS to utilize Range Locking (RL), in which
ranges of a file are locked, and different ranges can be written concurrently.
Therefore, it provides the possibility for intra-file parallelism.

ALFS [150], exploits the flash parallelism by mapping consecutive file system
segments to the flash channels and utilizing different I/O queues for each
flash channel. Similarly, ParaFS [276] implements parallelism-aware
scheduling, which also maintains different I/O queues for each channel.
However, it extends this concept by using a dispatching phase and a request
scheduling phase. The dispatching phase optimizes write I/O s by scheduling
I/O requests to the respective channels based on the utilization of the
channel, such that the least utilized channels receives more requests. All
requests are assigned a weight, which indicates their priority in the queue,
where read requests weight is lower than that of write requests, because of
the asymmetric performance of flash storage. During the request scheduling
phase the scheduler assigns slices to the read and write/erase operations in
the individual queues, such that if the time from the slice of a read
operation is up and the queue contains no other read requests, a write or
erase is scheduled, based on a fairness formula that incorporates the amount
of free space in the block and concurrently active erase operations on other
channels. This allows to minimize the erase operations on the flash, giving
always free channels to utilize and maintain a fair schedule between write and
erase operations.

###  9.3 Summary

Due to the architecture of flash storage providing a high degree of
parallelism, numerous methods are employed to leverage these parallel units in
order to maximize the performance. Depending on the level of flash
integration, particular design choices can be made, such as clustered
allocation and striping can be achieved with flash SSD integration, by
providing large write I/O requests such that the FTL can stripe the data
across parallel units. With a higher degree of control over the flash storage,
file systems can directly rely on utilizing concurrency to leverage the
parallelism of flash storage.

##  10 FIC-5: Wear Leveling

As flash cells wear out over time, it is important to utilize the flash evenly
to avoid burning out particular flash cells faster than others. The
possibility for ensuring even wear at the different levels of integration is
limited, as at the SSD flash integration level, the FTL handles all wear
leveling, without host considerations. However, similar to prior flash
integration challenges, several mechanisms are nonetheless applicable. In
particular, reducing the write traffic to the flash device, as less writing
incurs less flash wear, and particularly flash-specific data structures
inherently provide a degree of wear leveling. Based on the sequential write
requirement, data structures, such as the LFS must write sequentially in an
append-only fashion, which evenly writes the space. At closer to flash
integrations, where host systems have more control over the flash management,
there are particular mechanisms to ensure better flash wear. Table 9 depicts
the methods we discuss in this section for enabling increased wear leveling
for file systems.

Mechanism |  File Systems
---|---
Write Optimised Data Structures (Section 6.1) |  [245, 89, 217, 103, 57]
Reducing Write Traffic (Section 6.3) |  [86, 158, 257, 57, 99, 90, 185, 283, 151]
GC Policies (Section 7.3) |  [1, 272, 74, 193]
Write & Read Leveling (Sections 10.1 and 10.2) |  [159, 150, 259, 148]
Table 9: Mechanisms for file systems to deal with wear leveling of the flash
storage, and the respective file systems that implement a particular
mechanism. Green highlighted table cells depict previously discussed
mechanisms with their respective section.

###  10.1 Write Leveling

Several flash integration challenges proved data grouping to be an effective
method for dealing with GC overheads and I/O amplification. However, this can
have an effect on the flash storage. In particular the hot data, such as file
system metadata which is more frequently updated and written, must be moved
across the flash space more than cold data. CFFS [159] therefore switches the
allocation areas for metadata and data blocks, such that an erased metadata
block becomes a free data block. Therefore, cold data should be placed in
blocks that have been written more frequently, whereas hot data should be
placed in blocks with a lower write count history. The principle of migrating
cold data from less written blocks, which are also referred to as younger
blocks, to more frequently written, older blocks, is referred to as cold-data
migration, and similarly moving hot data from old blocks to younger blocks is
known as hot-data migration [26]. These methods are commonly used in FTL
implementations due to their simplicity and effectiveness, and similarly in
file systems such as ALFS [150].

Wear leveling is an increasingly vital concern on file systems that utilize
flash dual mode [259, 148], where it switches the flash level to increase
performance for critical I/O requests. Due to the lowering in flash cell
level, the same amount of written data requires a larger amount of space,
where a switch from MLC to SLC divides the capacity in half, requiring double
the space for the same I/O request. Therefore, these file systems include a
write budget that is maintained for the areas, and dynamically resizes the
available lower cell level area, such as decreasing the space if the wear is
reaching a threshold. This switches the cell level back to a higher number,
allowing to write more with less wear. Additionally, the file systems utilize
the wear budget in order to identify if an I/O request should be redirected to
the larger cell area, instead of being written to the lower cell level area.

###  10.2 Read Leveling

While write operations are the major cause of flash cells burning out, read
operations also pay a toll on flash cells, as the current flash cell
technology utilizes flash cells that are only capable of holding very few
electrons (determining the charge of the gate) due to their size [163, 231].
This makes the cells increasingly susceptible to read disturbance [161], where
reading of a page results in shifting of voltages in nearby cells (typically
in the same block), requiring frequent rewriting to ensure the charge stays
consistent. In order to control read disturbance, Liu et al. [161] propose to
read-leveling mechanisms in the FTL. While their proposal is aimed at FTL
implementations, the ideas are applicable to file systems for flash storage
devices. With the proposed read-leveling, the read-hot data, that is read more
frequently, is isolated from other data pages by placing the hot pages into
shadow blocks, which contain no valid data, in order to avoid disturbing that
data. However, this requires to identify the read-hot pages, where a tracking
of read counters for each page would require significant resources. Therefore,
a second-chance monitoring strategy is proposed, which initially tracks the
reads for each block, therefore requiring counters at a higher block
granularity, and upon reaching a threshold indicating the block contains read-
hot pages, the individual pages in the block are tracked on their read
counters. Finally, the pages in these blocks that reach a certain threshold
are copied to the shadow blocks. Therefore, this avoids the tracking of read
counters for individual pages and only copies read-hot pages into the shadow
blocks. While this strategy requires copying of read-hot pages to shadow
blocks, it minimizes read disturbance which in turn minimizes the WA it
causes.

###  10.3 Summary

In addition to previously discussed mechanisms to reduce I/O amplification and
GC, resulting in decreased wear of the flash storage, write leveling, ensuring
that write requests are spread across the available storage space, and read
leveling are important mechanisms for ensuring the longevity of the flash
storage.

##  11 FIC-6: I/O Management

Given that flash storage has the capabilities to achieve single digit
$\mu$-second latency, whereas overheads in the software stack, such as context
switching in the kernel caused by system calls, can already require
$\mu$-seconds to complete [233], making software the dominating factor in
overheads [21, 22, 63, 225, 250]. In addition, interrupts cause significant
overheads for systems. Aimed at slow storage devices, the I/O request is
submitted to the device, the context is switched, such that the process can
continue with other work, and upon completion of the I/O, the host is
interrupted, and the context is switched again. Any added interrupt on the I/O
path can cause significant delays [230]. Cache effects are another drawback of
context switching, since other work is continued, replacing data in the
caches, it requires bringing the replaced data back into the caches after the
interrupt and resuming of the prior context. Similarly, it also causes
Translation Lookaside Buffer (TLB) pollution on the host system. A different
approach to submitting I/O requests is with polling, which eliminates the need
for context switches. With polling, the I/O request is submitted and instead
of continuing other work, the process regularly checks the I/O for completion.
Using polling for I/O requests has been shown to be a favored method of
building application for fast storage devices [136, 268, 52].

Particular for fast storage devices, with the utilization of synchronous I/O,
to saturate the storage device, additional threads are required, which each
submit I/O requests to the numerous I/O queues in the of the storage device.
However, this mechanism does not scale efficiently, where each thread must
wait until the I/O request is completed, and thread scheduling overheads are
introduced. Therefore, with asynchronous I/O the threads do not wait for
completion, but instead submit a larger number of I/O requests each, allowing
to fill the device I/O queues more effectively. The I/O requests for which a
thread as submitted a request, but have not completed, are referred to as
outstanding or in-flight I/O requests. Table 10 shows the mechanisms for host
systems to better leverage the flash storage performance and minimize
overheads. In addition to file systems implementing particular mechanisms, we
discuss more general methods applicable to all applications for benefiting
from flash storage and enhancing performance.

Mechanism |  File Systems
---|---
I/O Operations (Section 11.1) |  [245]
I/O Scheduler (Section 11.2) |  [209]
I/O Path - User-Space File Systems (Section 11.3) |  [245, 273, 117, 162]
Table 10: I/O scheduling mechanisms to exploit performance capabilities of
flash storage, and the respective file systems that implement a particular
mechanism.

###  11.1 I/O Operations

Given that particular I/O patterns can have degrading affects on the SSD
performance, such as mixing read and write operations, as they share resources
on the device, including the mapping table and ECC engine, and furthermore
possibly invalidating the cached data in the SSD RAM. Similarly, mixing I/O
operations with different block sizes can result in increased fragmentation
[245]. As the Linux kernel relies on a submission and completion queue for
I/O, user-space frameworks such as SPDK and NVMeDirect provide more
flexibility for user-space file systems to design different queues, depending
on the requirements. URFS [245] utilizes this possibility to create adaptive
queues that can better optimize I/O submissions to the device. Based on the
workload characteristics URFS dynamically creates flexible I/O queues (e.g.,
group by size, read/write operation) to increase SSD performance. Similarly,
Borge et al. [173] show with a case study on HDFS performance with SSD, that
in order to leverage the capabilities of flash SSD, direct I/O, and increased
parallel requests with buffered I/O are needed.

###  11.2 I/O Scheduler

With the possibility for asynchronous I/O to merge and reorder requests, the
Linux kernel implements several schedulers, such as NOOP, deadline, and CFQ
[236, 208, 179, 83]. NOOP being the least intrusive scheduler only merges I/O
requests in its FIFO, but does not reorder them, which is beneficial on
devices such as OCSSD, that require consecutive LBAs. Son et al. [234]
showcase the benefits of merging random write requests, regardless of
contiguity of the LBAs, in order to better enhance performance with fast
storage devices. The deadline scheduler adds to NOOP by utilizing merging and
reordering, however also applies a deadline for each I/O request to ensure
requests are submitted to the device eventually. Two separate queues, one for
read requests and an additional one for write requests are utilized, which are
both ordered by the deadline of the request. Another scheduler variant of
deadline exists, called mq-deadline, which is aimed at multi-queue devices,
such as NVMe SSD. Completely Fair Queuing (CFQ) implements a round-robin based
queue that assigns time slices to each in order to prevent starvation and
provide fairness. While these are the common schedulers in the Linux kernel,
to see details on all schedulers present in the Linux kernel consult [246].
Such scheduling configuration begs the question on which scheduler is best
suited for file systems on flash storage. Several studies into performance of
the schedulers exist [236, 274], showcasing that merging of read I/O requests
in synchronous I/O provides beneficial performance gains, and similarly the
merging of write I/O s in asynchronous I/O shows performance gains.

Qin et al. [209] argue that I/O ordering limits exploiting the parallelism of
flash devices. Especially as the Linux block layer does not guarantee
particular ordering, flags such as Forced Unit Access (FUA), indicating that
I/O completion is signaled upon arrival of data on the storage, and PREFLUSH,
which before completing the request flushes the volatile caches, have to be
set in order to ensure a specific ordering [209]. With file systems, the I/O
of metadata and data has a particular ordering, such that metadata can only
point to data that exists, needing to ensure that data is written prior to
metadata. Removing of I/O ordering allows eliminating this need and better
utilize the flash parallelism. Utilizing the OOB area on flash pages, the file
system developed by Qin et al., called NBFS, maintains versioning in order to
identify out of order updates. Furthermore, updates are done using atomic
writes (discussed in Section 12). The issuing of FUA requests further implies
that its I/O s cannot be merged in the scheduler [209], implying that if a
smaller than flash page size FUA I/O request is issued, it is padded to the
page size, causing WA. NBFS solves this with its atomic writes that imply that
the FUA request does not immediately have to be written to the flash, but
instead wait for all data blocks to arrive, which are then used to fill the
pages, allowing to reduce the WA (solving FIC 3).

###  11.3 I/O Path - User-Space File Systems

A mechanism that is gaining significant attention in the research community is
the utilization of user-space file systems, bypassing the kernel layers and
avoid its associated overheads. These file systems run only in the user-space,
as opposed to commonly used file systems (e.g., F2FS) running in kernel space.
In addition to the benefit of avoiding kernel overheads, user-space file
systems are easier to develop, have increased reliability and security by
avoiding kernel bugs and vulnerabilities, and provide increased portability
[242]. A widely adopted framework for building user-space storage applications
is Filesystem in USErspace (FUSE) [239]. It is implemented over a kernel
module with which it exports a virtual file system from the kernel, where data
and metadata are provided by a user-space process, hence allowing user-space
applications to interact with it. Since FUSE is implemented with a kernel
module, FUSE based file systems suffer significant performance penalties,
requiring more CPU cycles than file systems in kernel space. Particularly
contributing to overheads is the need to copy memory between user-space and
kernel-space, caused by the way FUSE handles I/O requests [248, 249].
Furthermore, FUSE still suffers from context switching [249, 248, 212]
overheads and Inter-Process Communication (IPC) between the FUSE kernel module
and FUSE user-space daemon [280].

A similar framework for building user-space applications with direct storage
access is NVMe Direct [125]. However, it also relies on a kernel driver to
provide enhanced I/O policies. SPDK [271] is another framework for building
user-space storage applications, however it provides the mechanisms to bypass
the kernel and submit I/O directly to the device, by implementing a user-space
driver for the storage device. Such a framework allows building high
performance storage applications in user-space, which eliminate the overheads
coming from the kernel I/O stack.

URFS [245] provides increased concurrency performance by implementing a multi-
process shared cache in memory, in order to avoid the kernel overheads of
copying data as is present in FUSE. It furthermore helps avoid contention on
the storage device. Eliminating of data copy is also addressed in ZUFS (zero-
copy user-mode file system) [78], which is a user-space file system for
persistent memory, which completes I/O requests by requesting exact data
locations instead of copying data into the own address space. A similar user-
space file system that implements a shared cache for process is EvFS [273],
which is SPDK-based. While this file system can also support multiple
readers/writers in the page cache, it only supports these for a single user
process. User-space frameworks often provide capabilities to either expose the
storage device as a block device, which the user-space application then
accesses, or build a custom block device module (e.g., with SPDK, which also
has default driver modules such as NVMe). For NVMe devices that support NVMe
controller memory buffer management, the file system can manage parts of the
device memory. DevFS [117] utilize such an integration to manage the device
memory for file metadata and I/O queues.

Different from prior discussed development frameworks, File System as
Processes (FSP) [162] provides a storage architecture design for user-space
file systems. The emphasis of FSP is to scale with the arrival of faster
storage, and similarly to other user-space frameworks, minimize the software
stack. For this it bases development on running file systems as processes,
providing safer metadata integrity, data sharing coordination, and consistency
control, as the process running the file system is in control of everything,
instead of trusting libraries. Furthermore, FSP relies on IPC for fast
communication, which unlike FUSE has a low overhead since it does not require
context switching. Inter-core message passing comes at a low overhead and
cache-to-cache transfers on multi-core systems can complete in double-digit
cycles [233]. DashFS [162] is built with FSP, providing a safe user-space file
system with isolation of different user processes, and efficient IPC.

###  11.4 Summary.

With the complexity of the storage software stack and the high performance of
flash storage, the storage software stack dominates the I/O latency [21, 22],
requiring careful I/O management to enhance the performance. In addition to
I/O scheduling, allowing to merge consecutive I/O requests and reduce the
overall issued I/O requests, user-space file systems, bypassing the Linux
storage stack, avoid the storage stack layer overheads.

##  12 Failure Consistent Operations

An important aspect of file systems is to ensure that in the case of power
failure or system crashes, the file system state and its data remain in a
consistent state, and can be recovered upon a subsequent mount. While we do
not classify it as a challenge of flash storage, we discuss the methods for
ensuring failure consistent operations for flash. Most commonly used
mechanisms for ensuring this are journaling, CoW, and checkpointing. However,
journaling suffers from having to write data twice, once for the metadata log
and again for the data log, to ensure full consistency [206, 262], also
referred to as the double-write problem [117]. Therefore, file systems
commonly only provide metadata consistency by logging only the metadata.
Furthermore, power failure is a concern with flash storage, as it has
capacitors that can flush parts of the on-device memory buffers, unless more
expensive capacitors are used that can flush the entirety of the memory
buffers. In the case of power failure, partially written data or metadata
updates can result in the file system being in an inconsistent state.

While checkpointing, CoW, and other consistency mechanisms aim to handle these
failures and provide recovery after failure, other methods exist for providing
interfaces that eliminate partial operations. Particularly, the design of
flash storage, such as the available OOB space of pages, provides beneficial
options for such implementations. Table 11 depicts the methods for ensuring
failure consistency with flash storage, and the file systems implementing such
methods.

Mechanism |  File Systems
---|---
Atomic Writes (Section 12.1) |  [209, 34, 127]
Transactions (Section 12.2) |  [187]
Table 11: Failure consistency mechanisms to for flash storage, and the
respective file systems that implement a particular mechanism.

###  12.1 Atomic Writes

A possible method for ensuring that operations are not completed partially is
through atomic writes. This is important to file systems as an update of data
requires its respective metadata to also be updated. Failure of one should
result in the other not being completed. A variety of flash devices support
atomic writes through mechanisms such as in FTL [189] and through user-
programmable SSD [226], however it can also be implemented in the file system
itself. F2FS supports multi-block atomic writing, which allows updating
multiple file system blocks in a single ioctl command [209, 34, 127]. ReconFS
[166] provides multi-page atomicity by using a flag in each page to indicate
if it is valid. This is achieved by writing a 1 in the head of the last flash
page of the metadata updated, and all other pages have a 0 in the head.
Therefore, in the case of power failure, when the file system is
reconstructed, any metadata pages in between two pages with a 1 in the head
(depicting two ending page updates) are valid pages, and in the case when the
log has no page with the flag set to 1, the update failed and all pages after
the last 1 flag are invalid.

Similarly, Qin et al. [209] showcase the utilization of the OOB area on flash
with OCSSD in order to store metadata for ensuring data integrity in the No-
Barrier File System (NBFS), which is extending F2FS. The file system uses Data
Node Chain (DN-Chain) to ensure consistency measurements. DN-Chain is a linked
list of all the blocks in an atomic operation, which are stored through a
pointer in the OOB space, thus representing a linked list of pointers in an
atomic operation. The last block in the DN-Chain points to itself to indicate
the end of the linked list and the atomic operation. Furthermore, each block
contains a checkpoint version, allowing the recovery after a failure to
traverse the DN-Chain and identify if an invalid checkpoint version number is
present, which indicates a failed atomic operation. As the initial writing of
journal or CoW is done in memory and later flushed to the flash storage,
mechanisms such as failure-atomic msync() [202], provide atomicity in such
operations.

###  12.2 Transactions

An additional approach for ensuring consistency is to use transactions,
enforcing an “all-or-nothing“ mechanism that either writes all data or no data
at all if there are any failures during the transaction. Transactional support
can stem from transactional block devices, such as TxFlash (Transactional
Flash) [207] LightTX with embedded transaction support in the flash storage
FTL [164, 165], and similar block device implementations that expose
transaction support [87, 116, 38]. Additions to file systems can similarly
implement transactions for block devices without transaction support. exF2FS
[187] is an extension on F2FS that provides it with support for transactions.
In order to support transactions, exF2FS implements several features. Firstly,
with transactions relying on either all updates being present or no updates at
all, the GC policy is adapted such that the GC module cannot reclaim flash
pages that contain data from a transaction that is in progress. If such a page
is garbage collected without the transaction having finished, it can be
recovered and thus violates the all-or-nothing mechanism.

For this, exF2FS implements shadow garbage collection, which prohibits the GC
module from using pages involved in pending transactions. Secondly, in order
to provide large scale transactions with multiple exF2FS maintains transaction
file groups, which are kernel objects that identify the set of files involved
in a transaction. Lastly, it implements stealing, which allows dirty pages of
pending transactions to be committed to the flash storage, however do not
allow it to be garbage collected until the transaction completed. This
mechanism is referred to as delayed invalidation and relocation record, and
the process of allowing dirty pages to be evicted in uncommited transactions
is referred to as stealing [187].

###  12.3 Flash Failures

Flash failures are another important aspect of file systems on how they manage
and recover from these failures. A study into file system reliability showed
that 16% of injected faults resulted in an unmountable file system, which
furthermore was not fixable by a file system checker [96]. Especially, as the
density of flash is increasing, where more layers of NAND is stacked on top of
each other, resulting in a decrease in the flash reliability [177]. While
flash employs ECC to handle correcting of data, there are errors that are not
fixable such as the uncorrectable bit corruption [17, 10, 18], which can be
caused by flash wear, read disturbance, and other factors [96]. We do not go
into detail of flash induced errors, for a detailed evaluation on flash errors
recovery mechanisms consult [96, 67]. Jaffer et al. [96] provide several
guidelines for file systems to enhance reliability with flash errors,
including adding more sanity checks, especially of metadata, and finding
better tradeoffs between checksums and the checksum granularity, where a large
checksum granularity can result in significant data loss if it has an
unrecoverable invalid checksum, and a small checksum adds overheads on the
needed space and performance. While file system checkers aim to solve a degree
of faults, they are no panacea to fixing corrupted file systems [67] and
require better failure handling in the file system itself.

###  12.4 Summary

The importance of failure consistent operations for storage systems has
resulted mechanisms, such as atomic writes, to utilize the available OOB area
of flash pages for metadata to ensure consistency in the case of failures.
Similarly, in order to avoid flash errors, checksum methods have been
introduced to alleviate errors as a result of flash failures.

##  13 Discussion

With the multitude of methods for dealing with flash integration, there are
several that are of key concern. In particular, GC and mechanisms of dealing
with GC have shown to be applicable, and enhance other flash integration
challenges. However, there is no panacea for solving all flash integration
challenges. Incorporating a particular mechanism causes difficulty of
integration with other flash challenges. Especially, depending on the level of
integration of flash storage, there is limited possibility of integrating
particular mechanisms. Therefore, the closer integration is largely necessary
in order to more optimally integrate flash, however coming with the additional
flash management complexity. Therefore, a tradeoff between the level of
integratin and the required complexity must be made. A higher level of
management allows the application to more optimally be designed for the flash.
This however comes at the expense of increased complexity. Furthermore,
generic file systems working on numerous integration levels, require more
generic interface management, limiting their customizability for different
integrations.

Clear trends in the storage community are becoming apparent, focusing on
eliminating the hiding of flash management idiosyncrasies, and exposing its
characteristics to the host. Therefore, allowing the host to integrate and
optimize the software for its access patterns with increased knowledge of the
underlying storage device characteristics [16, 23, 113, 13, 107, 15]. As
stated in the CompSys Manifesto [92], ”the grand challenge in storage systems
is to combine heterogeneous storage layers, leveraging their programmability
and capabilities to deliver a new class of cost, data, and performance
efficiency for all kinds of applications”. Reducing the semantic gap between
storage hardware and software must be a driving concern in future storage
system design, leveraging the existing hardware capabilities and enhancing
integration for more efficient, effective, sustainable, and reliable storage
systems.

The recent addition of Zoned Namespace (ZNS) SSD [15, 243], standardized in
the NVMe 2.0 specification [258], similarly provides host the control over GC
management on the storage device, and matches the interface to the underlying
flash characteristics. Leveraging such device interfaces allows the file
system development to partially take control of on-device operations. In
addition to eliminating duplicate work of file system and GC on the device,
where the increased coordination provides better performance capabilities, the
higher-level control of the file system allows it to apply its data knowledge,
such as particular grouping based on file characteristics, without a
significant increase in complexity through the zone interface of ZNS SSD. Such
integration presents a well-defined interface aimed at eliminating the
interface mismatch between flash storage and storage software, leaving a
plethora of possibility for storage software to enhance flash integration.
Exposing more storage device control to the host system, particularly in the
configuration of ZNS, allows not only data placement to be better integrated
into storage software, but furthermore allows to fully utilize the parallel
units of the storage device. With ZNS devices, the parallelism unit of the
storage device is clearly defined [8], and can be leveraged by the storage
software.

We imagine interfaces exposing an increasing level of flash hardware
characteristics to the host software, to begin appearing, in order to better
coordinate and integrate the storage. Similarly, we envision future efforts to
aim at further decreasing the semantic gap between storage hardware and
software, and leverage a higher degree of coordination across storage
software/hardware layers. The gain in popularity of user-space based
applications, as we discussed in Section 11.3, presents prominent possibility
for future development and limiting kernel involvement, which has become an
increasing overhead in the software stack. Therefore, we furthermore picture
an increase in user-space applications, and particularly file systems.

##  14 Related Work

With the growing adoption of flash based storage systems [46, 146], there has
been a plethora of proposed systems to optimize for flash characteristics. We
focus on the existing file systems for flash storage, but other aspects such
as key-value stores are another popular use case for flash storage.

Flash Optimized File Systems. Egger [58] provide a survey on the file systems
for flash storage at the time (2010), comparing the file systems in key
features important for flash storage. This includes the feature set of the
file system, time complexity of operations such as mount time, and space
requirements for memory. However, evaluated file systems are not limited to
flash specific file systems. While the survey presents an insightful summary
of flash file systems, it was published in 2010, thus limiting the number of
available file systems significantly. Similarly, Gal and Toledo [66] present a
survey of algorithms and data structures for flash storage, which encompasses
flash mappings and flash-specific file systems.

Jaffer [95] provide a comparison of five file systems for flash storage,
analyzing the feature set of each and discussing limitations. In particular,
the author focuses on the evolution of design trends for flash storage over
the past decades, where the earliest file system included in the comparison
was presented in 1994. The author additionally includes a discussion on file
system optimizations for data management with Streams [113] and OCSSD [205,
16]. While the author presents an insightful analysis into design trends for
flash storage, the literature review is limited to only the five discussed
file systems and does not differentiate in the file system application domain.

Dubeyko [57] presents SSDFS, a file system designed for SSDs. Albeit not being
a literature review of flash file systems, the author presents an extensive
comparison of related work that proposes flash file systems. Including a
discussion on flash-friendly and flash-oriented file systems, and summarizing
the available methods for optimizing flash specific operations and storage
management. While the discussion of flash file systems provides a comparison
of flash file systems, it is similarly not differentiating between application
domain of the file system. Munegowda et al. [183] showcase a study into
several file systems on Windows and Linux for SSD and flash devices.
Furthermore, the authors present a comparison of features for the varying file
systems, including flash support and FTL integration, as well as a high level
performance comparison. However, the study is focused on the main adopted file
systems, lacking the inclusion of less adopted flash file systems.

Ramasamy and Karantharaj [213] survey the challenges of building file systems
for flash storage, including the performance implications, caching techniques,
and implications of the FTL. The authors additionally discuss available
solutions to the presented design challenges for storage systems on flash
memory. Similarly, Di Carlo et al. [51] present a study into the design issues
and challenges of flash memory file systems. The authors analyze the inherent
implications of the flash storage from the type of cell type used and required
wear leveling, error correction, and bad block management. A comparison of
several available flash file systems at the time of publication (2011) is
presented, with focus on the discussed design challenges.

Flash Optimized Applications. Not focusing of file systems for flash storage,
there have been several surveys into flash characteristics. Luo and Carey [5]
present a survey into log-structured merge-tree (LSM-tree) design techniques
for storage systems. With LSM-trees being a widely adopted and popular choice
of database and key-value store design to optimize for flash storage, the
presented survey showcases relevant flash storage optimizations for data
management. Similarly, Doekemeijer and Trivedi [55] present a study into key-
value stores optimized for flash storage, showcasing several techniques that
can likewise be applied to file system design for flash storage.

Flash Translation Layer. Chung et al. [37] provide a survey into the various
FTL algorithms, discussing the design issues of various algorithms. Flash file
system performance will largely depend on the FTL implementation for SSDs,
making optimal FTL design an important aspect of optimizing file system
performance. A similar survey on FTL algorithms is presented by Kwon et al.
[138]. As embedded devices and possible custom integrations require management
of flash at the file system level, the concepts for efficient and performant
FTL algorithms are applicable to file system level management of flash
storage.

##  15 Conclusion

The move from HDD to flash SSD, has been one of the most fundamental shifts in
the storage hierarchy. The increased performance of flash SSD over HDD,
capable of achieving single several GB/s bandwidth with millions of IOPS,
however required adaptations in the software stack, changing the design of
file systems and storage software to integrate with these devices. In this
literature study we evaluate the current state of file systems for flash
storage devices, how these file systems design to align with introduced flash
characteristics, and how the integration of flash storage into file system
design has affected storage stack design. We evaluate the findings of this
literature study to each of the proposed survey research questions (SRQs).

SRQ1: What are the main challenges arising from NAND flash characteristics and
its integration into file system design?
The architecture of flash-based storage introduces six key challenges for file
system and storage software developers to consider during software design and
development. The first key challenge of flash storage is the (1) asymmetric
read and write performance, for which file systems developers commonly resort
to methods and data structures for enhancing write performance. Due to the
architecture of flash storage, the lack of in-place updates introduces
required (2) garbage collection, presenting a significant performance
implication for flash storage. Furthermore, the implications of GC extend to
introducing (3) I/O amplification, which additionally increases the wear of
flash cells, requiring effective (4) wear leveling methods to employed. In
order to leverage the performance capabilities of flash storage, the (5) flash
parallelism must be exploited with particular methods that are capable of
increasing the concurrency on the flash storage. The last key challenge of
flash storage arises from the storage software stack into which the devices
integrate, where the performance of the storage stack becomes the bottleneck.
Therefore, (6) I/O management for flash storage is a vital aspect at limiting
software overheads, and maximizing the utilization of the flash storage.

SRQ2: How has NAND flash storage influenced the design and development of file
system and the storage software stack?
The main challenges of integrating with NAND flash storage resulted in file
system design to utilize specific data structures, algorithms, and mechanisms.
Log-based data structures are widely adopted for flash-based file system, due
to the matching characteristics to the flash storage. In addition to log-based
data structures, file system development has focused on several key methods to
exploit the parallelism capabilities of flash storage, including clustered
allocation, data striping, and increasing the I/O sizes. Similarly, the design
of I/O management has propagated out of the file system design, into the I/O
scheduler architecture, to optimize I/O activity for fast flash-based storage.

SRQ3: How will NAND flash storage and newly introduced NAND flash-based
storage devices and interfaces affect future file system design and
development?
Given the increasing rise in adoption for flash storage, and the introduction
of new flash-based storage devices and interfaces, future implications of
flash storage (RQ3) provide a promising ground of better integrating the flash
storage with software, leveraging the increased performance capabilities
further. Through new interfaces exposing a larger amount of flash
characteristics, the host software gets an increasing level of possibility to
design application specific flash management, integrating the application
design with flash management. Future storage software developments are likely
to continue integrating the closer integration of flash storage into host
storage software design, optimizing the flash utilizing for full leveraging of
flash performance. We envision the semantic gap between storage hardware and
software to slowly decrease over time, allowing to build more performant,
efficient, reliable, and responsible storage systems. Such efforts align with
the grand challenges of future storage [92], particularly with increasing
demand of systems due to the digitalization of the world, and the push towards
a more sustainable future.

## Glossary

## Acronyms

AHCI

    Advanced Host Controller Interface
AMF

    Application Managed Flash
API

    Application Programming Interface
AR

    Address Remapping
ARS

    Adaptive Reserved Space
BIOS

    Basic I/O System
CAFTL

    Content Aware FTL
CAT

    Cost-Age-Time
CFLRU

    Clean First Least Recently Used
CFQ

    Completely Fair Queuing
CMOS

    Complementary Metal-Oxide Semiconductor
CoW

    Copy on Write
CP

    Checkpoint
CPU

    Central Processing Unit
DAC

    Dynamic Data Clustering
DMA

    Direct Memory Access
DN-Chain

    Data Node Chain
DRAM

    Dynamic RAM
ECC

    Error Correction Codes
F2FS

    Flash-Friendly File System
FAB

    Flash Aware Buffer
FaGC

    File-aware Garbage Collection
FIC

    Flash Integration Challenge
FIFO

    First in First out
FPC

    File Access Pattern-Guided Compression
FSP

    File System as Processes
FTL

    Flash Translation Layer
FUA

    Forced Unit Access
FUSE

    Filesystem in USErspace
GC

    Garbage Collection
HDD

    Hard Disk Drive
inode

    index node
I/O

    Input/Output
IOPS

     I/O Operations per Second
IoT

    Internet of Things
IPC

    Inter-Process Communication
L2P

    Logical-to-Physical
LBA

    Logical Block Address
LFS

    Log-Structured File System
LRU

    Least Recently Used
LZ

    Lempel-Ziv
MBF

    Multiple Bloom Filters
MLC

    Multi-Level Cell
mlog

    Minor Log
MRU

    Most Recently Used
NAT

    Node Address Table
NVM

    Non-Volatile Memory
NVMe

    Non-Volatile Memory Express
OCSSD

    Open-Channel SSD
OOB

    Out-Of-Band
OPS

    Over-Provisioning Space
P2L

    Physical-to-Logical
PBA

    Physical Block Address
PBA

    Page Boundary Alignment
PCI

    Peripheral Component Interconnect
PCIe

    Express
PEB

    Physical Erase Block
PID

    Process Identifier
PIO B-Tree

    Parallel I/O B-Tree
PLC

    Penta-Level Cell
QPSC

    Quasi Preemptive Segment Cleaning
RA

    Read Amplification
RAM

    Random Access Memory
RFS

    Refactored File System
RL

    Range Locking
RLE

    Run Length Encoding
RLSQ

    Related Literature Studies Query
RM-IPU

    Remap-Based In-Place-Updates
RPS

    Reader Pass-through Semaphore
RSQ

    Relevant Studies Query
SA

    Space Amplification
SAC

    Suspend Aware Cleaning
SATA

    Serial Advanced Technology Attachment
SCJ

    Segment Cleaning Journal
SCM

    Storage Class Memory
SCSI

    Small Computer System Interface
SDF

    Software-Defined Flash
SIT

    Segment Information Table
SLC

    Single-Level Cell
SLR

    Systematic Literature Review
SMR

    Shingled Magnetic Recording
SPDK

    Storage Performance Development Kit
SRQ

    Survey Research Question
SSA

    Segment Summary Area
SSD

    Solid State Drive
TLB

    Translation Lookaside Buffer
UFT

    Update Frequency Table
V2P

    Virtual-to-Physical
VBA

    Virtual Block Address
VBQueue

    Valid Block Queue
VFIO

    Virtual Function I/O
WA

    Write Amplification
WL

    Wear Leveling
WODS

    Write Optimized Data Structure
WP

    Write Pointer
ZAC

    Zoned Block Device ATA Command Set
ZBC

    Zoned Block Command
ZNS

    Zoned Namespace
ZSLBA

    Zone Start LBA

## References

  * [1] SFS: Random Write Considered Harmful in Solid State Drives.  In 10th USENIX Conference on File and Storage Technologies (FAST 12), San Jose, CA, 2012. USENIX Association.
  * [2] Nitin Agrawal, Vijayan Prabhakaran, Ted Wobber, John D. Davis, Mark Manasse, and Rina Panigrahy.  Design Tradeoffs for SSD Performance.  In USENIX 2008 Annual Technical Conference, ATC’08, page 57–70, USA, 2008. USENIX Association.
  * [3] Miklós Ajtai.  The complexity of the pigeonhole principle.  Combinatorica, 14(4):417–433, 1994.
  * [4] One Aleph.  YAFFS: Yet another Flash file system.  http://www. yaffs. net, 2001.
  * [5] Chen Luo an.  LSM-based Storage Techniques: A Survey.  ArXiv preprint, abs/1812.07527, 2018.
  * [6] Nick Antonopoulos and Lee Gillam.  Cloud computing.  Springer, 2010.
  * [7] Remzi H. Arpaci-Dusseau.  Operating Systems: Three Easy Pieces, volume 42.  2017\.
  * [8] Hanyeoreum Bae, Jiseon Kim, Miryeong Kwon, and Myoungsoo Jung.  What you can’t forget: exploiting parallelism for zoned namespaces.  In Ali Anwar, Dimitris Skourtis, Sudarsun Kannan, and Xiaosong Ma, editors, HotStorage ’22: 14th ACM Workshop on Hot Topics in Storage and File Systems, Virtual Event, June 27 - 28, 2022, pages 79–85. ACM, 2022\.
  * [9] Maria Ijaz Baig, Liyana Shuib, and Elaheh Yadegaridehkordi.  Big data adoption: State of the art and research challenges.  Information Processing & Management, 56(6):102095, 2019.
  * [10] Hanmant P Belgal, Nick Righos, Ivan Kalastirsky, Jeff J Peterson, Robert Shiner, and Neal Mielke.  A new reliability model for post-cycling charge retention of flash memories.  In 2002 IEEE International Reliability Physics Symposium. Proceedings. 40th Annual (Cat. No. 02CH37320), pages 7–20. IEEE, 2002.
  * [11] Michael A Bender, Martin Farach-Colton, William Jannen, Rob Johnson, Bradley C Kuszmaul, Donald E Porter, Jun Yuan, and Yang Zhan.  An introduction to B-trees and write-optimization.  login; magazine, 40(5), 2015.
  * [12] Roberto Bez, Emilio Camerlenghi, Alberto Modelli, and Angelo Visconti.  Introduction to flash memory.  Proceedings of the IEEE, 91(4):489–502, 2003.
  * [13] Janki Bhimani, Jingpei Yang, Zhengyu Yang, Ningfang Mi, NHV Krishna Giri, Rajinikanth Pandurangan, Changho Choi, and Vijay Balakrishnan.  Enhancing ssds with multi-stream: What? why? how?  In 2017 IEEE 36th International Performance Computing and Communications Conference (IPCCC), pages 1–2. IEEE, 2017.
  * [14] Artem B Bityutskiy.  JFFS3 design issues, 2005.
  * [15] Matias Bjørling, Abutalib Aghayev, Hans Holmberg, Aravind Ramesh, Damien Le Moal, Gregory R. Ganger, and George Amvrosiadis.  ZNS: Avoiding the Block Interface Tax for Flash-based SSDs.  In 2021 USENIX Annual Technical Conference (USENIX ATC 21), pages 689–703. USENIX Association, 2021.
  * [16] Matias Bjørling, Javier Gonzalez, and Philippe Bonnet.  LightNVM: The Linux Open-Channel SSD Subsystem.  In 15th USENIX Conference on File and Storage Technologies (FAST 17), pages 359–374, Santa Clara, CA, 2017. USENIX Association.
  * [17] Simona Boboila and Peter Desnoyers.  Write Endurance in Flash Drives: Measurements and Analysis.  In FAST, pages 115–128, 2010.
  * [18] Adam Brand, Ken Wu, Sam Pan, and David Chin.  Novel read disturb failure mechanism induced by FLASH cycling.  In 31st Annual Proceedings Reliability Physics 1993, pages 127–132. IEEE, 1993.
  * [19] Gerth Stølting Brodal and Rolf Fagerberg.  Lower bounds for external memory dictionaries.  In SODA, volume 3, pages 546–554. Citeseer, 2003.
  * [20] Mingming Cao, Suparna Bhattacharya, and Ted Ts’o.  Ext4: The Next Generation of Ext2/3 Filesystem.  In LSF, 2007.
  * [21] Adrian M. Caulfield, Arup De, Joel Coburn, Todor I. Mollow, Rajesh K. Gupta, and Steven Swanson.  Moneta: A High-Performance Storage Array Architecture for Next-Generation, Non-volatile Memories.  In 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture, pages 385–395, 2010.
  * [22] Adrian M. Caulfield, Todor I. Mollov, Louis Alex Eisner, Arup De, Joel Coburn, and Steven Swanson.  Providing safe, user space access to fast, solid state disks.  In Tim Harris and Michael L. Scott, editors, Proceedings of the 17th International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2012, London, UK, March 3-7, 2012, pages 387–400. ACM, 2012.
  * [23] Adrian M. Caulfield, Todor I. Mollov, Louis Alex Eisner, Arup De, Joel Coburn, and Steven Swanson.  Providing Safe, User Space Access to Fast, Solid State Disks.  In Proceedings of the Seventeenth International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS XVII, page 387–400, New York, NY, USA, 2012. Association for Computing Machinery.
  * [24] Chandranil Chakraborttii and Heiner Litz.  Reducing write amplification in flash by death-time prediction of logical block addresses.  In Bruno Wassermann, Michal Malka, Vijay Chidambaram, and Danny Raz, editors, SYSTOR ’21: The 14th ACM International Systems and Storage Conference, Haifa, Israel, June 14-16, 2021, pages 11:1–11:12. ACM, 2021.
  * [25] Fay Chang, Jeffrey Dean, Sanjay Ghemawat, Wilson C Hsieh, Deborah A Wallach, Mike Burrows, Tushar Chandra, Andrew Fikes, and Robert E Gruber.  Bigtable: A distributed storage system for structured data.  ACM Transactions on Computer Systems (TOCS), 26(2):1–26, 2008.
  * [26] Li-Pin Chang.  On efficient wear leveling for large-scale flash-memory storage systems.  In Proceedings of the 2007 ACM symposium on Applied computing, pages 1126–1130, 2007.
  * [27] Li-Pin Chang.  Hybrid solid-state disks: Combining heterogeneous NAND flash in large SSDs.  In 2008 Asia and South Pacific Design Automation Conference, pages 428–433. IEEE, 2008.
  * [28] Li-Pin Chang and Tei-Wei Kuo.  An adaptive striping architecture for flash memory storage systems of embedded systems.  In Proceedings. Eighth IEEE Real-Time and Embedded Technology and Applications Symposium, pages 187–196. IEEE, 2002.
  * [29] Feng Chen, Song Jiang, and Xiaodong Zhang.  Smartsaver: turning flash drive into a disk energy saver for mobile computers.  In Wolfgang Nebel, Mircea R. Stan, Anand Raghunathan, Jörg Henkel, and Diana Marculescu, editors, Proceedings of the 2006 International Symposium on Low Power Electronics and Design, 2006, Tegernsee, Bavaria, Germany, October 4-6, 2006, pages 412–417. ACM, 2006.
  * [30] Feng Chen, David A. Koufaty, and Xiaodong Zhang.  Understanding intrinsic characteristics and system implications of flash memory based solid state drives.  pages 181–192, 2009.
  * [31] Feng Chen, Rubao Lee, and Xiaodong Zhang.  Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing.  In 2011 IEEE 17th International Symposium on High Performance Computer Architecture, pages 266–277. IEEE, 2011.
  * [32] Feng Chen, Tian Luo, and Xiaodong Zhang.  $CAFTL$: A $Content-Aware$ flash translation layer enhancing the lifespan of flash memory based solid state drives.  In 9th USENIX Conference on File and Storage Technologies (FAST 11), 2011.
  * [33] Yixin Chen and Li Tu.  Density-based clustering for real-time stream data.  In Proceedings of the 13th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 133–142, 2007.
  * [34] Seungyong Cheon and Youjip Won.  Exploiting multi-block atomic write in SQLite transaction.  In Proceedings of the International Conference on High Performance Compilation, Computing and Communications, pages 23–27, 2017.
  * [35] M-L Chiang and R-C Chang.  Cleaning policies in mobile computers using flash memory.  Journal of Systems and Software, 48(3):213–231, 1999.
  * [36] Hyun Jin Choi, Seung-Ho Lim, and Kyu Ho Park.  JFTL: A flash translation layer based on a journal remapping for flash memory.  ACM Transactions on Storage (TOS), 4(4):1–22, 2009.
  * [37] Tae-Sun Chung, Dong-Joo Park, Sangwon Park, Dong-Ho Lee, Sang-Won Lee, and Ha-Joo Song.  A survey of flash translation layer.  Journal of Systems Architecture, 55(5-6):332–343, 2009.
  * [38] Joel Coburn, Trevor Bunker, Meir Schwarz, Rajesh Gupta, and Steven Swanson.  From ARIES to MARS: transaction support for next-generation, solid-state drives.  In Michael Kaminsky and Mike Dahlin, editors, ACM SIGOPS 24th Symposium on Operating Systems Principles, SOSP ’13, Farmington, PA, USA, November 3-6, 2013, pages 197–212. ACM, 2013.
  * [39] Douglas Comer.  Ubiquitous B-tree.  ACM Computing Surveys (CSUR), 11(2):121–137, 1979.
  * [40] INCITS T10 Technical Committee.  Information technology - Zoned Block Commands (ZBC).  Standard, American National Standards Institute, 2014.  Available from: https://www.t10.org/.
  * [41] INCITS T13 Technical Committee.  Information technology – Zoned Device ATA Command Set (ZAC).  Standard, American National Standards Institute, 2015.  Available from: https://www.t13.org/.
  * [42] Kernel Development Community.  Cramfs - cram a filesystem onto a small ROM.  https://www.kernel.org/doc/html/latest/filesystems/cramfs.html.  Accessed: 2022-07-10.
  * [43] Christian Monzio Compagnoni, Akira Goda, Alessandro S Spinelli, Peter Feeley, Andrea L Lacaita, and Angelo Visconti.  Reviewing the evolution of the NAND flash technology.  Proceedings of the IEEE, 105(9):1609–1633, 2017.
  * [44] Alex Conway, Eric Knorr, Yizheng Jiao, Michael A. Bender, William Jannen, Rob Johnson, Donald Porter, and Martin Farach-Colton.  Filesystem Aging: It’s more Usage than Fullness.  In 11th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 19), Renton, WA, 2019. USENIX Association.
  * [45] Michael Cornwell.  Anatomy of a solid-state drive.  Commun. ACM, 55(12):59–63, 2012.
  * [46] Tugrul U Daim, Pattravadee Ploykitikoon, Elizabeth Kennedy, and Woraruthai Choothian.  Forecasting the future of data storage: case of hard disk drive and flash memory.  Foresight, 2008.
  * [47] Jeffrey Dean and Luiz André Barroso.  The tail at scale.  Commun. ACM, 56(2):74–80, 2013.
  * [48] Yuhui Deng.  What is the future of disk drives, death or rebirth?  ACM Comput. Surv., 43(3):23:1–23:27, 2011.
  * [49] Peter Desnoyers.  Analytic models of SSD write performance.  ACM Trans. Storage, 10(2):8:1–8:25, 2014.
  * [50] Peter Deutsch.  GZIP file format specification version 4.3.  Technical report, 1996.
  * [51] Stefano Di Carlo, M Cramia, Paolo Prinetto, and Michele Fabiano.  Chapter Design Issues and Challenges of File Systems for Flash Memories.  2011\.
  * [52] Diego Didona, Jonas Pfefferle, Nikolas Ioannou, Bernard Metzler, and Animesh Trivedi.  Understanding modern storage APIs: a systematic study of libaio, SPDK, and io_uring.  In Proceedings of the 15th ACM International Conference on Systems and Storage, pages 120–127, 2022.
  * [53] Xiaoning Ding, Song Jiang, Feng Chen, Kei Davis, and Xiaodong Zhang.  DiskSeen: Exploiting Disk Layout and Access History to Enhance I/O Prefetch.  In USENIX Annual Technical Conference, volume 7, pages 261–274, 2007.
  * [54] Krijn Doekemeijer, Nick Tehrany, Balakrishnan Chandrasekaran, Matias Bjørling, and Animesh Trivedi.  Performance characterization of nvme flash devices with zoned namespaces (zns).  In (to appear) IEEE International Conference on Cluster Computing, CLUSTER 2023, October 31-November 3, 2023, Santa Fe, New Mexico, USA. IEEE, 2023.
  * [55] Krijn Doekemeijer and Animesh Trivedi.  Key-Value Stores on Flash Storage Devices: A Survey.  ArXiv preprint, abs/2205.07975, 2022.
  * [56] Fred Douglis and Arun Iyengar.  Application-specific Delta-encoding via Resemblance Detection.  In USENIX annual technical conference, general track, pages 113–126. San Antonio, TX, USA, 2003.
  * [57] Viacheslav Dubeyko.  SSDFS: Towards LFS Flash-Friendly File System without GC operation.  ArXiv preprint, abs/1907.11825, 2019.
  * [58] Christian Egger.  File systems for flash devices, 2010.
  * [59] Jörn Engel and Robert Mertens.  LogFS-finally a scalable flash file system.  In 12th International Linux System Technology Conference, 2005.
  * [60] K. Eshghi and R. Micheloni.  SSD Architecture and PCI Express Interface, pages 19–45.  Springer Netherlands, Dordrecht, 2013.
  * [61] Timothy R. Feldman and Garth A. Gibson.  Shingled Magnetic Recording: Areal Density Increase Requires New Data Management.  login Usenix Mag., 38, 2013.
  * [62] Werner Fischer and Georg Schönberger.  Linux Storage Stack Diagram.  Online] http://www. thomas-krenn. com/en/wiki/Linux_Storage_Stack_Diagram (License: CC-BY-SA 3.0, modified by Ingu Kang), 2017.
  * [63] Annie P Foong, Bryan Veal, and Frank T Hady.  Towards SSD-Ready Enterprise Platforms.  In ADMS@ VLDB, pages 15–21, 2010.
  * [64] Agostino Forestiero, Clara Pizzuti, and Giandomenico Spezzano.  A single pass algorithm for clustering evolving data streams based on swarm intelligence.  Data Mining and Knowledge Discovery, 26(1):1–26, 2013.
  * [65] Yinjin Fu, Hong Jiang, Nong Xiao, Lei Tian, and Fang Liu.  Aa-dedupe: An application-aware source deduplication approach for cloud backup services in the personal computing environment.  In 2011 IEEE International Conference on Cluster Computing, pages 112–120. IEEE, 2011.
  * [66] Eran Gal and Sivan Toledo.  Algorithms and data structures for flash memories.  ACM Computing Surveys (CSUR), 37(2):138–163, 2005.
  * [67] Om Rameshwar Gatla, Mai Zheng, Muhammad Hameed, Viacheslav Dubeyko, Adam Manzanares, Filip Blagojevic, Cyril Guyot, and Robert Mateescu.  Towards robust file system checkers.  ACM Transactions on Storage (TOS), 14(4):1–25, 2018.
  * [68] Garth Gibson and Greg Ganger.  Principles of Operation for Shingled Disk Devices.  In 3rd Workshop on Hot Topics in Storage and File Systems (HotStorage 11), Portland, OR, 2011. USENIX Association.
  * [69] Emmanuel Goossaert.  Coding for ssds–part 2: Architecture of an ssd and benchmarking, feb 2014\.
  * [70] Nitesh Goyal and Rabi Mahapatra.  Energy characterization of cramfs for embedded systems.  In International Workshop on Software Support for Portable Storage (IWSSPS) held in conjunction with the IEEE Real-Time and Embedded Systems and Applications Symposium (RTAS 2005), 2005.
  * [71] Goetz Graefe et al.  Modern B-tree techniques.  Foundations and Trends® in Databases, 3(4):203–402, 2011.
  * [72] Aayush Gupta, Youngjae Kim, and Bhuvan Urgaonkar.  DFTL: a flash translation layer employing demand-based selective caching of page-level address mappings.  pages 229–240, 2009.
  * [73] Sudhanva Gurumurthi, Anand Sivasubramaniam, Mahmut Kandemir, and Hubertus Franke.  DRPM: dynamic speed control for power management in server class disks.  In 30th Annual International Symposium on Computer Architecture, 2003\. Proceedings., pages 169–179. IEEE, 2003.
  * [74] Hyunho Gwak and Dongkun Shin.  SCJ: Segment Cleaning Journaling for Log-Structured File Systems.  IEEE Access, 9:142437–142448, 2021.
  * [75] Jin-Yong Ha, Young-Sik Lee, and Jin-Soo Kim.  Deduplication with block-level content-aware chunking for solid state drives (SSDs).  In 2013 IEEE 10th International Conference on High Performance Computing and Communications & 2013 IEEE International Conference on Embedded and Ubiquitous Computing, pages 1982–1989. IEEE, 2013.
  * [76] Sangwook Shane Hahn, Sungjin Lee, Cheng Ji, Li-Pin Chang, Inhyuk Yee, Liang Shi, Chun Jason Xue, and Jihong Kim.  Improving file system performance of mobile storage systems using a decoupled defragmenter.  In 2017 USENIX Annual Technical Conference (USENIX ATC 17), pages 759–771, 2017.
  * [77] Kyuhwa Han, Hyunho Gwak, Dongkun Shin, and Jooyoung Hwang.  ZNS+: advanced zoned namespace interface for supporting in-storage zone compaction.  In Angela Demke Brown and Jay R. Lorch, editors, 15th USENIX Symposium on Operating Systems Design and Implementation, OSDI 2021, July 14-16, 2021, pages 147–162. USENIX Association, 2021.
  * [78] Boaz Harrosh.  zuf: ZUFS Zero-copy User-mode FileSystem.  https://lwn.net/Articles/795996/.  Accessed: 2022-07-10.
  * [79] John A Hartigan and Manchek A Wong.  Algorithm AS 136: A k-means clustering algorithm.  Journal of the royal statistical society. series c (applied statistics), 28(1):100–108, 1979.
  * [80] Ibrahim Abaker Targio Hashem, Ibrar Yaqoob, Nor Badrul Anuar, Salimah Mokhtar, Abdullah Gani, and Samee Ullah Khan.  The rise of “big data” on cloud computing: Review and open research issues.  Information Systems, 47:98–115, 2015.
  * [81] Jun He, Sudarsun Kannan, Andrea C. Arpaci-Dusseau, and Remzi H. Arpaci-Dusseau.  The unwritten contract of solid state drives.  In Gustavo Alonso, Ricardo Bianchini, and Marko Vukolic, editors, Proceedings of the Twelfth European Conference on Computer Systems, EuroSys 2017, Belgrade, Serbia, April 23-26, 2017, pages 127–144. ACM, 2017\.
  * [82] Tim Hegeman and Alexandru Iosup.  Survey of Graph Analysis Applications.  ArXiv preprint, abs/1807.00382, 2018.
  * [83] Dominique A Heger and Richard Quinn.  Linux 2.6 IO Performance Analysis, Quantification, and Optimization.  In Int. CMG Conference, 2010.
  * [84] Jen-Wei Hsieh, Li-Pin Chang, and Tei-Wei Kuo.  Efficient on-line identification of hot data for flash-memory management.  In Proceedings of the 2005 ACM symposium on Applied computing, pages 838–842, 2005.
  * [85] Xiao-Yu Hu, Evangelos Eleftheriou, Robert Haas, Ilias Iliadis, and Roman A. Pletka.  Write amplification analysis in flash-based solid state drives.  In Miriam Allalouf, Michael Factor, and Dror G. Feitelson, editors, Proceedings of of SYSTOR 2009: The Israeli Experimental Systems Conference 2009, Haifa, Israel, May 4-6, 2009, ACM International Conference Proceeding Series, page 10. ACM, 2009.
  * [86] Ping Huang, Guangping Wan, Ke Zhou, Miaoqing Huang, Chunhua Li, and Hua Wang.  Improve effective capacity and lifetime of solid state drives.  In 2013 IEEE Eighth International Conference on Networking, Architecture and Storage, pages 50–59. IEEE, 2013.
  * [87] Ping Huang, Ke Zhou, Hua Wang, and Chun Hua Li.  BVSSD: Build built-in versioning flash-based solid state drives.  In Proceedings of the 5th Annual International Systems and Storage Conference, pages 1–12, 2012.
  * [88] David A Huffman.  A method for the construction of minimum-redundancy codes.  Proceedings of the IRE, 40(9):1098–1101, 1952.
  * [89] Adrian Hunter.  A brief introduction to the design of UBIFS, 2008.
  * [90] Seunghwan Hyun, Hyokyung Bahn, and Kern Koh.  LeCramFS: an efficient compressed file system for flash-based portable consumer devices.  IEEE Transactions on Consumer Electronics, 53(2):481–488, 2007\.
  * [91] Intel.  Intel® SSD D7-P5600 Series.  https://ark.intel.com/content/www/us/en/ark/products/202708/intel-ssd-d7p5600-series-6-4tb-2-5in-pcie-4-0-x4-3d3-tlc.html, Accessed: 2022-05-02.
  * [92] Alexandru Iosup, Fernando Kuipers, Ana Lucia Varbanescu, Paola Grosso, Animesh Trivedi, Jan Rellermeyer, Lin Wang, Alexandru Uta, and Francesco Regazzoni.  Future computer systems and networking research in the netherlands: A manifesto, 2022.
  * [93] Charlie Isaksson, Margaret H Dunham, and Michael Hahsler.  SOStream: Self organizing density-based clustering over data stream.  In International Workshop on Machine Learning and Data Mining in Pattern Recognition, pages 264–278. Springer, 2012.
  * [94] Jeremy Iverson, Chandrika Kamath, and George Karypis.  Fast and effective lossy compression algorithms for scientific datasets.  In European Conference on Parallel Processing, pages 843–856. Springer, 2012.
  * [95] Shehbaz Jaffer.  Evolution of File System design for Solid State Drives.
  * [96] Shehbaz Jaffer, Stathis Maneas, Andy A. Hwang, and Bianca Schroeder.  The reliability of modern file systems in the face of SSD errors.  ACM Trans. Storage, 16(1):2:1–2:28, 2020.
  * [97] Ashish Jagmohan, Michele Franceschini, and Luis Lastras.  Write amplification reduction in NAND flash through multi-write coding.  In 2010 IEEE 26th Symposium on Mass Storage Systems and Technologies (MSST), pages 1–6. IEEE, 2010.
  * [98] William Jannen, Jun Yuan, Yang Zhan, Amogh Akshintala, John Esmet, Yizheng Jiao, Ankur Mittal, Prashant Pandey, Phaneendra Reddy, Leif Walsh, et al.  BetrFS: A Right-Optimized Write-Optimized File System.  In 13th USENIX Conference on File and Storage Technologies (FAST 15), pages 301–315, 2015.
  * [99] Cheng Ji, Li-Pin Chang, Riwei Pan, Chao Wu, Congming Gao, Liang Shi, Tei-Wei Kuo, and Chun Jason Xue.  Pattern-Guided File Compression with User-Experience Enhancement for Log-Structured File System on Mobile Devices.  In 19th USENIX Conference on File and Storage Technologies (FAST 21), pages 127–140. USENIX Association, 2021.
  * [100] Cheng Ji, Li-Pin Chang, Liang Shi, Chao Wu, Qiao Li, and Chun Jason Xue.  An Empirical Study of File-System Fragmentation in Mobile Storage Systems.  In 8th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 16), Denver, CO, 2016. USENIX Association.
  * [101] Chen Jia, ChengYu Tan, and Ai Yong.  A grid and density-based clustering algorithm for processing data stream.  In 2008 Second International Conference on Genetic and Evolutionary Computing, pages 517–521. IEEE, 2008.
  * [102] Song Jiang, Xiaoning Ding, Feng Chen, Enhua Tan, and Xiaodong Zhang.  DULO: an effective buffer cache management scheme to exploit both temporal and spatial locality.  In Proceedings of the 4th conference on USENIX Conference on File and Storage Technologies, volume 4, pages 8–8, 2005.
  * [103] Yizheng Jiao, Simon Bertron, Sagar Patel, Luke Zeller, Rory Bennett, Nirjhar Mukherjee, Michael A. Bender, Michael Condict, Alex Conway, Martin Farach-Colton, Xiongzi Ge, William Jannen, Rob Johnson, Donald E. Porter, and Jun Yuan.  Betrfs: a compleat file system for commodity ssds.  In Yérom-David Bromberg, Anne-Marie Kermarrec, and Christos Kozyrakis, editors, EuroSys ’22: Seventeenth European Conference on Computer Systems, Rennes, France, April 5 - 8, 2022, pages 610–627. ACM, 2022\.
  * [104] Yanqin Jin, Hung-Wei Tseng, Yannis Papakonstantinou, and Steven Swanson.  Improving SSD Lifetime with Byte-Addressable Metadata.  In Proceedings of the International Symposium on Memory Systems, MEMSYS ’17, page 374–384, New York, NY, USA, 2017. Association for Computing Machinery.
  * [105] Heeseung Jo, Jeong-Uk Kang, Seon-Yeong Park, Jin-Soo Kim, and Joonwon Lee.  FAB: Flash-aware buffer management policy for portable media players.  IEEE Transactions on Consumer Electronics, 52(2):485–493, 2006\.
  * [106] William K Josephson.  A Direct-Access File System for a New Generation of Flash Memory.  PhD thesis, Princeton University, 2011.
  * [107] William K. Josephson, Lars Ailo Bongo, Kai Li, and David Flynn.  DFS: A file system for virtualized flash storage.  ACM Trans. Storage, 6(3):14:1–14:25, 2010.
  * [108] Dawoon Jung, Jaegeuk Kim, Jinsoo Kim, and Joonwon Lee.  Scaleffs: A scalable log-structured flash file system for mobile multimedia systems.  ACM Trans. Multim. Comput. Commun. Appl., 5(1):9:1–9:18, 2008\.
  * [109] Jaemin Jung, Youjip Won, Eunki Kim, Hyungjong Shin, and Byeonggil Jeon.  FRASH: Exploiting Storage Class Memory in Hybrid File System for Hierarchical Storage.  ACM Trans. Storage, 6(1), 2010.
  * [110] Sanghyuk Jung, Yangsup Lee, and Yong Ho Song.  A process-aware hot/cold identification scheme for flash memory storage systems.  IEEE Transactions on Consumer Electronics, 56(2):339–347, 2010\.
  * [111] Saurabh Kadekodi, Vaishnavh Nagarajan, and Gregory R. Ganger.  Geriatrix: Aging what you see and what you don’t see. A file system aging approach for modern storage systems.  In 2018 USENIX Annual Technical Conference (USENIX ATC 18), pages 691–704, Boston, MA, 2018. USENIX Association.
  * [112] Dong Hyun Kang, Gihwan Oh, Dongki Kim, In Hwan Doh, Changwoo Min, Sang-Won Lee, and Young Ik Eom.  When address remapping techniques meet consistency guarantee mechanisms.  In 10th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 18), 2018.
  * [113] Jeong-Uk Kang, Jeeseok Hyun, Hyunjoo Maeng, and Sangyeun Cho.  The Multi-streamed $Solid-State$ Drive.  In 6th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 14), 2014.
  * [114] Junbin Kang, Benlong Zhang, Tianyu Wo, Weiren Yu, Lian Du, Shuai Ma, and Jinpeng Huai.  SpanFS: A Scalable File System on Fast Storage Devices.  In 2015 USENIX Annual Technical Conference (USENIX ATC 15), pages 249–261, Santa Clara, CA, 2015. USENIX Association.
  * [115] Mincheol Kang, Wonyoung Lee, Jinkwon Kim, and Soontae Kim.  PR-SSD: Maximizing Partial Read Potential By Exploiting Compression and Channel-Level Parallelism.  IEEE Transactions on Computers, 2022.
  * [116] Woon-Hak Kang, Sang-Won Lee, Bongki Moon, Gi-Hwan Oh, and Changwoo Min.  X-FTL: transactional FTL for SQLite databases.  In Kenneth A. Ross, Divesh Srivastava, and Dimitris Papadias, editors, Proceedings of the ACM SIGMOD International Conference on Management of Data, SIGMOD 2013, New York, NY, USA, June 22-27, 2013, pages 97–108. ACM, 2013.
  * [117] Sudarsun Kannan, Andrea C. Arpaci-Dusseau, Remzi H. Arpaci-Dusseau, Yuangang Wang, Jun Xu, and Gopinath Palani.  Designing a True Direct-Access File System with DevFS.  In 16th USENIX Conference on File and Storage Technologies (FAST 18), pages 241–256, Oakland, CA, 2018. USENIX Association.
  * [118] S Kapoor and A Chopra.  A review of Lempel Ziv compression techniques.  IJCST, 4(2), 2013.
  * [119] Vamsee Kasavajhala.  Solid state drive vs. hard disk drive price and performance study.  Proc. Dell Tech. White Paper, pages 8–9, 2011.
  * [120] P Kavitha.  A survey on lossless and lossy data compression methods.  International Journal of Computer Science & Engineering Technology, 7(03):110–114, 2016.
  * [121] Atsuo Kawaguchi, Shingo Nishioka, and Hiroshi Motoda.  A flash-memory based file system.  In USENIX, pages 155–164, 1995.
  * [122] Ram Kesavan, Matthew Curtis-Maury, Vinay Devadas, and Kesari Mishra.  Storage Gardening: Using a Virtualization Layer for Efficient Defragmentation in the WAFL File System.  In 17th USENIX Conference on File and Storage Technologies (FAST 19), pages 65–78, Boston, MA, 2019. USENIX Association.
  * [123] Ram Kesavan, Matthew Curtis-Maury, Vinay Devadas, and Kesari Mishra.  Countering fragmentation in an enterprise storage system.  ACM Trans. Storage, 15(4):25:1–25:35, 2020.
  * [124] Nawsher Khan, Ibrar Yaqoob, Ibrahim Abaker Targio Hashem, Zakira Inayat, Waleed Kamaleldin Mahmoud Ali, Muhammad Alam, Muhammad Shiraz, and Abdullah Bin Gani.  Big Data: Survey, Technologies, Opportunities, and Challenges.  The Scientific World Journal, 2014, 2014.
  * [125] Hyeong-Jun Kim, Young-Sik Lee, and Jin-Soo Kim.  NVMeDirect: A user-space I/O framework for application-specific optimization on NVMe SSDs.  In 8th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 16), Denver, CO, 2016. USENIX Association.
  * [126] Hyojun Kim and Youjip Won.  MNFS: mobile multimedia file system for NAND flash based storage device.  In CCNC 2006. 2006 3rd IEEE Consumer Communications and Networking Conference, 2006., volume 1, pages 208–212. IEEE, 2006.
  * [127] Jaegeuk Kim.  [PATCH 2/4] f2fs: support atomic_write feature for database.  https://lkml.org/lkml/2014/9/26/19, 9 2014.
  * [128] Jaegeuk Kim.  DEFRAG.F2FS.  https://manpages.debian.org/testing/f2fs-tools/defrag.f2fs.8.en.html, 2021\.
  * [129] Jaegeuk Kim, Heeseung Jo, Hyotaek Shim, Jin-Soo Kim, and Seungryoul Maeng.  Efficient Metadata Management for Flash File Systems.  In 2008 11th IEEE International Symposium on Object and Component-Oriented Real-Time Distributed Computing (ISORC), pages 535–540, 2008\.
  * [130] Jaeho Kim, Donghee Lee, and Sam H. Noh.  Towards SLO Complying SSDs Through OPS Isolation.  In 13th USENIX Conference on File and Storage Technologies (FAST 15), pages 183–189, Santa Clara, CA, 2015. USENIX Association.
  * [131] Jaehong Kim, Sangwon Seo, Dawoon Jung, Jin-Soo Kim, and Jaehyuk Huh.  Parameter-aware I/O management for solid state disks (SSDs).  IEEE Transactions on Computers, 61(5):636–649, 2011.
  * [132] Jaehong Kim, Sangwon Seo, Dawoon Jung, Jin-Soo Kim, and Jaehyuk Huh.  Parameter-Aware I/O Management for Solid State Disks (SSDs).  IEEE Transactions on Computers, 61(5):636–649, 2012.
  * [133] Jonghwa Kim, Choonghyun Lee, Sangyup Lee, Ikjoon Son, Jongmoo Choi, Sungroh Yoon, Hu-ung Lee, Sooyong Kang, Youjip Won, and Jaehyuk Cha.  Deduplication in SSDs: Model and quantitative analysis.  In 2012 IEEE 28th Symposium on Mass Storage Systems and Technologies (MSST), pages 1–12. IEEE, 2012.
  * [134] Barbara Ann Kitchenham and Stuart Charters.  Guidelines for performing Systematic Literature Reviews in Software Engineering.  Technical Report EBSE 2007-001, Keele University and Durham University Joint Report, 2007.
  * [135] Ryusuke Konishi, Yoshiji Amagai, Koji Sato, Hisashi Hifumi, Seiji Kihara, and Satoshi Moriai.  The linux implementation of a log-structured file system.  ACM SIGOPS Oper. Syst. Rev., 40(3):102–107, 2006.
  * [136] Kornilios Kourtis, Nikolas Ioannou, and Ioannis Koltsidas.  Reaping the performance of fast NVM storage with uDepot.  In 17th USENIX Conference on File and Storage Technologies (FAST 19), pages 1–15, 2019.
  * [137] Tei-Wei Kuo, Jen-Wei Hsieh, Li-Pin Chang, and Yuan-Hao Chang.  Configurability of performance and overheads in flash management.  In Asia and South Pacific Conference on Design Automation, 2006., pages 8–pp. IEEE, 2006.
  * [138] Se Jin Kwon, Arun Ranjitkar, Young-Bae Ko, and Tae-Sun Chung.  FTL algorithms for NAND-type flash memories.  Design Automation for Embedded Systems, 15(3):191–224, 2011.
  * [139] Stefan K. Lai.  Brief History of ETOX NOR Flash Memory.  Journal of Nanoscience and Nanotechnology, 12(10):7597–7603, 2012\.
  * [140] Butler Lampson.  Principles for computer system design.  In ACM Turing award lectures, page 1992. 1993.
  * [141] Dave Landsman and D Walker.  AHCI and NVMe as interfaces for SATA Express™ Devices, 2013.
  * [142] Chang-Gyu Lee, Hyunki Byun, Sunghyun Noh, Hyeongu Kang, and Youngjae Kim.  Write optimization of log-structured flash file system for parallel I/O on manycore servers.  In Moshik Hershcovitch, Ashvin Goel, and Adam Morrison, editors, Proceedings of the 12th ACM International Conference on Systems and Storage, SYSTOR 2019, Haifa, Israel, June 3-5, 2019, pages 21–32. ACM, 2019\.
  * [143] Changman Lee, Dongho Sim, Jooyoung Hwang, and Sangyeun Cho.  F2FS: A New File System for Flash Storage.  In 13th USENIX Conference on File and Storage Technologies (FAST 15), pages 273–286, Santa Clara, CA, 2015. USENIX Association.
  * [144] Chul Lee, Sung Hoon Baek, and Kyu Ho Park.  A Hybrid Flash File System Based on NOR and NAND Flash Memories for Embedded Devices.  IEEE Transactions on Computers, 57(7):1002–1008, 2008.
  * [145] Jongsung Lee and Jin-Soo Kim.  An Empirical Study of Hot/Cold Data Separation Policies in Solid State Drives (SSDs).  In Proceedings of the 6th International Systems and Storage Conference, SYSTOR ’13, New York, NY, USA, 2013. Association for Computing Machinery.
  * [146] Sang-Won Lee, Bongki Moon, Chanik Park, Jae-Myung Kim, and Sang-Woo Kim.  A case for flash memory ssd in enterprise database applications.  In Jason Tsong-Li Wang, editor, Proceedings of the ACM SIGMOD International Conference on Management of Data, SIGMOD 2008, Vancouver, BC, Canada, June 10-12, 2008, pages 1075–1086. ACM, 2008.
  * [147] Sang-Won Lee, Dong-Joo Park, Tae-Sun Chung, Dong-Ho Lee, Sangwon Park, and Ha-Joo Song.  A log buffer-based flash translation layer using fully-associative sector translation.  ACM Transactions on Embedded Computing Systems (TECS), 6(3):18–es, 2007.
  * [148] Sungjin Lee, Keonsoo Ha, Kangwon Zhang, Jihong Kim, and Junghwan Kim.  FlexFS: A Flexible Flash File System for MLC NAND Flash Memory.  In 2009 USENIX Annual Technical Conference (USENIX ATC 09), San Diego, CA, 2009. USENIX Association.
  * [149] Sungjin Lee, Jihong Kim, and Arvind Mithal.  Refactored design of i/o architecture for flash storage.  IEEE Computer Architecture Letters, 14(1):70–74, 2014.
  * [150] Sungjin Lee, Ming Liu, Sangwoo Jun, Shuotao Xu, Jihong Kim, and Arvind.  Application-Managed flash.  In 14th USENIX Conference on File and Storage Technologies (FAST 16), pages 339–353, Santa Clara, CA, 2016. USENIX Association.
  * [151] Yongmyung Lee, Jong-Hyeok Park, Jonggyu Park, Hyunho Gwak, Dongkun Shin, Young Ik Eom, and Sang-Won Lee.  When F2FS Meets Address Remapping.  In Proceedings of the 14th ACM Workshop on Hot Topics in Storage and File Systems, HotStorage ’22, page 31–36, New York, NY, USA, 2022. Association for Computing Machinery.
  * [152] Hongyan Li.  Flash Saver: Save the Flash-Based Solid State Drives through Deduplication and Delta-encoding.  In 2012 13th International Conference on Parallel and Distributed Computing, Applications and Technologies, pages 436–441. IEEE, 2012\.
  * [153] Jiangpeng Li, Kai Zhao, Xuebin Zhang, Jun Ma, Ming Zhao, and Tong Zhang.  How Much Can Data Compressibility Help to Improve NAND Flash Memory Lifetime?  In 13th USENIX Conference on File and Storage Technologies (FAST 15), pages 227–240, Santa Clara, CA, 2015. USENIX Association.
  * [154] Nanqinqin Li, Mingzhe Hao, Huaicheng Li, Xing Lin, Tim Emami, and Haryadi S. Gunawi.  Fantastic ssd internals and how to learn and use them.  In Proceedings of the 15th ACM International Conference on Systems and Storage, SYSTOR ’22, page 72–84, New York, NY, USA, 2022. Association for Computing Machinery.
  * [155] Shuai Li, Wei Tong, Jingning Liu, Bing Wu, and Yazhi Feng.  Accelerating garbage collection for 3D MLC flash memory with SLC blocks.  In 2019 IEEE/ACM International Conference on Computer-Aided Design (ICCAD), pages 1–8. IEEE, 2019.
  * [156] Zheng Li, Shuangwu Zhang, Jingning Liu, Wei Tong, Yu Hua, Dan Feng, and Chenye Yu.  A software-defined fusion storage system for PCM and NAND flash.  In 2015 IEEE Non-Volatile Memory System and Applications Symposium (NVMSA), pages 1–6, 2015.
  * [157] Xiaojian Liao, Youyou Lu, Erci Xu, and Jiwu Shu.  Max: A Multicore-Accelerated File System for Flash Storage.  In 2021 USENIX Annual Technical Conference (USENIX ATC 21), pages 877–891. USENIX Association, 2021.
  * [158] Seung-Ho Lim.  DeFFS: Duplication-eliminated flash file system.  Computers & Electrical Engineering, 37(6):1122–1136, 2011.
  * [159] Seung-Ho Lim and Kyu-Ho Park.  An efficient NAND flash file system for flash memory storage.  IEEE Transactions on Computers, 55(7):906–912, 2006.
  * [160] Yoohyuk Lim, Jaemin Lee, Cassiano Campes, and Euiseong Seo.  Parity-Stream separation and SLC/MLC convertible programming for life span and performance improvement of SSD RAIDs.  In 9th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 17), Santa Clara, CA, July 2017. USENIX Association.
  * [161] Chun-Yi Liu, Yu-Ming Chang, and Yuan-Hao Chang.  Read leveling for flash storage systems.  In Dalit Naor, Gernot Heiser, and Idit Keidar, editors, Proceedings of the 8th ACM International Systems and Storage Conference, SYSTOR 2015, Haifa, Israel, May 26-28, 2015, pages 5:1–5:10. ACM, 2015.
  * [162] Jing Liu, Andrea C. Arpaci-Dusseau, Remzi H. Arpaci-Dusseau, and Sudarsun Kannan.  File Systems as Processes.  In 11th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 19), Renton, WA, 2019. USENIX Association.
  * [163] Chih-Yuan Lu, Kuang-Yeu Hsieh, and Rich Liu.  Future challenges of flash memory technologies.  Microelectronic engineering, 86(3):283–286, 2009.
  * [164] Youyou Lu, Jiwu Shu, Jia Guo, Shuai Li, and Onur Mutlu.  LightTx: A lightweight transactional design in flash-based SSDs to support flexible transactions.  In 2013 IEEE 31st International Conference on Computer Design (ICCD), pages 115–122, 2013.
  * [165] Youyou Lu, Jiwu Shu, Jia Guo, Shuai Li, and Onur Mutlu.  High-performance and lightweight transaction support in flash-based SSDs.  IEEE Transactions on Computers, 64(10):2819–2832, 2015.
  * [166] Youyou Lu, Jiwu Shu, and Wei Wang.  ReconFS: A Reconstructable File System on Flash Storage.  In 12th USENIX Conference on File and Storage Technologies (FAST 14), pages 75–88, Santa Clara, CA, 2014. USENIX Association.
  * [167] Youyou Lu, Jiwu Shu, and Jiacheng Zhang.  Mitigating Synchronous I/O Overhead in File Systems on Open-Channel SSDs.  ACM Trans. Storage, 15(3), 2019.
  * [168] Youyou Lu, Jiwu Shu, and Weimin Zheng.  Extending the Lifetime of Flash-based Storage through Reducing Write Amplification from File Systems.  In 11th USENIX Conference on File and Storage Technologies (FAST 13), pages 257–270, San Jose, CA, 2013. USENIX Association.
  * [169] Youyou Lu, Jiwu Shu, and Weimin Zheng.  Extending the Lifetime of Flash-based Storage through Reducing Write Amplification from File Systems.  In 11th USENIX Conference on File and Storage Technologies (FAST 13), pages 257–270, San Jose, CA, 2013. USENIX Association.
  * [170] Kainan Ma, Ming Liu, Tao Li, Yibo Yin, and Hongda Chen.  A Low-Cost Improved Method of Raw Bit Error Rate Estimation for NAND Flash Memory of High Storage Density, 2020.
  * [171] Charles Manning.  YAFFS: the NAND-specific flash file system.  Linuxdevices. org, 2002.
  * [172] Charles Manning.  How YAFFS works.  Retrieved April, 6:2011, 2010.
  * [173] Marí.  Understanding and taming SSD read performance variability: HDFS.  ArXiv preprint, abs/1903.09347, 2019.
  * [174] Biswajit Mazumder and Jason O. Hallstrom.  A Fast, Lightweight, and Reliable File System for Wireless Sensor Networks.  In Proceedings of the 13th International Conference on Embedded Software, EMSOFT ’16, New York, NY, USA, 2016. Association for Computing Machinery.
  * [175] Dirk Meister, Jurgen Kaiser, Andre Brinkmann, Toni Cortes, Michael Kuhn, and Julian Kunkel.  A study on data deduplication in HPC storage systems.  In SC’12: Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis, pages 1–11. IEEE, 2012\.
  * [176] Ralph C Merkle.  One way hash functions and DES.  In Conference on the Theory and Application of Cryptology, pages 428–446. Springer, 1989.
  * [177] Justin Meza, Qiang Wu, Sanjev Kumar, and Onur Mutlu.  A large-scale study of flash memory failures in the field.  ACM SIGMETRICS Performance Evaluation Review, 43(1):177–190, 2015\.
  * [178] Pratik Mishra and Arun Somani.  Host managed contention avoidance storage solutions for Big Data.  Journal of Big Data, 4:18, 2017.
  * [179] Mahsa Moallem.  A study on the performance evaluation of Linux I/O schedulers.  2008\.
  * [180] Vidyabhushan Mohan, Sriram Sankar, Sudhanva Gurumurthi, and W Redmond.  reFresh SSDs: Enabling high endurance, low cost flash in datacenters.  Univ. of Virginia, Tech. Rep. CS-2012-05, 2012.
  * [181] Vidyabhushan Mohan, Taniya Siddiqua, Sudhanva Gurumurthi, and Mircea R Stan.  How I learned to stop worrying and love flash endurance.  In 2nd Workshop on Hot Topics in Storage and File Systems (HotStorage 10), 2010.
  * [182] Steve Morgan.  The 2020 Data Attack Surface Report.  https://1c7fab3im83f5gqiow2qqs2k-wpengine.netdna-ssl.com/wp-content/uploads/2020/12/ArcserveDataReport2020.pdf, 2020\.  Accessed: 2022-04-28.
  * [183] Keshava Munegowda, GT Raju, and Veera Manikandan Raju.  Evaluation of file systems for solid state drives.  In Proceedings of the Second International Conference on Emerging Research in Computing, Information, Communication and Applications, pages 342–348, 2014.
  * [184] Benjamin Nahill and Zeljko Zilic.  FLogFS: A lightweight flash log file system.  In 2015 IEEE 12th International Conference on Wearable and Implantable Body Sensor Networks (BSN), pages 1–6. IEEE, 2015.
  * [185] FEI Ning, Yi Zhuang, Chun-Ling Chen, and YANG Liang.  Design, implementation and evaluation of write-enabled CramFS.  The Journal of China Universities of Posts and Telecommunications, 18(3):124–128, 2011.
  * [186] MFXJ Oberhumer.  LZO-a real-time data compression library.  http://www.oberhumer.com/opensource/lzo/, 2008.
  * [187] Joontaek Oh, Sion Ji, Yongjin Kim, and Youjip Won.  exF2FS: Transaction Support in Log-Structured Filesystem.  In 20th USENIX Conference on File and Storage Technologies (FAST 22), pages 345–362, Santa Clara, CA, 2022. USENIX Association.
  * [188] Jian Ouyang, Shiding Lin, Jiang Song, Zhenyu Hou, Yong Wang, and Yuanzheng Wang.  SDF: software-defined flash for web-scale internet storage systems.  In Rajeev Balasubramonian, Al Davis, and Sarita V. Adve, editors, Architectural Support for Programming Languages and Operating Systems, ASPLOS 2014, Salt Lake City, UT, USA, March 1-5, 2014, pages 471–484. ACM, 2014.
  * [189] Xiangyong Ouyang, David Nellans, Robert Wipfel, David Flynn, and Dhabaleswar K Panda.  Beyond block I/O: Rethinking traditional storage primitives.  In 2011 IEEE 17th International Symposium on High Performance Computer Architecture, pages 301–311. IEEE, 2011.
  * [190] Patrick O’Neil, Edward Cheng, Dieter Gawlick, and Elizabeth O’Neil.  The log-structured merge-tree (LSM-tree).  Acta Informatica, 33(4):351–385, 1996.
  * [191] Krishna Parat and Chuck Dennison.  A floating gate based 3D NAND technology with CMOS under array.  In 2015 IEEE International Electron Devices Meeting (IEDM), pages 3–3. IEEE, 2015.
  * [192] Dongchul Park and David HC Du.  Hot data identification for flash-based storage systems using multiple bloom filters.  In 2011 IEEE 27th Symposium on Mass Storage Systems and Technologies (MSST), pages 1–11. IEEE, 2011.
  * [193] Dongil Park, Seungyong Cheon, and Youjip Won.  Suspend-aware Segment Cleaning in Log-structured File System.  In 7th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 15), Santa Clara, CA, 2015. USENIX Association.
  * [194] Hyunchan Park, Sam H. Noh, and Chuck Yoo.  O1FS: Flash file system with O(1) crash recovery time.  Journal of Systems and Software, 97:86–96, 2014.
  * [195] Jonggyu Park and Young Ik Eom.  Fragpicker: A new defragmentation tool for modern storage devices.  In Proceedings of the ACM SIGOPS 28th Symposium on Operating Systems Principles, pages 280–294, 2021.
  * [196] Jonggyu Park, Dong Hyun Kang, and Young Ik Eom.  File Defragmentation Scheme for a Log-Structured File System.  In Proceedings of the 7th ACM SIGOPS Asia-Pacific Workshop on Systems, APSys ’16, New York, NY, USA, 2016. Association for Computing Machinery.
  * [197] Sang Oh Park and Sung Jo Kim.  An efficient multimedia file system for NAND flash memory storage.  IEEE Transactions on Consumer Electronics, 55(1):139–145, 2009\.
  * [198] Sang Oh Park and Sung Jo Kim.  An Efficient Array File System for Multiple Small-Capacity NAND Flash Memories.  In 2011 14th International Conference on Network-Based Information Systems, pages 569–572, 2011.
  * [199] Sang Oh Park and Sung Jo Kim.  ENFFiS: an enhanced NAND flash memory file system for mobile embedded multimedia system.  ACM Transactions on Embedded Computing Systems (TECS), 12(2):1–13, 2013.
  * [200] Seon-yeong Park, Dawoon Jung, Jeong-uk Kang, Jin-soo Kim, and Joonwon Lee.  CFLRU: a replacement algorithm for flash memory.  In Proceedings of the 2006 international conference on Compilers, architecture and synthesis for embedded systems, pages 234–241, 2006\.
  * [201] Song-Hwa Park, Tae-Hoon Lee, and Ki-Dong Chung.  A Flash file system to support fast mounting for NAND Flash memory based embedded systems.  In International Workshop on Embedded Computer Systems, pages 415–424. Springer, 2006.
  * [202] Stan Park, Terence Kelly, and Kai Shen.  Failure-atomic msync() a simple and efficient mechanism for preserving the integrity of durable data.  In Proceedings of the 8th ACM European Conference on Computer Systems, pages 225–238, 2013.
  * [203] Youngwoo Park, Seung-Ho Lim, Chul Lee, and Kyu Ho Park.  PFFS: a scalable flash memory file system for the hybrid architecture of phase-change RAM and NAND flash.  In Roger L. Wainwright and Hisham Haddad, editors, Proceedings of the 2008 ACM Symposium on Applied Computing (SAC), Fortaleza, Ceara, Brazil, March 16-20, 2008, pages 1498–1503. ACM, 2008.
  * [204] percona.  Tokudb.  https://github.com/percona/tokudb-engine.  Accessed: 2022-07-10.
  * [205] Ivan Luiz Picoli, Niclas Hedam, Philippe Bonnet, and Pinar Tözün.  Open-Channel SSD (What is it Good For).  In CIDR 2020, 10th Conference on Innovative Data Systems Research, Amsterdam, The Netherlands, January 12-15, 2020, Online Proceedings. www.cidrdb.org, 2020.
  * [206] Thanumalayan Sankaranarayana Pillai, Ramnatthan Alagappan, Lanyue Lu, Vijay Chidambaram, Andrea C Arpaci-Dusseau, and Remzi H Arpaci-Dusseau.  Application crash consistency and performance with CCFS.  ACM Transactions on Storage (TOS), 13(3):1–29, 2017.
  * [207] Vijayan Prabhakaran, Thomas L Rodeheffer, and Lidong Zhou.  Transactional Flash.  In OSDI, volume 8, 2008.
  * [208] Stephen Pratt and Dominique A Heger.  Workload dependent performance evaluation of the linux 2.6 i/o schedulers.  In Proceedings of the Linux symposium, volume 2, pages 425–448, 2004.
  * [209] Hongwei Qin, Dan Feng, Wei Tong, Yutong Zhao, Sheng Qiu, Fei Liu, and Shu Li.  Better Atomic Writes by Exposing the Flash Out-of-Band Area to File Systems.  In Proceedings of the 22nd ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, and Tools for Embedded Systems, LCTES 2021, page 12–23, New York, NY, USA, 2021. Association for Computing Machinery.
  * [210] Sheng Qiu and A. L. Narasimha Reddy.  NVMFS: A hybrid file system for improving random write in nand-flash SSD.  In 2013 IEEE 29th Symposium on Mass Storage Systems and Technologies (MSST), pages 1–5, 2013.
  * [211] Wenwei Qiu, Xiang Chen, Nong Xiao, Fang Liu, and Zhiguang Chen.  A New Exploration to Build Flash-Based Storage Systems by Co-designing File System and FTL.  In 2013 IEEE 16th International Conference on Computational Science and Engineering, pages 925–932, 2013.
  * [212] Aditya Rajgarhia and Ashish Gehani.  Performance and extension of user space file systems.  In Proceedings of the 2010 ACM Symposium on Applied Computing, pages 206–213, 2010.
  * [213] Arul Selvan Ramasamy and Porkumaran Karantharaj.  File system and storage array design challenges for flash memory.  In 2014 International Conference on Green Computing Communication and Electrical Engineering (ICGCCEE), pages 1–8, 2014.
  * [214] Eunhee Rho, Kanchan Joshi, Seung-Uk Shin, Nitesh Jagadeesh Shetty, Jooyoung Hwang, Sangyeun Cho, Daniel DG Lee, and Jaeheon Jeong.  FStream: Managing Flash Streams in the File System.  In 16th USENIX Conference on File and Storage Technologies (FAST 18), pages 257–264, Oakland, CA, 2018. USENIX Association.
  * [215] Bhaskar Prasad Rimal, Admela Jukan, Dimitrios Katsaros, and Yves Goeleven.  Architectural requirements for cloud computing systems: an enterprise cloud approach.  Journal of Grid Computing, 9(1):3–26, 2011.
  * [216] Ronald Rivest.  The MD5 message-digest algorithm.  Technical report, 1992.
  * [217] Ohad Rodeh, Josef Bacik, and Chris Mason.  BTRFS: The Linux B-tree filesystem.  ACM Transactions on Storage (TOS), 9(3):1–32, 2013.
  * [218] Hongchan Roh, Sanghyun Park, Sungho Kim, Mincheol Shin, and Sang-Won Lee.  B+-Tree Index Optimization by Exploiting Internal Parallelism of Flash-Based Solid State Drives.  Proc. VLDB Endow., 5(4):286–297, 2011.
  * [219] Mendel Rosenblum and John K. Ousterhout.  The Design and Implementation of a Log-Structured File System.  ACM Trans. Comput. Syst., 10(1):26–52, 1992.
  * [220] Samsung.  Ultra-Low Latency with Samsung Z-NAND SSD.  https://semiconductor.samsung.com/resources/brochure/Ultra-Low%20Latency%20with%20Samsung%20Z-NAND%20SSD.pdf, Accessed: 2022-05-02.
  * [221] Takashi Sato.  ext4 online defragmentation.  In Proceedings of the Linux Symposium, pages 179–186, 2007.
  * [222] Sebastian Schildt, Wolf-Bastian Pottner, and Lars Wolf.  Contiki ring file system for real-time applications.  In 2012 IEEE 8th International Conference on Distributed Computing in Sensor Systems, pages 364–371. IEEE, 2012.
  * [223] Bianca Schroeder, Raghav Lagisetty, and Arif Merchant.  Flash Reliability in Production: The Expected and the Unexpected.  In 14th USENIX Conference on File and Storage Technologies (FAST 16), pages 67–80, Santa Clara, CA, 2016. USENIX Association.
  * [224] Margo I Seltzer, Keith Bostic, Marshall K McKusick, Carl Staelin, et al.  An Implementation of a Log-Structured File System for UNIX.  In USENIX Winter, pages 307–326, 1993.
  * [225] Eric Seppanen, Matthew T O’Keefe, and David J Lilja.  High performance solid state storage under linux.  In 2010 IEEE 26th Symposium on Mass Storage Systems and Technologies (MSST), pages 1–12. IEEE, 2010.
  * [226] Sudharsan Seshadri, Mark Gahagan, Sundaram Bhaskaran, Trevor Bunker, Arup De, Yanqin Jin, Yang Liu, and Steven Swanson.  Willow: A User-Programmable SSD.  In 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pages 67–80, Broomfield, CO, 2014. USENIX Association.
  * [227] Mansour Shafaei, Peter Desnoyers, and Jim Fitzpatrick.  Write Amplification Reduction in Flash-Based SSDs Through Extent-Based Temperature Identification.  In 8th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 16), Denver, CO, 2016. USENIX Association.
  * [228] Mamta Sharma et al.  Compression using Huffman coding.  IJCSNS International Journal of Computer Science and Network Security, 10(5):133–141, 2010.
  * [229] Hojin Shin, Myunghoon Oh, Gunhee Choi, and Jongmoo Choi.  Exploring performance characteristics of ZNS ssds: Observation and implication.  In 9th Non-Volatile Memory Systems and Applications Symposium, NVMSA 2020, Seoul, South Korea, August 19-21, 2020, pages 1–5. IEEE, 2020\.
  * [230] Woong Shin, Qichen Chen, Myoungwon Oh, Hyeonsang Eom, and Heon Y. Yeom.  OS I/O Path Optimizations for Flash Solid-state Drives.  In 2014 USENIX Annual Technical Conference (USENIX ATC 14), pages 483–488, Philadelphia, PA, 2014. USENIX Association.
  * [231] YunSeung Shin.  Non-volatile memory technologies for beyond 2010.  In Digest of Technical Papers. 2005 Symposium on VLSI Circuits, 2005., pages 156–159. IEEE, 2005.
  * [232] Keith A Smith and Margo I Seltzer.  File system aging—increasing the relevance of file system benchmarks.  In Proceedings of the 1997 ACM SIGMETRICS international conference on Measurement and modeling of computer systems, pages 203–213, 1997\.
  * [233] Livio Soares and Michael Stumm.  $FlexSC$: Flexible System Call Scheduling with $Exception-Less$ System Calls.  In 9th USENIX Symposium on Operating Systems Design and Implementation (OSDI 10), 2010.
  * [234] Yongseok Son, Hyuck Han, and Heon Young Yeom.  Optimizing file systems for fast storage devices.  In Dalit Naor, Gernot Heiser, and Idit Keidar, editors, Proceedings of the 8th ACM International Systems and Storage Conference, SYSTOR 2015, Haifa, Israel, May 26-28, 2015, pages 8:1–8:6. ACM, 2015.
  * [235] Radu Stoica, Manos Athanassoulis, Ryan Johnson, and Anastasia Ailamaki.  Evaluating and repairing write performance on flash devices.  In Proceedings of the Fifth International Workshop on Data Management on New Hardware, pages 9–14, 2009.
  * [236] Hui Sun, Xiao Qin, and Chang-sheng Xie.  Exploring optimal combination of a file system and an I/O scheduler for underlying solid state disks.  Journal of Zhejiang University Science C, 15(8):607–621, 2014.
  * [237] Anand Suresh, Garth A. Gibson, and Gregory R. Ganger.  Shingled Magnetic Recording for Big Data Applications.  2012\.
  * [238] Adam Sweeney, Doug Doucette, Wei Hu, Curtis Anderson, Mike Nishimoto, and Geoff Peck.  Scalability in the XFS File System.  In USENIX Annual Technical Conference, volume 15, 1996.
  * [239] Miklos Szeredi.  FUSE: Filesystem in userspace.  http://fuse. sourceforge. net, 2010.
  * [240] Andrew S Tanenbaum.  Computer systems organization.  In Structured computer organization, chapter 2.1.5, pages 61–65. Pearson Education India, 2016.
  * [241] Andrew S Tanenbaum.  The microarchitecture level.  In Structured computer organization, chapter 4.5, page 298. Pearson Education India, 2016.
  * [242] Vasily Tarasov, Abhishek Gupta, Kumar Sourav, Sagar Trehan, and Erez Zadok.  Terra Incognita: On the Practicality of User-Space File Systems.  In 7th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 15), Santa Clara, CA, 2015. USENIX Association.
  * [243] Nick Tehrany and Animesh Trivedi.  Understanding NVMe Zoned Namespace (ZNS) Flash SSD Storage Devices.  ArXiv preprint, abs/2206.01547, 2022.
  * [244] Nicolas Tsiftes, Adam Dunkels, Zhitao He, and Thiemo Voigt.  Enabling large-scale storage in sensor networks with the Coffee file system.  In 2009 International Conference on Information Processing in Sensor Networks, pages 349–360, 2009.
  * [245] Yaofeng Tu, Yinjun Han, Zhenghua Chen, Zhengguang Chen, and Bing Chen.  URFS: A User-space Raw File System based on NVMe SSD.  In 2020 IEEE 26th International Conference on Parallel and Distributed Systems (ICPADS), pages 494–501, 2020.
  * [246] ubuntu wiki.  IOSchedulers.  https://wiki.ubuntu.com/Kernel/Reference/IOSchedulers, 2019.  Accessed: 2022-07-10.
  * [247] Benny Van Houdt.  A mean field model for a class of garbage collection algorithms in flash-based solid state drives.  ACM SIGMETRICS Performance Evaluation Review, 41(1):191–202, 2013\.
  * [248] Bharath Kumar Reddy Vangoor, Prafful Agarwal, Manu Mathew, Arun Ramachandran, Swaminathan Sivaraman, Vasily Tarasov, and Erez Zadok.  Performance and Resource Utilization of FUSE User-Space File Systems.  ACM Trans. Storage, 15(2), 2019.
  * [249] Bharath Kumar Reddy Vangoor, Vasily Tarasov, and Erez Zadok.  To $FUSE$ or Not to $FUSE$: Performance of $User-Space$ File Systems.  In 15th USENIX Conference on File and Storage Technologies (FAST 17), pages 59–72, 2017.
  * [250] Vijay Vasudevan, Michael Kaminsky, and David G Andersen.  Using vector interfaces to deliver millions of iops from a networked key-value storage server.  In Proceedings of the Third ACM Symposium on Cloud Computing, pages 1–13, 2012.
  * [251] Peng Wang, Guangyu Sun, Song Jiang, Jian Ouyang, Shiding Lin, Chen Zhang, and Jason Cong.  An efficient design and implementation of lsm-tree based key-value store on open-channel ssd.  In Proceedings of the Ninth European Conference on Computer Systems, pages 1–14, 2014.
  * [252] Xiaoyun Wang, Yiqun Lisa Yin, and Hongbo Yu.  Finding collisions in the full SHA-1.  In Annual international cryptology conference, pages 17–36. Springer, 2005.
  * [253] Jane Webster and Richard Thomas Watson.  Analyzing the Past to Prepare for the Future: Writing a Literature Review.  MIS Q., 26, 2002.
  * [254] Zev Weiss, Sriram Subramanian, Swaminathan Sundararaman, Nisha Talagala, Andrea Arpaci-Dusseau, and Remzi Arpaci-Dusseau.  ANViL: Advanced Virtualization for Modern Non-Volatile Memory Devices.  In 13th USENIX Conference on File and Storage Technologies (FAST 15), pages 111–118, 2015.
  * [255] Terry A. Welch.  A technique for high-performance data compression.  Computer, 17(06):8–19, 1984.
  * [256] Claes Wohlin.  Guidelines for snowballing in systematic literature studies and a replication in software engineering.  In Martin J. Shepperd, Tracy Hall, and Ingunn Myrtveit, editors, 18th International Conference on Evaluation and Assessment in Software Engineering, EASE ’14, London, England, United Kingdom, May 13-14, 2014, pages 38:1–38:10. ACM, 2014.
  * [257] David Woodhouse.  JFFS: The journalling flash file system.  In Ottawa linux symposium, volume 2001, 2001.
  * [258] NVM Express Workgroup.  NVM Express NVM Command Set Specification 2.0.  Standard, January 2022.  Available from: https://nvmexpress.org/specifications.
  * [259] Bing Wu, Mengye Peng, Dan Feng, and Wei Tong.  DualFS: A Coordinative Flash File System with Flash Block Dual-mode Switching.  In 2020 IEEE 38th International Conference on Computer Design (ICCD), pages 65–72, 2020.
  * [260] Kan Wu, Andrea Arpaci-Dusseau, and Remzi Arpaci-Dusseau.  Towards an Unwritten Contract of Intel Optane SSD.  In 11th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 19), Renton, WA, 2019. USENIX Association.
  * [261] Wen Xia, Hong Jiang, Dan Feng, and Lei Tian.  Combining deduplication and delta compression to achieve low-overhead data reduction on backup datasets.  In 2014 Data Compression Conference, pages 203–212. IEEE, 2014\.
  * [262] Jian Xu and Steven Swanson.  $NOVA$: A Log-structured File System for Hybrid $Volatile/Non-volatile$ Main Memories.  In 14th USENIX Conference on File and Storage Technologies (FAST 16), pages 323–338, 2016.
  * [263] Qiumin Xu, Huzefa Siyamwala, Mrinmoy Ghosh, Tameesh Suri, Manu Awasthi, Zvika Guz, Anahita Shayesteh, and Vijay Balakrishnan.  Performance analysis of NVMe SSDs and their implication on real world databases.  In Proceedings of the 8th ACM International Systems and Storage Conference, pages 1–11, 2015.
  * [264] Hua Yan and Qian Yao.  An efficient file-aware garbage collection algorithm for NAND flash-based consumer electronics.  IEEE Transactions on Consumer Electronics, 60(4):623–627, 2014\.
  * [265] Shiqin Yan, Huaicheng Li, Mingzhe Hao, Michael Hao Tong, Swaminathan Sundararaman, Andrew A. Chien, and Haryadi S. Gunawi.  Tiny-Tail Flash: Near-Perfect Elimination of Garbage Collection Tail Latencies in NAND SSDs.  ACM Trans. Storage, 13(3), 2017.
  * [266] Jinfeng Yang, Bingzhe Li, and David J. Lilja.  Exploring performance characteristics of the optane 3d xpoint storage technology.  ACM Trans. Model. Perform. Evaluation Comput. Syst., 5(1):4:1–4:28, 2020.
  * [267] Jingpei Yang, Ned Plasson, Greg Gillis, Nisha Talagala, and Swaminathan Sundararaman.  Don’t Stack Your Log On My Log.  In 2nd Workshop on Interactions of NVM/Flash with Operating Systems and Workloads (INFLOW 14), Broomfield, CO, 2014. USENIX Association.
  * [268] Jisoo Yang, Dave B Minturn, and Frank Hady.  When poll is better than interrupt.  In FAST, volume 12, pages 3–3, 2012.
  * [269] Lihua Yang, Fang Wang, Zhipeng Tan, Dan Feng, Jiaxing Qian, and Shiyun Tu.  ARS: Reducing F2FS Fragmentation for Smartphones using Decision Trees.  In 2020 Design, Automation & Test in Europe Conference & Exhibition (DATE), pages 1061–1066, 2020.
  * [270] Yue Yang and Jianwen Zhu.  Algebraic Modeling of Write Amplification in Hotness-Aware SSD.  In Proceedings of the 8th ACM International Systems and Storage Conference, SYSTOR ’15, New York, NY, USA, 2015. Association for Computing Machinery.
  * [271] Ziye Yang, James R. Harris, Benjamin Walker, Daniel Verkamp, Changpeng Liu, Cunyin Chang, Gang Cao, Jonathan Stern, Vishal Verma, and Luse E. Paul.  SPDK: A Development Kit to Build High Performance Storage Applications.  In 2017 IEEE International Conference on Cloud Computing Technology and Science (CloudCom), pages 154–161, 2017.
  * [272] Jinsoo Yoo, Joontaek Oh, Seongjin Lee, Youjip Won, Jin-Yong Ha, Jongsung Lee, and Junseok Shim.  Orcfs: Orchestrated file system for flash storage.  ACM Trans. Storage, 14(2):17:1–17:26, 2018.
  * [273] Takeshi Yoshimura, Tatsuhiro Chiba, and Hiroshi Horii.  EvFS: User-level, Event-Driven File System for Non-Volatile Memory.  In 11th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 19), Renton, WA, 2019. USENIX Association.
  * [274] Young Jin Yu, Dong In Shin, Woong Shin, Nae Young Song, Jae Woo Choi, Hyeong Seog Kim, Hyeonsang Eom, and Heon Young Yeom.  Optimizing the block I/O subsystem for fast storage devices.  ACM Transactions on Computer Systems (TOCS), 32(2):1–48, 2014.
  * [275] Jiacheng Zhang, Youyou Lu, Jiwu Shu, and Xiongjun Qin.  Flashkv: Accelerating kv performance with open-channel ssds.  ACM Transactions on Embedded Computing Systems (TECS), 16(5s):1–19, 2017.
  * [276] Jiacheng Zhang, Jiwu Shu, and Youyou Lu.  ParaFS: A Log-Structured File System to Exploit the Internal Parallelism of Flash Devices.  In 2016 USENIX Annual Technical Conference (USENIX ATC 16), pages 87–100, Denver, CO, 2016. USENIX Association.
  * [277] Runyu Zhang, Duo Liu, Xianzhang Chen, Xiongxiong She, Chaoshu Yang, Yujuan Tan, Zhaoyan Shen, and Zili Shao.  LOFFS: A Low-Overhead File System for Large Flash Memory on Embedded Devices.  In 2020 57th ACM/IEEE Design Automation Conference (DAC), pages 1–6, 2020.
  * [278] Runyu Zhang, Duo Liu, Xianzhang Chen, Xiongxiong She, Chaoshu Yang, Yujuan Tan, Zhaoyan Shen, Zili Shao, and Lei Qiao.  ELOFS: An Extensible Low-overhead Flash File System for Resource-scarce Embedded Devices.  IEEE Transactions on Computers, pages 1–1, 2022.
  * [279] You Zhou, Qiulin Wu, Fei Wu, Hong Jiang, Jian Zhou, and Changsheng Xie.  Remap-SSD: Safely and Efficiently Exploiting SSD Address Remapping to Eliminate Duplicate Writes.  In 19th USENIX Conference on File and Storage Technologies (FAST 21), pages 187–202. USENIX Association, 2021.
  * [280] Yue Zhu, Teng Wang, Kathryn Mohror, Adam Moody, Kento Sato, Muhib Khan, and Weikuan Yu.  Direct-fuse: Removing the middleman for high-performance fuse file system support.  In Proceedings of the 8th International Workshop on Runtime and Operating Systems for Supercomputers, pages 1–8, 2018.
  * [281] Jacob Ziv and Abraham Lempel.  A universal algorithm for sequential data compression.  IEEE Transactions on information theory, 23(3):337–343, 1977.
  * [282] Jacob Ziv and Abraham Lempel.  Compression of individual sequences via variable-rate coding.  IEEE transactions on Information Theory, 24(5):530–536, 1978.
  * [283] Aviad Zuck, Ohad Barzilay, and Sivan Toledo.  NANDFS: A Flexible Flash File System for RAM-Constrained Systems.  In Proceedings of the Seventh ACM International Conference on Embedded Software, EMSOFT ’09, page 285–294, New York, NY, USA, 2009. Association for Computing Machinery.