<figure><img src="image_1.png" /></figure>

HAL
open science

# A Survey on the Use of AI/ML for Storage System Design and Optimization

Jalil Boukhobza, Suren Byna, Yuan-Hao Chang, Shadi Ibrahim, Safdar Jamil, Youngjae Kim, Chieh-Lin Tsai, Mai Zheng, Amelie Chi Zhou

<figure><img src="image_2.png" /></figure>

## To cite this version:

Jalil Boukhobza, Suren Byna, Yuan-Hao Chang, Shadi Ibrahim, Safdar Jamil, et al.. A Survey on the Use of AI/ML for Storage System Design and Optimization. 2026. hal-05528520

HAL Id: hal-05528520

https://hal.science/hal-05528520v1

Preprint submitted on 26 Feb 2026

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_3.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
# A Survey on the Use of AI/ML for Storage System Design and Optimization

Jalil Boukhobza, Suren Byna, Yuan-Hao Chang, Shadi Ibrahim, Safdar Jamil, Youngjae Kim, Chieh-Lin Tsai, Mai Zheng, and Amelie Chi Zhou

***Abstract***—Storage systems are critical subsystems in modern computing architectures whether they are aimed for high performance computing (HPC) or for distributed cloud computing data centers. Optimizing storage systems has been a decades-old research area to use these systems efficiently as well as to improve the performance of workloads using them. Advances in Artificial Intelligence (AI) and Machine Learning (ML) have sped up the optimizations in various aspects of storage systems. In this study, we investigate numerous efforts on using AI/ML for designing and optimizing storage systems. A comprehensive survey at this scale and completeness isn't previously available. We aim to provide a comprehensive overview of the state of the art in using AI/ML in the design, management, and optimization of storage systems in HPC and cloud systems. We have surveyed ≈200 publications from premier conferences and journals that covered storage systems, operating systems, distributed computing, HPC, and embedded systems. We organize the survey to describe the designs and optimizations at device, HPC and distributed system, and workload levels. We pose four research questions for each of these areas, focusing on AI/ML usage, deployment, generalizability of the AI/ML methods, and data management. We also summarize the open research challenges faced in applying AI/ML in the final question. We strongly believe this comprehensive survey will serve the storage systems community as a guide for designing and optimizing storage systems by distilling influential research efforts during the past decade.

***Index Terms***—keyword1, keyword2, keyword3

## I. INTRODUCTION

Over the past decade, artificial intelligence has shown fantastic progress, driven by advances in deep learning, the introduction of the Transformer architecture, and the development of large-scale language and multimodal foundation models. Deep learning breakthroughs in computer vision and reinforcement learning laid the foundation for modern AI systems [1]. The introduction of the Transformer model [2] revolutionized natural language processing, enabling the creation of powerful language models like BERT [3] and GPT-3 [4],

J. Boukhobza is with Lab-STICC, CNRS UMR 6285, ENSTA, Institut Polytechnique de Paris, Brest, France, and Academia Sinica, Taipei, Taiwan (email: jalil.boukhobza@ensta.fr).

S. Byna is with The Ohio State University, Columbus, USA (email: byna.l@osu.edu).

Y.-H. Chang and C.-L. Tsai are with National Taiwan University, Taipei, Taiwan (emails: johnson@csie.ntu.edu.tw, d09922013@ntu.edu.tw).

Shadi Ibrahim is with Inria, Univ. Rennes, CNRS, IRISA, Rennes, France (email: shadi.ibrahim@inria.fr).

Safdar Jamil and Youngjae Kim are with Sogang University, Seoul, South Korea (emails: safdar@sogang.ac.kr, yuokim@sogang.ac.kr).

Mai Zheng is with Iowa State University, Ames, USA (email: mai@iastate.edu).

Amelie Chi Zhou is with Hong Kong Baptist University, Hong Kong (email: amelieczhou@comp.hkbu.edu.hk).

which have shown remarkable capabilities in understanding and generating human language. More recently, multimodal AI systems capable of interpreting and generating both text and images have emerged, further expanding AI's applications in diverse fields ranging from medicine to autonomous vehicles.

AI is used in different fields of computer systems, ranging from computer architecture [5], system design [6] to network system optimization [7]. It is integrated at different levels of the system stack, from AI application deployment [8] to low-level architectural features [9]. For instance, ML techniques were used as a design methodology for computer architecture/systems for tasks such as branch prediction, memory system design, Network On Chip management, network management, task allocation and scheduling [9]. AI-based solutions were designed as components of global solutions or as full-featured strategies for different purposes. AI models are very diverse (see Section IV) both in their underlying architectures and in the problems they are supposed to address; they can be categorized according to their function (forecasting, classification, clustering, etc), their learning approach (supervised or not), their algorithmic variety and cost, etc. This variety makes it hard to elaborate a strict mapping between AI models and system problems to solve, but still some efforts were made toward that direction [10].

The rapid growth in data generation — fueled by cloud computing, IoT and edge devices, and high-performance computing (HPC) applications — has placed unprecedented pressure on storage systems. Traditional design approaches rely heavily on heuristics and manually-tuned parameters. With the ever-growing complexity and scale of modern workloads, there is a legitimate interest in leveraging artificial intelligence (AI) and machine learning (ML) techniques to automate, optimize, and re-imagine various aspects of storage system design and optimization. These include tasks such as device-level optimization (garbage collection, mapping for SSDs, etc), system-level optimization (cache management, I/O scheduling, anomaly detection, system-driven data placement), and software-level optimization (application-driven data placement, workload modeling and prediction). In addition, the widespread adoption of AI/ML, particularly in fields such as scientific computing, places greater demands on storage systems, which must now handle the intensive training and inference phases of these workloads [11]. Although optimizing storage for AI is beyond the scope of this paper, it is important to recognize that AI/ML applications further increase the complexity and load on storage systems, highlighting the need for new optimization and design approaches.
Despite the emerging body of work in this area, knowledge
remains fragmented across domains and there is a lack of
a cohesive understanding of the challenges, opportunities,
and state-of-the-art solutions. A comprehensive survey is thus
needed to consolidate existing efforts and guide future re-
search.

**This survey aims to provide a comprehensive overview of the state-of-the-art research on the application of AI and ML techniques in the design, management, and optimization of storage systems.** In addition to summarizing key developments, this work is guided by a set of fundamental research questions that shape our analysis: (1) What is the reason behind using AI in storage system design and optimization? (2) How practical and cost-effective are these solutions in real-world deployments? (3) To what extent are AI-driven methods adaptable to diverse workloads and evolving system conditions? (4) How are the training data for these models collected, managed, and maintained? (5) What are the current limitations and open challenges of applying AI in storage contexts? By organizing the survey around these core questions, we aim not only to synthesize existing knowledge, but also to identify research gaps and initiate new directions in the development of efficient and reliable storage systems.

This paper is organized as follows: Section 2 describes the survey methodology. Section 3 highlights the novelty of this survey as compared to state-of-the-art ones. Section 4 gives an overview on the use of AI/ML for storage systems. Section 5 elaborates a taxonomy for storage systems related problems. Sections 6, 7, 8, 9 and 10 survey AI-driven studies for device-level optimization, caching and prefetching, system-level, workload and performance prediction, and anomaly detection, respectively. Section 11 discusses future directions. Sections 2 to 4 are prerequisites to apprehend the survey and understand the methodology and objectives. Section 5 elaborates a taxonomy categorizing the use of AI/ML models across different storage system design and optimization challenges. Sections 6 to 10 give a detailed view on the use of AI for the different storage layers. These sections can be read independently as they target different storage components. The last section discusses some blind spots and perspectives.

## II. SURVEY METHODOLOGY

We mainly focused on two methodologies to conduct this survey: systematic literature review (SLR) [12] and snowballing [13]. The SLR process defines several steps for conducting a survey among which 1) the planning phase, 2) the review conducting phase and 3) the reporting of the review phase. Each phase consists of several steps that focus on avoiding biases and being as exhaustive and accurate as possible in the review process to eventually make it reproducible.

For the paper search procedure, we have established a search strategy to span an as large as possible volume of papers in renowned journals and conferences related to storage systems. The paper search procedure is detailed in the following paragraphs. Additionally, we borrowed ideas from the snowballing process to iterate on a set of papers and use both backward and forward references of a subset of identified seed papers.

Our search procedure consists of three steps:

1) Searching papers in conferences and major databases

2) Identifying major topics

3) Selecting a first set of papers per topic then performing backward/forward snowballing

### A. Searching phase

We chose to operate the searching phase on a 5-6 years time window from 2019 to 2024 <fnref n="1" />. As the storage system topic is orthogonal to different communities, we selected a subset of conferences related to different computer system domains ²³:

* Storage systems

- FAST: USENIX Conference on File and Storage Technologies

- MSST: The International Conference on Massive Storage Systems and Technology

- SYSTOR: The ACM International Systems and Storage Conference

* Operating systems:

- SOSP: Symposium on Operating Systems Principles

- OSDI: USENIX Symposium on Operating Systems Design and Implementation

- USENIX ATC: the USENIX Annual Technical Conference

- ASPLOS: the International Conference on Architectural Support for Programming Languages and Operating Systems.

* Distributed and high performance computing:

- SC: ACM/IEEE Supercomputing Conference

- IPDPS: IEEE International Parallel & Distributed Processing Symposium

- CCGRID: IEEE/ACM International Symposium on Cluster, Cloud and Internet Computing

- Cluster: IEEE International Conference on Cluster Computing

- CLOUD: IEEE International Conference on Cloud Computing

- SOCC: ACM Symposium on Cloud Computing

* Embedded systems and design automation:

- DAC: ACM/IEEE Design Automation Conference

- DATE: IEEE/ACM Design, Automation and Test in Europe Conference

- ICCAD: IEEE/ACM The International Conference on Computer-Aided Design

In addition to the conferences above, we performed a keyword systematic search on ACM DL and IEEE Explore digital libraries with keywords containing: "machine learning", "artificial intelligence", "storage", "NVM", "I/O system". The objectives were to capture the most relevant papers and to consider renowned journals indexed by these digital libraries.

<footnote n="1">¹some conferences did not took place in 2024 by the writing time of the survey (started in mid-2024), 5 editions were considered in that case</footnote>

<footnote n="2">²the actual conference classification based on topics is much more complex and has been over simplified here for search strategy explanation sake only</footnote>

<footnote n="3">³Note that the survey is not exclusively based on those conferences, they only represent the first set of searched venues</footnote>
We scrolled up to 5 pages of results for each search. From the results, we considered only papers related to storage and non-volatile-memory (for instance, papers solely related to volatile memory systems were excluded from the survey).

This paper selection process resulted in capturing around 120 papers (see Table I, first column) related to applying AI and ML to storage system design and optimization.

It is important to note that only papers applying AI and ML for storage optimization were considered. Papers (and there were many of them) optimizing AI and ML processes and applications by acting on storage systems (storage for AI) are out of the scope of this survey.

## B. Identifying major topics

After this first selection of papers, we went through the titles and abstracts of all papers to classify them according to the level at which the AI/ML algorithms have been applied. We classified these studies in 5 categories from the device to the application:

* Device level optimization: this category contains papers mainly related to SSD internal optimization, that is: flash translation layer mapping scheme, garbage collection, wear-leveling, write amplification reduction, I/O throughput enhancement, lifetime extension, etc.

* Cache and prefetching: several related work addressed caching and prefetching issues at different levels of the computer system stack.

* System-level Optimizations: studies applying AI/ML to system-level optimizations on many levels and for different objectives. We found studies acting on I/O scheduling, data deduplication, data placement in hybrid storage systems, and storage tuning.

* Workload and performance prediction: this category mainly contains work on using AI/ML for predicting I/O workloads for a diversity of applications and also for predicting storage system performance for a given set of I/O-bound applications.

* Anomaly detection: this category is not necessarily tied to a single level as anomalies may occur across the storage system stack (e.g., HDD/SSD failures, RAID errors, Cloud storage issues). Given the cross-level nature, we dedicate a category to this class of studies.

Note that the categories above are not completely hermetic. For instance, some studies might target caching for a distributed system (could fall in the caching or system-level category) or deduplication at the device level (could fall in the system or device-level categories). We made sure studies in that case are discussed at least once in what we thought was the most relevant section. Also, some categories are more function-driven (caching and anomaly detection) while the others are level-driven (device, system and application), we opted for this subdivision for two reasons: 1) it makes more sense discussing some optimization according to the levels at which they operate and for others according to the functionality, and 2) we also tried to balance the number of papers per category.

<table><caption>TABLE I
NUMBER OF PAPERS PER CATEGORY AFTER THE FIRST AND SECOND PHASE SEARCH.</caption><thead><tr><th>Category</th><th>Nb of papers - phase 1</th><th>Nb of papers - phase 2</th></tr></thead><tbody><tr><td>Device level</td><td>13</td><td>10</td></tr><tr><td>Anomaly detection</td><td>27</td><td>8</td></tr><tr><td>Cache and prefetching</td><td>24</td><td>20</td></tr><tr><td>Large scale distributed systems</td><td>26</td><td>31</td></tr><tr><td>Workload and performance prediction</td><td>25</td><td>4</td></tr></tbody></table>

## C. Selecting papers per topic and performing backward/forward snowballing

Papers belonging to the same category above were analyzed and compiled. We operated backward and forward snowballing to identify important papers cited by and citing seed papers to complete the bibliography, see the second column Table I.

## III. NOVELTY AND RELATED SURVEYS

This section discusses the main objective and scope of this paper and related surveys.

### A. Scope of this survey

It has been more than a decade since AI entered the storage optimization landscape, with its integration accelerating over the last five years. We think that it is time to take a step back and conduct a survey to identify trends and uncover gaps in the integration of intelligent techniques. A focused survey can provide timely insights into challenges, issues, and future directions for research and development in this critical area.

This exhaustive survey addresses several layers of the storage stack, so we needed to fix, very early in the writing process, a list of RQs to discuss for each topic and that are summarized below.

* **RQ1:** What is the reason behind using AI/ML? This RQ aims to discuss the justification behind using AI, and to what extent are the models suited to the problem addressed.

* **RQ2:** How practical is the use of AI/ML solutions in the different studies and how much does it cost? This RQ discusses about the **deployment, implementation** of AI algorithms, and their respective **cost** (overheads in terms of time, memory, storage, complexity, etc). It focuses on the nature of deployment: centralized/distributed, the use of online or offline learning and the frameworks used.

* **RQ3:** How adaptable is the solution? This RQ discusses how a given solution could be **generalizable** to other similar problems, **scalable** to larger problems, **explainable** and **reproducible**.

* **RQ4:** How were learning data managed? This RQ discussed how learning data were obtained (collection, availability, intrusiveness,...) and how they are managed (privacy and security issues)

* **RQ5:** What is missing in AI for storage? This RQ discusses blind spots and the expected AI techniques for future storage system optimization problems.
## B. Related surveys

Several surveys related to AI/ML or its use in computer systems have already been published.

**AI/ML surveys:** As AI/ML became a necessary tool for different application domains, several surveys were published in these recent years to shed some light on the use of such algorithms, techniques, applications, their suitability for solving certain problems, and limitations. One can cite surveys on deep learning [14], federated learning [15], machine learning into metaheuristics [16]. The question of the deployment of ML was also interestingly raised [8], and some studies explored such a deployment on resource-constrained devices [17].

**AI/ML for computer systems:** More related to our topic, some surveys studied the use of ML for computer system optimizations. Some focused on architecture and systems [9] or Electronic Design Automation [6], [5]. Other surveyed scheduling for the cloud [18], cloud data systems in general [19] or IoT system management [20]. Some broader studies tried to give a macroscopic understanding of ML usage in computer systems and networking [7] or a microscopic analysis of a subset of contributions [21]. All of these studies interestingly highlight different and complementary facets of the same issue. However, no survey focused solely on storage systems.

This work is complementary to previous related surveys by focusing on research that uses AI/ML to solve storage system-related issues and by focusing on a specific set of RQs highlighted above. Storage systems are defined here as all hardware and software components implicated in handling persistent data in a computer system, from small IoT devices and handhelds to massive geo-distributed clouds and high-performance computing systems.

# IV. OVERVIEW TO ML FOR STORAGE SYSTEMS

ML has emerged as a transformative tool for addressing complex challenges in storage systems. This section provides a foundational understanding of classical ML techniques and their relevance to storage optimization, setting the stage for deeper exploration in subsequent sections.

Note that Table VIII in the appendix contains a summary of AI/ML acronyms used in this paper.

## A. Classical Machine Learning Techniques

1) *Supervised Learning:* Supervised learning is a type of machine learning where the model is trained on labeled data. Each training sample is paired with an output label, and the model learns to predict the output from the input data. Key algorithms in this category include Linear Regression (LiR), Decision Trees (DT), and Random Forests (RF). These algorithms are designed to identify patterns in the data and make predictions based on those patterns. When given sufficient labeled data, these algorithms can lead to high accuracy.

Supervised learning has various applications in the field of storage. Especially, supervised learning excels in scenarios where labeled data is available and the goal is prediction. This makes it suitable for tasks like failure prediction (where labeled failure data can be used to train a model) and workload

prediction (where historical data can be used to predict future workloads). Below are a few examples in storage systems.

* **Failure Prediction:** Predicting SSD/HDD failures using the monitored attributes from storage devices (e.g., temperature, error rates). For instance, Zhang et al. [22] employed a multi-task RF to predict SSD failures by analyzing long-term SMART (Self-Monitoring, Analysis, and Reporting Technology) data patterns.

* **Workload Characterization:** Categorizing I/O patterns (random vs. sequential) to optimize caching strategies. For instance, Light Gradient Boosting Machine (Light-GBM) models have been used to classify workloads in cloud storage for efficient resource allocation [23].

* **Workload Prediction:** Wang et al. [24] have adopted classification techniques to predict the load features of new cloud disks, allowing for more effective multi-dimensional resource allocation and improved load balancing in cloud storage systems.

2) *Unsupervised Learning:* Unsupervised learning is a type of machine learning that deals with unlabeled data, thus providing better adaptability compared to supervised learning. Unsupervised learning is valuable when labeled data is scarce or unavailable. Its strength mainly lies in uncovering hidden patterns and structures within data. One of the primary tasks in unsupervised learning is clustering, where the goal is to group similar data points together based on their features. This helps in identifying natural groupings within the data, which can be useful for various analytical purposes. Many clustering algorithms exist, such as K-Means, hierarchical clustering, and Density-Based Spatial Clustering of Applications with Noise (DBSCAN) [25]. Other typical tasks in unsupervised learning include dimensionality reduction, where techniques like Principal Component Analysis (PCA) are used to reduce the number of features while preserving essential information; and anomaly detection methods are employed to identify unusual or rare data points.

Unsupervised learning also has wide applications in the field of storage.

* **Data Grouping:** K-means and DBSCAN cluster workloads by access patterns (e.g., sequential vs. random, read-heavy vs. write-heavy), enabling tiered storage (e.g., placing “hot” data on SSDs and “cold” data on HDDs) [26].

* **Anomaly Detection:** Techniques like Isolation Forest (IF) [27] and Auto-Encoders (AE) identify unusual patterns in storage systems, such as unexpected I/O contention, hardware degradation (e.g., SSD write amplification spikes), or metadata corruption [28].

* **Dimensionality Reduction:** Algorithms such as PCA [29] simplify high-dimensional data (e.g., latency distributions, I/O queue depths) to isolate performance bottlenecks in distributed storage systems.

3) *Semi-Supervised Learning:* Semi-supervised learning combines labeled and unlabeled data to improve learning accuracy, making it particularly valuable in system optimization scenarios where labeled data is scarce but vast amounts of unlabeled data (e.g., logs, traces, or performance metrics) are
readily available. By leveraging both labeled and unlabeled
data, this approach builds more robust models that generalize
better to unseen patterns, which is critical for dynamic systems
with evolving workloads or rare anomalies.

Typical semi-supervised learning algorithms [30] include
self-training and Label Propagation (LP). Self-training first
trains a model on a small labeled dataset, and then iteratively
labels the most confident unlabeled examples and incorporates
them into the training set. LP models datasets as a graph and
spread label information from labeled to unlabeled data points
based on their proximity in the feature space. Both algorithms
have been successfully applied in various system optimization
domains.

4) *Reinforcement Learning*: Reinforcement learning (RL) is a machine learning paradigm where an agent learns to make sequential decisions by interacting with an environment to maximize cumulative rewards. The agent iteratively observes the current state of the environment, selects an action based on its learned policy, and receives a reward (or penalty) reflecting the action's effectiveness. Through trial and error, the agent refines its policy to optimize long-term outcomes. There are several core components in RL algorithms:

* **States:** Representations of the environment (e.g., storage node, load levels, cache hit rates).

* **Actions:** Decisions the agent can take (e.g., migrating data, adjusting cache size).

* **Rewards:** Feedback signals (e.g., reduced latency, balanced workloads).

* **Policy:** The strategy guiding action selection. It represents a mapping from states to actions. Storage systems typically use value-based methods (e.g., Q-learning) and policy gradients (e.g., actor-critic).

RL is a promising approach for storage system optimization
due to its adaptability and ability to model complex system
dynamics. Unlike static algorithms, RL agents continuously
learn and adapt from new data, making them exceptionally
capable of managing the unpredictable nature of storage
environments. This adaptability proves crucial for handling
sudden workload shifts, such as the dynamic I/O patterns seen
in Content Delivery Networks (CDNs) where user demand
fluctuates rapidly (§7.6). The framework's ability to optimize
for long-term cumulative rewards rather than immediate gains
makes it perfect for balancing competing objectives, such as
maximizing performance while minimizing wear in storage
devices (§6.3).

5) *Deep Learning*: Deep Learning (DL) is a subset of machine learning that employs *Artificial Neural Networks* (ANN) with multiple layers (“deep” architectures) to model complex patterns in data. Unlike classical machine learning methods (e.g., supervised learning, unsupervised learning), DL automatically learns hierarchical feature representations from raw data, eliminating the need for manual feature engineering. DL methods have the following key advantages:

* **Scalability:** Excels at processing large-scale, high-dimensional data (e.g., logs, sensor streams, unstructured text).

* **Non-linear Modeling:** Captures intricate relationships in data, such as temporal dependencies in I/O traces or spatial correlations in distributed storage topologies.

* **Adaptability:** Transfer learning allows pre-trained models (e.g., BERT, ResNet) to be fine-tuned for domain-specific tasks with minimal labeled data.

Because of the above advantages, DL methods enable advanced analytics for modern storage infrastructures. Classical DL architectures have been applied to different types of problems. For example, Recurrent Neural Networks (RNNs), such as Long Short-Term Memory (LSTM), process sequential data via feedback loops, thus are ideal for *time-series analysis*. Transformers leverage self-attention mechanisms to model long-range dependencies in unstructured data (e.g., log sequences, metadata). Graph Neural Networks (GNNs) operate on graph-structured data (e.g., storage node topologies, dependency graphs).

## B. Other Relevant AI Techniques

While the above introduced learning approaches form the core of AI techniques for storage optimizations, a few other AI techniques have been used to address specialized challenges in modern storage systems.

a) *Natural Language Processing (NLP)*: NLP enables machines to analyze, interpret, and generate human language. In storage systems, NLP techniques are particularly valuable for parsing unstructured log messages to identify hardware failures [31], supporting automated troubleshooting, or parameter tuning [32] in storage systems.

b) *Expert Systems*: Expert systems are AI programs that mimic the decision-making abilities of a human expert. They use a knowledge base of human expertise and an inference engine to solve specific problems within a domain. In storage systems, expert systems can be applied to assist in the optimal configuration of storage systems [33] or provide diagnostic and remedial actions for system issues based on predefined rules and expert knowledge [34].

c) *Knowledge Graphs*: Knowledge graphs model relationships between entities (e.g., files, users, nodes) to enable semantic reasoning. These approaches excel at capturing complex dependencies in storage systems and can be used to uncover non-obvious insights (e.g., predicting cascading failures from disk-to-node dependencies).

## V. TAXONOMY ON ML FOR STORAGE PROBLEMS

ML has become a cornerstone for addressing diverse challenges in storage systems, from low-level device management to large-scale distributed storage orchestration. This section presents a comprehensive taxonomy that classifies ML techniques based on their core functional objectives: detecting failures (Anomaly Detection), anticipating system states (Forecasting), dynamically tuning resources (Optimizations), and uncovering hidden patterns (Discovery). This structure is deliberately chosen to align with the critical themes of this survey (including Device-Level Optimizations, Cache and Prefetching, System-Level Optimizations, Workload/Performance Prediction, and Anomaly Detection), and to highlight how ML
<figure><img src="image_4.png" /><figcaption>Fig. 1. Classification of Machine Learning Algorithms.</figcaption></figure>

<table><caption>TABLE II
TAXONOMY SUMMARY</caption><thead><tr><th>Category</th><th>Example Tasks</th><th>Storage Level</th><th>Key ML Techniques</th><th>Section</th></tr></thead><tbody><tr><td rowspan="3">Anomaly Detection</td><td>Disk failure prediction (HDD/SSD)</td><td>Device</td><td rowspan="3">Logistic Regression [35], Random Forests [22], PCA [29] and DBSCAN [25], Deep Learning such as GAN [36] and RNN [37]</td><td rowspan="3">§10.1, §10.2, §10.3</td></tr><tr><td>System-level anomalies (RAID/PFS/Cloud-storage)</td><td>System</td></tr><tr><td>Performance anomaly detection (Fail-slow incidents)</td><td>Distributed</td></tr><tr><td rowspan="3">Forecasting</td><td>Lifetime prediction (File/SSD)</td><td>Device</td><td rowspan="3">LightGBM [38], Random Forests [39], LSTMs [40], Transformer [41], [42]</td><td rowspan="3">§6.3, §7.3, §7.4, §7.5, §8.1, §8.4, §8.5, §9.1, §9.2, §9.3, §9.4, §9.6</td></tr><tr><td>I/O workload characterization</td><td>System</td></tr><tr><td>System performance prediction</td><td>Distributed</td></tr><tr><td rowspan="4">Optimization</td><td>Garbage collection scheduling</td><td>Device</td><td rowspan="4">Reinforcement Learning [43] (e.g., Q-learning [44]), Neural Networks [45], Bayesian Optimization [46]</td><td rowspan="4">§6.2, §6.3, §6.4, §6.5, §7.3, §8.1, §8.2, §9.5</td></tr><tr><td>Address translation</td><td>System</td></tr><tr><td>Cache policy tuning</td><td>System</td></tr><tr><td>Data placement in hybrid storage</td><td>Distributed</td></tr><tr><td rowspan="3">Discovery</td><td>Hot and cold data separation</td><td>Device</td><td rowspan="3">Clustering algorithms (e.g., K-means [26], DB-SCAN [47], [48]), Classifiers (e.g., MLP [49]), PCA [29], FP-Growth [50]</td><td rowspan="3">§6.1, §6.3, §7.2, §7.3, §8.3, §9.3</td></tr><tr><td>I/O phase detection</td><td>System</td></tr><tr><td>Bottleneck identification</td><td>Distributed</td></tr></tbody></table>

objectives map to distinct storage challenges. The taxonomy bridges the gap between foundational ML concepts (Section 4) and their practical implementations across storage layers (Sections 6–10). By mapping problems to ML solutions, we highlight recurring patterns, gaps, and opportunities for future work.

## A. Anomaly detection

Anomaly detection aims to identify deviations from normal behaviors, which is critical for ensuring reliability in large-scale storage systems. In this survey, we study system failure and anomaly detection problems from different levels.

**Device level.** At the device level, ML models predict hardware failures (e.g., HDD/SSD failures) using SMART attributes, with classic ML techniques like Logistic Regression (LoR) and RF trained to detect changepoint in the SMART attributes [35]. Deep learning techniques such as Generative Adversarial Networks (GAN) and Graph Neural Networks (GNN) have also been explored to predict disk failures based on states of healthy disks.

**System level.** System-level anomaly detection has seen remarkable advances in log analysis. For example, in RAID systems, spatio-temporal inter-dependent error events have been collected and tensor model was built [51] to predict the complex error pattern. Unsupervised methods like PCA and DBSCAN have been explored to cluster log patterns, while NLP-based models (e.g., BiLSTM in Drill) have been

studied to parse unstructured logs. For example, Drill [31] uses BiLSTM-NLP hybrids to parse unstructured logs, detecting anomalies like metadata corruption in GlusterFS.

**Distributed systems.** In distributed systems, such as the large-scale cloud storage systems, a key challenge is balancing false positives with detection latency, especially for real-time deployment. Existing study [28] combines DBSCAN clustering with polynomial regression to distinguish true fail-slow incidents from normal workload variations, reducing false positives in the anomaly detection.

## B. Forecasting

The objective of forecasting problems is to predict future system states or workload patterns to enable proactive resource management in storage systems.

**Device level.** Device-centric predictions are widely studied, such as SSD write amplification forecasting and flash lifetime prediction [50]. For example, models like Temporal Convolutional Networks (TCN) and LSTMs have been used to forecast SSD write amplification or the NAND flash lifetime. The multi-task learning approach in APTN [52] jointly predicts remaining lifespan and failure mode (e.g., charge leakage vs. wordline failure) by processing both SMART counters and NAND wear characteristics.

**System level.** For I/O pattern forecasting, transformer architectures have surpassed traditional models in handling complex periodic patterns. A spatial-temporal-sequential neural network (STSNN) model was adopted to capture spatial-temporal
correlations in block accesses through 3D attention mech-
anisms, improving accuracy in predicting block popularity.
LSTMs model I/O burstiness in PreMatch [53] to forecast
energy demand, scheduling storage operations during high
renewable availability.

**Distributed systems.** In distributed systems, I/O interfer-
ence is a critical issue which further leads to performance
variation. Performance variability prediction leverages ensem-
ble methods (e.g., RFs) to guide system scaling decisions.
A critical trade-off lies in model complexity versus accuracy,
particularly for online learning scenarios.

C. *Optimizations*

The objective of optimization problems is to dynamically
tune system parameters (e.g., cache policies, I/O schedulers,
data placement strategies) for improved efficiency and perfor-
mance across storage layers.

**Device level.** At the device level, ML techniques optimize core firmware operations. RL methods like Q-learning [43] dynamically manage garbage collection (GC) scheduling by balancing valid page migration against erase operations. RNN models are well-suited for improving GC due to their effective prediction of page access sequences (§6.3). Lightweight neural networks (e.g., LearnedFTL [45]) replace static Flash Translation Layer (FTL) mappings for logical-to-physical address translation, adapting to workload patterns while reducing memory overhead.

**System level.** At the system level, optimization extends to cache management and hybrid storage tiering. RL frameworks automate cache policy selection (§7.3), dynamically adjusting eviction/admission rules based on I/O patterns. Bayesian Optimization tunes hybrid storage configurations (§8.2), migrating data between SSD/HDD tiers by predicting access hotness. Systems like MiniCost [54] leverage RL to optimize cloud storage class assignments (hot/cold tiers) using workload forecasts (§8.1).

**Distributed systems.** Large-scale optimization involves co-
ordinating parameters across nodes and tiers. RL agents (e.g.,
DataBot+ [55]) model storage placement as Markov Decision
Processes (MDP), optimizing data locality to reduce network
latency. Techniques like multi-action Q-learning manage cross-
layer operations (e.g., SLC/QLC flash conversion alongside
GC), balancing performance and endurance. Scalability re-
mains critical, with solutions employing offline training and
online lightweight inference to handle geo-distributed state
spaces.

D. *Discovery*

Discovery focuses on identifying hidden patterns, correla-
tions, or relationships in storage workloads to inform system
design.

**Device level.** At the device level, discovery targets flash ac-
cess patterns and wear characteristics. For example, regarding
access pattern mining, K-means and DBSCAN cluster logical
block addresses by rewrite intervals to group pages with
similar lifespans (§6.1). Systems like WARCIP and HAML-
SSD use adaptive clustering to minimize valid page migration

during garbage collection, reducing write amplification (§6.3).
FP-Growth mines co-accessed data sequences (e.g., Pattern-
based Wear-Leveling), placing correlated writes in low-wear
blocks to extend SSD endurance.

**System level.** System-level discovery uncovers work-
load characteristics for system optimizations. For exam-
ple, workload-aware discovery adopts clustering techniques
such as K-means to separate I/O streams into read/write-
heavy or sequential/random categories (§7.3). CacheSifter uses
lightweight Multi-Layer Perceptron (MLP) classifiers to group
files by reuse profiles (e.g., “burn-after-use”, “long-living”),
directing them to DRAM or flash tiers (§7.2). Sequential
pattern mining (e.g., FP-Growth) identifies correlated accesses
to enable prefetching in caches.

**Distributed systems.** Large-scale discovery addresses per-
formance bottleneck identification in complex distributed stor-
age. PCA and SHapley Additive exPlanations (SHAP) values
decompose latency distributions in RAID systems, isolating
variables like queue depth or network contention (§9.5). Gauge
employs HDBSCAN to trace I/O throughput bottlenecks to
specific hardware misconfigurations (§9.6). Unsupervised K-
means identifies "bursty" access phases in HPC jobs (§8.3),
enabling phase-aware data placement in Lustre file systems.

VI. DEVICE LEVEL OPTIMIZATION

A. Introduction

Modern storage devices incorporate various management
mechanisms to fully exploit the performance of the underlying
hardware. For instance, address translation and data placement
strategies are employed to optimize data access. Additionally,
considering the characteristics of NAND flash memory-based
solid-state drives (SSDs), techniques such as wear leveling
and garbage collection [56], [57] are utilized to enhance
device endurance and maintain data integrity. Central to these
mechanisms is the Flash Translation Layer (FTL), a critical
firmware component within SSDs that abstracts the physical
characteristics of NAND flash and presents a logical block
interface to the host system [56]. The FTL is responsible
for mapping logical block addresses (LBAs) issued by the
host to physical page addresses (PPAs) in the flash memory,
handling out-of-place writes, managing mapping tables, and
coordinating internal operations such as garbage collection
and wear leveling. However, these mechanisms are typically
developed based on human-driven heuristics, relying on prede-
fined metrics for operation. As a result, they often struggle to
adapt to diverse and dynamic I/O and data patterns at runtime,
limiting their effectiveness across different scenarios. This
rigidity in FTL design can lead to suboptimal performance,
inefficient resource usage, and degraded endurance, especially
in modern workloads with increasingly unpredictable access
behaviors.

ML algorithms have emerged as an effective approach
for uncovering hidden patterns in historical data, enabling
more adaptive and automated improvements in device-level
management for modern storage systems. Moreover, with the
rapid advancements in AI, NN-based models have also been
adopted for storage devices, often outperforming traditional
ML-based solutions. Among these AI/ML approaches, RL has gained particular popularity due to its ability to directly learn from real-world data, dynamically adjust model behavior, and effectively manage complex, uncertain, or previously unseen scenarios.

Although ML/AI models often enhance performance, they also introduce significant challenges for storage devices. In most ML/AI models, performance is typically proportional to model complexity, such as the number of parameters, which increases the computational overhead of inference. For device-level management, this overhead is critical and, in some cases, even problematic, as the time available for the model to generate an output is highly constrained. Effectively balancing model complexity and performance is, therefore, a crucial challenge in applying ML/AI to device-level management in storage systems. In this section, we introduce various studies that improve device-level management in storage systems from different perspectives, including address mapping, wear leveling, garbage collection, write amplification reduction, and low-level scheduling.

## B. AI/ML for Address Translation

Logical-to-physical address mapping is a vital function of the FTL to ensure efficient data access [58]. Traditionally, FTL schemes employ static mapping techniques with different granularity, including page-level, block-level, or hybrid methods. Page-level mapping provides high flexibility with significant memory overhead, whereas block-level mapping minimizes memory requirements but often leads to performance degradation and higher write amplification. Hybrid mapping aims to leverage the strengths of both strategies, though it requires intricate management and often struggles under varied workloads. Recent advances integrate AI/ML methods into the address mapping processes, significantly enhancing SSD performance by dynamically adapting mapping decisions based on learned workload characteristics.

Zhou et al. [59] propose CPFTL, a correlation-aware FTL that improves page-level address mapping by leveraging clustering-based correlation mining. Instead of relying on temporal or spatial locality, CPFTL groups frequently co-accessed logical pages using lightweight clustering, allowing correlated mappings to be prefetched together. A Bloom filter-based prediction mechanism enables fast lookup, improving cache hit rates and reducing both translation overhead and garbage collection. By uncovering latent access patterns, CPFTL brings a machine learning-inspired, data-driven approach to enhance FTL efficiency under low-locality workloads.

LeaFTL [60] employs a runtime linear regression model integrated with a mapping table composed of learned accurate and approximate index segments to efficiently compute physical addresses. By dynamically adapting the logical-to-physical mappings, LeaFTL substantially reduces the size of the address mapping table, enhancing caching efficiency within the SSD controller. The linear regression model is designed to be both simple and lightweight, requiring merely a few microseconds to learn each index segment on contemporary SSD controllers. Additionally, this model provides guaranteed error

bounds for its learned predictions, ensuring reliability and high performance. LeaFTL faces three key issues: inaccurate predictions, difficulty aligning logical and physical addresses due to SSD parallelism, and high training overhead during writes. LearnedFTL [45] overcomes these challenges by combining learned indexes with demand-based FTL. It introduces in-place-update linear models with bitmap filters to ensure accurate predictions and reduce unnecessary reads. By using virtual physical page numbers and group-based allocation, it aligns data more effectively and enables low-overhead model training during garbage collection. This design significantly reduces double reads and improves performance, especially for random workloads.

Traditional FTLs employ auxiliary data structures such as AVL trees and hash tables, which are not suitable for SRAM-constrained mobile SSDs. Marcus et al. [61] introduce RQFTL, it overcomes this limitation by a lightweight neural network-based index, to enable fast and compact range matching within a dense array. To support frequent updates efficiently, RQFTL splits the Logical-to-physical cache into a short-term cache for fast insertions and a long-term cache indexed by retrainable models. This design maintains low memory usage and supports adaptive updates without impacting runtime performance.

In summary, ML/AI techniques such as clustering, linear regression and neural networks enhance FTL address mapping by enabling adaptive, workload-aware translation beyond the capabilities of traditional static methods. ML-based FTLs like LeaFTL, LearnedFTL, and RQFTL reduce memory overhead and improve performance by learning access patterns, compressing mappings, and dynamically adapting to workload variations. This approach offers greater scalability and efficiency, especially in memory-constrained environments like mobile SSDs. Despite these promising developments, the use of ML/AI in address translation remains limited. We believe the primary reason lies in the practical challenges of deploying ML/AI-based address translation schemes under strict hardware constraints. SSD controllers operate within tight timing and memory budgets, and if the inference cost of an ML/AI model exceeds the latency reduction or space savings it delivers, the benefits are effectively nullified. Consequently, only very lightweight models, such as linear regression or compact neural networks, are feasible in this context. This trade-off between model expressiveness and execution efficiency explains why only a few ML/AI-augmented address translation schemes have emerged in the state of the art.

## C. AI/ML for Garbage Collection, Wear-Leveling and Write Amplification Reduction

In NAND flash-based SSDs, data cannot be overwritten directly, necessitating out-of-place updates to a free page whenever data modifications occur. Garbage collection function in FTL is responsible for reclaiming invalid pages generated by these out-of-place updates; it identifies blocks containing invalid or outdated data, relocates any remaining valid data to new locations, and then erases the entire block to make it available for future writes.
However, frequent garbage collection incurs overhead due to additional reads, writes, and erase operations, contributing to performance degradation and increased write amplification. Write amplification refers to the ratio between the amount of data physically written to the flash memory and the amount of data originally written by the host. Since valid data must often be copied during garbage collection, and entire blocks must be erased even when only a portion is updated, the total number of physical writes can far exceed the logical writes. This phenomenon accelerates flash wear, reduces endurance, and degrades performance over time, especially in workloads with frequent small or random writes. Also, one major challenge in garbage collection is the long-tail latency in SSDs, where a small fraction of I/O requests suffer from unusually high delays. This is primarily due to the nature of GC, which involves copying valid pages and erasing entire blocks. As NAND flash memory scales up, block sizes increase, making these operations more time-consuming. When GC occurs during periods of high I/O activity, it blocks ongoing read and write operations, leading to sharp spikes in response times.

**Clustering and Classification methods.** HAML-SSD [26] redefines data hotness based on both update frequency and average update time interval, enabling more accurate classification through a K-Means clustering algorithm. Data with similar hotness are grouped into the same blocks, reducing valid page migration during garbage collection and lowering write amplification. Kremer et al.[62] improves garbage collection in SSDs by using a self-adapting, ML-inspired data classification strategy. It tracks access frequency and recency using counters and a fading average, allowing it to separate hot and cold data effectively. This reduces the number of valid pages copied during GC, lowering write amplification and internal I/O overhead. WARCIP [63] improves garbage collection by clustering I/O pages based on their rewrite interval (RWI), which reflects data lifetime. It groups pages with similar RWIs into the same block to minimize the number of valid pages during GC, reducing write amplification. WARCIP employs a self-optimizing, adaptive clustering algorithm with a dynamic split-and-merge mechanism that adjusts to changing I/O patterns. A feedback mechanism reinforces good clustering decisions by rewarding blocks with low valid-page counts during GC and penalizing poor ones, guiding future placement. Hsu et al. [64] reduce write amplification by dynamically clustering data based on update distances. It adjusts the number and boundaries of clusters at runtime and selects appropriate granularity to balance accuracy and overhead. A cluster-based GC policy delays garbage collection to allow more pages to become invalid, reducing valid page migration and improving efficiency.

**Reinforcement Learning** has become a popular approach for GC in SSDs due to its ability to adaptively optimize decisions based on runtime workload characteristics. Kang et al. [43] introduce a Reinforcement Learning-Assisted Garbage Collection (RL-GC) method to reduce long-tail latency. RL-GC frames GC as a reinforcement learning problem. The SSD controller learns optimal actions, such as how many pages to copy or when to issue an erase operation, based on system states like inter-request intervals and previous actions. Using

Q-learning, it continuously adapts its policy to reduce response latency, allowing the system to better utilize idle time and dynamically adjust GC behavior. Building on this, Kang et al. [44] introduce a Q-table cache (QTC) to store frequently accessed state-action pairs and augments it with a lightweight neural network (QP Net) that predicts initial Q-values for unseen states. This hybrid design enables finer-grained adaptation without incurring excessive memory overhead. In contrast, Wei et al. [65] expands the RL paradigm to manage both GC and flash mode conversion in convertible SSDs. It integrates multi-action Q-learning to coordinate data allocation, internal GC, and flash conversion across SLC, MLC, and QLC layers, leveraging system states and workload patterns to maintain balanced performance and endurance.

**Recurrent Neural Network.** Beside RL-based approaches, RNN models are well-suited for improving garbage collection because they effectively capture temporal patterns in page access sequences, enabling more accurate prediction of data lifetime for efficient data separation. In [66] the authors apply an LSTM model to forecast hotness of data based on workload features, then use K-Means clustering to group data with similar predicted temperatures into the same blocks. This reduces valid page migration during garbage collection and lowers write amplification by increasing the chance that hot data becomes invalid together. Sun et al. [67] reduce write amplification by optimizing GC with machine learning. It uses a Gated Recurrent Unit (GRU)-based model to predict whether each page is short- or long-living based on historical access patterns. GRU is a compact RNN that captures temporal patterns efficiently, making it suitable for SSD controllers. Pages with similar lifetimes are grouped into superblocks, increasing the chance of collecting mostly invalid pages during GC and reducing valid page migration.

Wear-leveling is another critical function within FTL aimed at prolonging SSD lifetime. Due to the inherent physical characteristics of NAND flash, each memory block can only sustain a limited number of program/erase (P/E) cycles before becoming unreliable. Without appropriate management, frequent updates to specific blocks could lead to early wear-out, significantly reducing overall SSD endurance. Wear-leveling mitigates this issue by distributing write and erase cycles uniformly across the available flash blocks. It achieves this by periodically migrating static (cold) data to heavily used blocks and hot data to less-used ones, thereby balancing the P/E cycles among blocks and extending the device's usable lifetime.

Li et al. [50] apply FP-Growth to mine frequent write patterns, grouping co-accessed data into the same low-wear blocks to reduce write amplification. In addition, a read balance-oriented wear-leveling method redistributes hot read data across SSD chips to exploit internal parallelism, improving read performance while maintaining uniform wear distribution.

## D. *AI/ML for I/O Throughput Enhancement*

In SSDs, I/O operations involve managing read and write requests between the host and flash memory through the SSD
controller. Unlike traditional hard drives, SSDs support parallel access through multiple channels, dies, and planes, enabling high throughput and low latency. I/O throughput in SSDs is influenced by a variety of factors, including how I/O requests are merged and scheduled, how flash pages are selected during programming, and how internal resources like channels and streams are allocated. Inefficient handling of these aspects can lead to resource contention, long tail latencies, and underutilization of hardware parallelism. These challenges are further exacerbated in high-density, multi-streamed, or multi-tenant SSD environments where workloads are highly dynamic and heterogeneous.

SSDkeeper [68] is a self-adapting channel allocation mechanism designed to improve SSD performance in multi-tenant environments. It uses an ANN model, to dynamically assign flash channels based on real-time workload features such as read/write ratio and I/O intensity. By learning from historical data and predicting optimal channel allocation, SSDkeeper reduces access conflicts and improves I/O throughput while maintaining performance isolation across tenants. Liu et al. [69] builds upon the original SSDkeeper design by incorporating a channel swap-based wear-leveling scheme, which addresses the issue of uneven aging caused by fixed channel allocations. This extension enhances not only performance but also device endurance, making SSDkeeper more suitable for long-term, high-density SSD deployments. Wu et al. [70] uses RL to improve SSD I/O performance by dynamically adjusting I/O merging decisions based on workload patterns. It applies Q-learning to select merge strategies that balance throughput and latency variation, outperforming static threshold methods by adapting to diverse I/O behaviors in real time. Li et al. [71] improves SSD I/O performance by mitigating the impact of read disturb, a reliability issue that causes increased error rates and latency in frequently accessed blocks. It combines a read-disturb-aware write scheduling strategy that places frequently read data in more stable blocks with a RL-based refresh scheduling mechanism. The RL model learns when to trigger partial read refresh operations during idle periods between I/O requests, reducing interference and long-tail latency while maintaining data reliability. In [72], authors improve SSD I/O performance by using deep RL to dynamically allocate flash resources in multi-streamed SSDs. It leverages a deep Q-network to make decisions based on I/O patterns and device status, optimizing both throughput and QoS by reducing I/O conflicts and balancing resource utilization. Li et al. [73] uses RL to improve I/O performance in QLC SSDs by optimizing page placement during full-sequence programming. Full-sequence programming writes data to all four page types (LSB, CLSB, CMSB, MSB) in a fixed order, where slower pages cause higher read latency. The proposed method maps frequently read data to faster pages based on access patterns, reducing read latency and improving responsiveness.

These methods aim to improve throughput and QoS by dynamically adjusting I/O merging strategies, scheduling policies, and resource allocation based on real-time workload characteristics. By moving beyond static heuristics, these approaches enable SSDs to better leverage their internal parallelism and respond more effectively to varying access patterns,

ultimately enhancing overall I/O performance.

## E. AI/ML for Hardware Testing, Hardware Configuration, and Lifetime Enhancement

AI/ML techniques have also been applied to improve the physical reliability, testability, and resource utilization of SSD hardware. GRAFT [74] automates SSD firmware testing by combining GNNs and offline RL. It extracts code structure as graph embeddings and uses a conservative Q-learning agent to generate efficient test cases from pre-collected data. This approach achieves high code coverage with fewer commands, matching or exceeding human-designed tests while reducing manual effort. Pensieve [75] enhances SSD lifetime by reducing program and erase operations through ML-guided data compression. It classifies incoming data using a RF model trained with agglomerative clustering, grouping similar data for shared-dictionary compression. This avoids redundant compression, minimizes write traffic, and indirectly improves garbage collection by reducing write amplification. Li et al. [46] propose AutoBlox, a learning-based framework for automatically configuring software-defined SSDs. It combines supervised and unsupervised learning, using techniques like workload clustering, regression, and Bayesian optimization, to select optimal hardware configurations based on workload features and system constraints. By leveraging ML, AutoBlox reduces manual tuning and enables adaptive, workload-aware SSD optimization.

## F. Discussion

**RQ1: What is the reason behind using ML?** For device-level optimization, accurately modeling the characteristics of real-world workloads is a critical factor that directly influences the effectiveness of the proposed solutions. In the past, many studies have adopted heuristic-based techniques grounded in empirical observations of specific access patterns or workload behaviors. While such heuristics can yield performance gains in targeted scenarios, they often fail to generalize across a broader spectrum of workloads due to their limited capacity to represent complex or dynamic behavior. This limitation has motivated the adoption of machine learning techniques, which are capable of continuously learning from data and adapting to diverse workload. For example, HAML-SSD [26] applies a clustering-based method to classify hot and cold data using both update frequency and inter-update intervals, allowing it to dynamically adapt to shifting workload patterns. Similarly, in [72], authors leverage deep reinforcement learning to manage flash resource allocation across multiple I/O streams, optimizing both throughput and QoS even under diverse workload conditions. With demonstration of these works, we believe that when sufficient data volume and diversity are available, machine learning methods can capture latent access patterns that are otherwise difficult to detect through heuristic observation alone, thus enabling more robust and effective device-level optimizations.

**RQ2: How is it practical and how much does it cost?**
The practicality of applying machine learning at the device level of SSDs depends largely on how effectively the learning
<table><caption>TABLE III SUMMARY OF ML/AI TECHNIQUES APPLIED TO VARIOUS SSD DEVICE-LEVEL OPTIMIZATION OBJECTIVES.</caption><thead><tr><th>Objective</th><th>ML/AI Techniques</th><th>Underlying Hardware</th><th>Workload</th></tr></thead><tbody><tr><td>Logical-to-Physical Address Mapping</td><td>Linear Regression [60], [45], Clustering [59], NN [61]</td><td>Controller [59], [60], [45], [61]</td><td>Real-world I/O trace [59], [61], OLTP-Bench [76], [60], Filebench [77], [60]</td></tr><tr><td>Garbage Collection &amp; Write Amplification Reduction</td><td>RL [43], [65], Q-Learning [44], LSTM [66], GRU [67], Clustering [66], [26], [63], [64], FP-Growth [50], Self-adapting classification [62]</td><td>Controller [43], [44], [65], [66], [67], [50], [62], [63], [64], Host CPU [66], [63], Host GPU [66], Specialized accelerator [26]</td><td>Real-world I/O trace [50], FIU [78], [43], Filebench [43], TraceTracker [79], MSR [80], [65], [26], [63], [64], [50], [65], TPC-C [63], [62], SPC [81], [65], [62], SSD trace [82], [65], FIO [83], [66], RocksDB [84], [66], MySQL [85], [66], VDI [86], [26], Alibaba cloud [87], [67], UMass trace repository [64]</td></tr><tr><td>I/O Throughput Enhancement</td><td>NN [68], [69], RL [70], [71], [72], [73], Clustering [72]</td><td>Controller [68], [69], [71], [72], [73], Host CPU [70], [72]</td><td>Real-world I/O trace [68], Synthesize I/O trace [68], MPST [71], MSR [70], [71], [72], [73], [69], UMass trace repository [71], VDI [71], Alibaba cloud [73]</td></tr><tr><td>Hardware Optimization</td><td>GNN [74], RL [74], Clustering [75], Random Forest [75], Linear Regression [46], Bayesian optimization [46]</td><td>Controller [75], Host CPU [74], [46]</td><td>Real-world I/O trace [46], Filebench [75], RocksDB [46], UMass trace repository [46], MySQL [46], VDI [46]</td></tr></tbody></table>

*Note:* This table is paper-centric; a reference may appear in multiple columns to represent the technique, hardware, and workload reported in a work.

framework is integrated into the resource-constrained environment of embedded storage systems.

**Deployment.** Most ML-based solutions for SSDs adopt a centralized deployment model, where the inference of the model is executed within the SSD controller while these models can be trained in both offline and online ways. For offline models that trained offline [66], [64], [68], typically using historical or synthetic I/O traces. Periodic offline updates can be applied to refresh the model and adapt to long-term workload shifts, thus avoiding the significant computational burden of in-situ training. This deployment strategy simplifies integration and ensures predictable performance but limits adaptability to rapidly changing or previously unseen workloads. In contrast, online learning, mainly with reinforcement learning [43], [44], [65], [70], can enable dynamic adaptation during runtime, but typically requires higher computational power and memory than what is available in most SSD controllers.

**Implementation.** In terms of implementation, most ML-based solutions are executed directly on the embedded controller of the SSD. Lightweight models such as decision trees, logistic regression, and linear regression are well-suited for this environment because they can be efficiently integrated into SSD firmware using simple control logic and minimal memory access, without requiring specialized hardware support. In contrast, more complex approaches, particularly those involving neural networks, demand careful firmware-level optimization to meet timing and resource constraints. For example, RQFTL [61] implements a hybrid address translation mechanism that combines a short-term hash table with a long-term neural index (RQRMI), enabling fast updates while maintaining compact range prediction within a limited SRAM budget. Although hardware acceleration remains uncommon at the device level due to power and cost considerations, some designs, such as HAML-SSD [26], propose hardware-assisted modules like the HAML-unit to offload clustering tasks and reduce runtime software overhead.

**Cost.** The practicality of deploying ML or NN models in SSD firmware hinges on overcoming the constraints imposed

by limited computational resources and stringent timing requirements. These models are typically executed on SSD controllers or embedded processing units that operate under tight power, memory, and computational budgets. For instance, the size of the Q-table in reinforcement learning-based schemes [44], or the cache structures in learned address translation models such as RQFTL[61], must be carefully constrained to fit within the limited SRAM available on SSD controllers. Although SRAM offers superior access performance, both the model size and its associated metadata must be tightly managed. Furthermore, executing ML models on the controller introduces additional computational load, potentially interfering with core SSD tasks. In some cases, integrating a specialized hardware unit [26] to support these models may incur additional area and power overhead, which must be justified by the performance gains. Importantly, these works do not ignore such costs, HAML-SSD[26] explicitly quantifies its hardware ML unit's footprint as only 0.037% of chip area and 0.385% power. RQFTL[61] reports a compact 6KB model to minimize SRAM pressure. Others like [67] and [66] explicitly report runtime and metadata overheads of GRU and LSTM model.

### RQ3: How adaptable is the solution?

**Generalizability.** ML and AI-based approaches are generally acknowledged to provide greater generalizability compared to traditional heuristic methods, which are often designed for fixed assumptions and tend to perform well only under narrow operating conditions. ML and AI-based models, by learning patterns from data, can adapt to a broader range of workload characteristics, provided they are trained on diverse and representative datasets. However, in practice, many ML and AI-based solutions still rely on static offline training and lack mechanisms for runtime adaptation for unseen pattern. To address this, some works adopt online learning or reinforcement learning to enhance adaptability and generalization across workloads [70], [71], [72], [73], [43], [65].

**Scalability.** At the device level, the increasing number of planes, dies, and channels in modern SSDs introduces
substantial complexity in scheduling and data placement, requiring ML models to handle greater internal parallelism and expanded input spaces. Only a minority of works explicitly frame scalability as a core evaluation metric. For example, [60], [45] test their designs under different DRAM sizes, flash configurations, or increasing translation entries, while [88] spans over 60 enterprise SSDs. Nevertheless, in the majority of papers, scalability is implicitly reflected in experimental setups that vary SSD parameters such as the number of planes, dies, channels, cache sizes, or total device capacity [67], [44], [43]. This indicates that while explicit discussions are limited, most methods are at least tested across heterogeneous SSD configurations, offering indirect evidence of their scalability.

**Explainability.** Traditional ML-based solutions generally offer better explainability than neural network-based approaches. Models like decision trees [88], [75] or logistic regression [60], [45] provide clear, interpretable logic, where each decision can be traced step-by-step, aiding in debugging and validation. In contrast, neural networks, despite their predictive power, remain impenetrable due to their complex structure. This lack of transparency makes it difficult to understand or justify specific predictions. Despite its importance, explainability is rarely emphasized in the current body of work. Only a few studies, such as [88], explicitly address interpretability as a design objective

**Reproducibility.** In terms of reproducibility, we discuss it with two aspects from the view of the model, both ML and neural network models can exhibit variations in learned parameters, even when trained on the same dataset, due to stochastic elements like random initialization or regularization techniques aimed at preventing overfitting. However, with careful control of training configurations, such as fixed random seeds, consistent hyperparameters, and standardized preprocessing, a reasonable degree of reproducibility can be achieved. The second part is about the simulation environment. Even though in most of the papers the setup of the environment is explained, works that adopt the open-sourced simulators (OpenSSD [62], [67], MQSim [74], [46], SSDsim [26], [70], [71], [73], [50], [65], [72], [69], [68], FEMU [45], Flashsim [43], [44], WiscSim [61]) or GitHub projects [59], [45], [46] are more convincing according to the reproducibility. Also, some works [60], [46] have passed the artifact review.

**RQ4: How are learning data managed?**

**Data Acquisition.** The training data used in ML-based SSD solutions are typically obtained from synthetic workloads, open datasets, or real-world I/O traces. Publicly available datasets such as the MSR Cambridge [26] or Alibaba Cloud traces [67] are commonly used to train and evaluate models under various access patterns. These traces provide diverse read/write behaviors that are critical for learning workload-dependent policies.

Regarding the process of real-world data acquisition from the firmware, recent literature demonstrates a shift toward hardware-level monitoring and background processing to minimize interference to ensure the correctness of the collected trace. For instance, SSDKeeper [68] implements a "feature collector" directly within the FTL to capture real-time state information, such as read/write intensity and tenant access

characteristics, within fixed time windows. In mobile environments, RQFTL [61] utilizes lightweight programs to record high-fidelity traces from physical devices without invasive kernel modifications, thus maintaining the integrity of the original workload. To mitigate the noise or performance overhead of these processes, researchers employ several optimization strategies. CPFTL [59] reduces the computational burden by performing regional correlation mining as a background task during idle periods, preventing interference with foreground I/O. RQFTL [61] further minimizes noise by offloading neural network inference and retraining to a dedicated embedded core, ensuring that logical-to-physical (L2P) lookup latencies remain unaffected.

**Data Management.** In most offline-trained solutions, raw traces are preprocessed into feature vectors and labels, and then stored externally for model training. These models are periodically updated and re-integrated into the firmware. For online learning or reinforcement learning approaches, learning data are typically managed within the device or simulator environment through buffers or Q-tables [44]. However, since these studies commonly rely on publicly available datasets or traces generated by benchmark programs, issues related to data management, particularly privacy and security, are not discussed or explicitly addressed in the existing literature.

# VII. CACHING AND PREFETCHING

## A. Introduction to storage caching

Caching is a very important paradigm in memory and storage systems optimization. It is based on adding an intermediate memory that presents better performance characteristics than a slower one while being more costly. Its objective is to absorb the highest proportion of I/O requests possible in the cache memory in order to increase the performance (e.g., reduce latency, execution time). Building an efficient cache consists of inserting the smallest cache memory (reducing the cost) for maximum benefit (increasing the performance).

Caching is based on the principle of locality of references, that is the tendency of applications to reference a predictable subset of data within a time window [89], [90], [91]. The caching concept is technology and architecture agnostic. It can be implemented on DRAM, SRAM, flash, or other types of memory technology; it can be placed within a computing node at different levels (or even be a full node on its own) or outside a computing node. For storage systems, as it is discussed in future sections, caches can be hardware caches within specific devices such as SSDs, centralized software caches in servers, or distributed caches in network applications.

The caching component is crucial in a storage system as the gap between memory and storage devices' performance is constantly widening. In effect, the importance of a cache depends on the performance gap between the cache and the slow memory; the higher the gap, the more critical a cache can be for performance. The performance of a cache might also depend on its size. The larger the cache, the more it can capture future references for a given policy. Cache size is generally dimensioned as a fraction of the storage size. The performance of the cache is crucial for the system, and it is
generally measured locally in terms of hit rate; that is, the proportion of data blocks accessed from the cache over all data block references, and globally in terms of the total execution time; that is, highlighting the time reduction related to adding a cache. Some studies [92] evaluated that an additional 1% hit rate may increase the overall performance by 35%, illustrating the criticality of such a component.

As stated earlier, caching is based on the locality of references and on the ability of a strategy to capture workload patterns to predict future needs. Caching consists in betting that the system will need (or not) some data in the near future (the future horizon depends on the size of the cache). A cache is considered to be full in a permanent regime, so adding data to the cache consists in removing (evicting) some other data from the cache. Caching, by nature, introduces unpredictability in response times as it inserts a new level of memory with performance properties that are different from the original one.

A cache should be efficient by absorbing a large proportion of I/Os (increase the hit rate and reduce the execution time) at the lowest cost (that is in terms of size and management overheads). In order to perform well, a cache should adapt to workload changes. It should also be scalable, giving relatively good performance for different sizes (proportions of the slow memory). One way to measure the efficiency of a cache is to compare it, retrospectively, to the oracle strategy, that is, a strategy supposed to be aware of future data references. Belady [89] and OPT [93] can be used as top performing strategies. While the first one caches systematically every data block accessed (and so evicts systematically at each data access), the second could be more conservative and evaluates the relevance of storing a given data block for each access, preventing the cache from storing a "zero-reuse object". Belady and OPT assume that all data blocks have the same value and no priority is used for filtering data (which is not necessarily the case, for instance, for cloud and network-based applications).

A storage cache may have different functions that need to be highlighted to apprehend state-of-the-art contributions, especially the ones using AI. The most commonly designed cache strategy is "cache eviction". Most common caches are based on temporal locality and implement different flavors of Least-Recently-Used (LRU) and/or Least-Frequently-Used (LFU)-based algorithms to choose which data block to evict provided that we keep track of past references. In most cases, it is assumed that the cache is on the critical path and that each accessed data block is cached. When a data block is inserted, a block is chosen to be evicted (according to the implemented strategy). State-of-the-art strategies try to infer future accesses based on recency and/or frequency. Some cache strategies try not to insert in the cache all accessed data blocks, as some are not re-accessed in the future or it is simply not cost-effective to store them in the cache (e.g. it may cause the eviction of a high number of data blocks for a small benefit). In that case, the cache system implements an "admission control" system to filter data to be stored in the cache. Finally, the cache system may implement "prefetching mechanisms". It consists of loading in the cache data that are about to be used in the future, so that once requested by the application, they are loaded directly from the cache, thus reducing the execution

time. Prefetching generally relies on spatial (and sometimes geographic) locality. For instance, Linux implements read-ahead, that is spatial locality-based prefetching, in the page cache that prefetches data when files are accessed sequentially [56], [57].

## B. AI/ML for Caching

Using AI/ML for caching strategies generally induces a tradeoff between a set of advantages and disadvantages. From the positive side, as discussed earlier, using AI/ML makes it possible to have a system that is more accurate in predicting future use of data for a more relevant caching strategy (eviction, prefetching and admission control). AI/ML makes it possible to adapt more easily to changing workload and uses historical data in a more efficient (and complex) way to discover I/O access patterns (I/O size, type and order). From the negative side, the deployed AI/ML algorithms may be resource-hungry (CPU and memory) and are data-hungry and thus hard to deploy in practice. They also may push toward losing the control of the algorithmic understanding of the strategy, possibly reducing introspectibility and debuggability [94].

AI/ML made it possible to consider data in a more quantitative and qualitative way. From a quantitative perspective, AI/ML allows feeding models with huge volumes of data and finding (hidden) relationships between different I/O parameters. AI/ML also made it possible to feed the caching strategy online, enforcing adaptation to changing workloads. From a qualitative perspective, the design of an AI/ML-based caching strategy puts the abstraction level higher for designers that do not necessarily handle I/O parameters directly by handcrafting a strategy. However, they can feed the AI/ML algorithm with more diverse features, and it is (in general) up to the AI/ML algorithm to uncover the most relevant ones and generate the model subsequently. When using AI/ML, cache designers moved from handcrafting a strategy to selecting gray to black box components with the ability to leverage a higher diversity of features.

From a system perspective, after surveying 44 papers related to AI applied to storage cache, state-of-the-art caching strategies with AI can be subdivided into three classes:

* Centralized caches: for (generally) large (but sometimes smaller) systems incorporating a central cache in the storage hierarchy. The cache is technology-agnostic even if it is frequently built up of flash or DRAM-based memory.

* Embedded caches: here the cache is embedded in a device, generally an SSD, but it could be also integrated in a mobile phone. For this type of cache, the overhead of the caching technique should be limited and particular attention is drawn on memory footprint (as discussed in the Section VI). In some cases, energy consumption is also a metric to be limited.

* Distributed caches: here the cache is generally whether distributed itself in geographically large areas or it may serve several distributed nodes. The most frequent case study for this type in the literature is Content Delivery Networks (CDN).
### C. Centralized Caches

From the set of 44 papers surveyed in this section, 29 of them were dedicated to centralized caches. AI/ML was used mainly for three tasks in caching systems: prediction, classification, and selection.

**Prediction.** Several past studies relied on the prediction of different parameters to drive the cache strategy. Surprisingly, there was a vast set of different parameters that were predicted. The authors of [95] predicted the forward reuse interval (i.e. the number of accesses between the current access and the next access of the same block) using LSTM-based RNN to decide about the eviction of each object by seeking a pseudo OPT strategy performance. [96] used GBM to learn object group utilities by formulating the problem as a regression problem. It then predicts the future utility of an object. In [97], the authors used Support Vector Machines (SVM) to predict objects that will be read without being updated in a given time window for admission control in Key-Value caches. In [98], the authors used a multivariate regression model for the learned index at the client side for RDMA-based caches. The authors of [99] propose to predict, thanks to Extreme Gradient Boosting (XGBoost), if and how a file will be used in the near future to store in the cache by calculating a probability of using a file in a given time window. In [100], the authors also predict future file access, but this time, this is done through metadata analysis thanks to a handcrafted probabilistic model. The assumption here is that files are accessed in a given context, including both content-dependent and context-dependent information. The authors of [101] also predict the page to evict from a CLOCK cache while considering performance properties of the underlying media (e.g., asymmetric read and write costs). This is done thanks to a perceptron NN. In [102], the authors target to predict the next block to be accessed by the storage system for elaborating the eviction policy using word sequences in a language model, based on LSTM. The work in [103] models the hit density (how much an object will contribute to the hit rate) to predict the cache objects usefulness and draw a strategy based on this criteria. In [104], the authors predict the eviction probability based on a model of an approximate optimal Belady's MIN oracle that relies on cost-related parameters rather than only accesses. It uses a GBM model.

Prediction was also used for prefetching sake. In [41], the authors relied on finding the sequence of data to be accessed for an effective prefetch using a transformer model with attention. In [42], ExPAND is a CXL prefetcher trained to predict the next address to be accessed in order to issue both the address and time to prefetch a given block. They also used transformers for the prediction.

**Classification.** Several strategies used classification algorithms for caching strategies. The authors of [105] used classification for the prediction of the reuse of an object in the future to drive the cache according to cost considerations based on the reuse of objects. They used a flavor of the AdaBoost model. The authors of [106] try to identify performance-critical data pages with RNNs, while the authors of [107] seek to detect the running workload thanks to classification

with a simple NN to better tune the read-ahead prefetching. In [108], classification was used to identify the hotness of a block to choose between the use of LRU or LIRS (Low Inter-reference Recency Set) [109] eviction strategy. It relies on the naive Bayes Multinomial model. In [110], classification algorithms are used too, more specifically SVM with K-means, but this time for the purpose of choosing the right data to migrate in hybrid storage systems. Another usage of classification is done in [111], where the RL model partitions the storage cache between different types of data (digest for deduplication, content, and data), and the cache configuration is tuned accordingly. RL with Q-learning was used in this study. The authors of [94] used classification based on GBM for admission control and prefetching. It targets the reduction of disk latency (rather than increasing the hit rate) using a cost function. In [112], Hoeffding trees were used for classification to predict the files that will be accessed in the future and the next offsets within the files. Decision trees were used in [113] to classify whether a file will be accessed more than once in a given time window for admission control.

**Selection.** While in the previous category the AI/ML algorithms were employed to perform a classification after which a strategy is used to draw an action, some other contributions used AI/ML for directly selecting an action to perform on the system. Three contributions were proposed to select the right cache strategy to apply according to the I/O pattern identified, based on AI. In [114], the authors used RL with variants of Multi-Armed Bandit to select between LFU and LRU. The authors of [33] used different experts from LeCAR and adaptive parameter tuning. Deep RL (DRL) was leveraged in [99] using deep deterministic policy gradient (DDPG) for expert selection. The authors of [115] used a NN model for multi-class regression to predict the best cache strategy from a large set of experts such as LRU, LFU, ARC (Adaptive Replacement Cache), Hyperbolic, etc. The authors of [116] used RL demotion policy autotuning on multi-tiered main memory systems. It also promotes hot pages selected using K nearest neighbors model (KNN).

Other studies do not strictly fall in the preceding classes. In [117], the authors used MLP NN to model the miss ratio curve for cache efficient allocation. [118] uses GBM to approximate the Belady MIN algorithm and evicts randomly an object whose next request is beyond a specific threshold (for which caching would be useless).

### D. Embedded Caches

As presented earlier, embedded caches are generally integrated in specific devices (generally SSDs) and need to be limited in terms of resource usage. We identified 7 contributions in this area, most of which fall either in the prediction or classification class.

**Prediction.** ICGMM [119] optimizes caching and eviction using a hardware-implemented module based on Gaussian Mixture Models (GMM) that helps with page frequency prediction. DeepPrefetcher [40] uses a DNN to learn the block access pattern (and predict) contexts and leverages the LSTM model for context-aware data prefetching. The authors relied
on the difference between successive access requests rather than absolute LBAs. It is also supposed to run within the SSD device. In [120], the authors leverage an LSTM-based sequence-to-sequence NN model to learn and predict spatial I/O access patterns of applications from block-level I/O traces.

**Classification.** In [121], RFs were used to classify I/O requests as critical, intermediate, and non-critical according to their access status. The cache strategy relied on the criticality for eviction sake. In [122], the authors relied on a lightweight RF classifier to predict the forward reuse distance of I/O requests. It classifies their values into sets and tries to identify the set to which each request belongs. The lower the value, the higher the priority for storing in the cache. CacheSifter [49] classifies cache files into different categories according to their reuse (burn after use, transient, and long-living) and dynamically places them into DRAM or flash based on the access pattern. A lightweight MLP was used for the classification.

Different from prediction or classification, in [123], ML-Cache analyzes the reuse distance and uses a NN model to dimension the size of the cache to allocate to each stream in NVMe SSDs.

## E. Distributed Caches

8 papers fall within this class, most of which are related to CDN. Half of the papers use AI for prediction, and the other half for selection.

**Prediction.** In [124], the authors target the domain of Internet of Vehicles in fully distributed environments. The objective is to devise a caching framework that prefetches contents to the edge near the users. The authors used federated learning (FL) and KNN classifiers for popular content prediction. In [125], the authors used decision trees to predict the range of memory requirements and the performance improvement of caching in the context of Function as a Service (FaaS) cloud. OFC tries to accurately estimate memory requirements of functions and uses the remaining capacity for the cache. In [38], the authors used lightweight boosted decision trees based on LightGBM to model an OPT-like policy. They then call the predictor for each request to estimate whether or not to admit the data block into the cache. SLAP [126] predicts an object reuse time range for CDN using the LSTM model and admits objects that will be reused (before eviction) given the current cache size.

**Selection.** In [127], the authors use neural bandit expert selection to choose the right expert to deploy according to the access pattern in a CDN cache. In [128], the authors designed a caching and promotion policy (SCIP) to adjust the insertion position using a bimodal insertion policy for both miss and hit objects based on a multi-arm bandit reinforcement learning model. In [129], the authors formulated the cache policy optimization in a dynamic cellular network as a non-stationary partially observable Markov decision process and used an Advantageous Actor-Critic (A2C) supported by an LSTM-based NN. In [130], the authors devised an original strategy that augments a heuristic with a light NN model to rank and select the eviction candidates.

## F. Discussion

Table IV summarizes the different metrics with the AI/ML models classified according to the cache type (centralized, embedded, and distributed) and the model objective (prediction, classification, and selection). Several observations can be made:

* There is no consensus on the most important metric to model for a storage cache problem. Some metrics have been used in several studies such as: reuse distance, file or object reuse, hot/critical data. This disparity is related to the caching problem itself and AI-related contributions are no exceptions.

* There is no consensus on the AI models to use. In fact, some AI models were explored in several studies: LSTM, NN, RL, GBM, RF, however, we cannot conclude about a specific best model for caching.

* There is no consensus on how to use an AI model for solving a caching problem, among prediction, classification or selection.

* To the best of our knowledge, classification has not been investigated for distributed caches even if it could be used as for centralized caches, we could not ascertain the cause of this observation.

* To the best of our knowledge, selection has not been investigated for embedded caches even if it could be used as for centralized caches, we could not ascertain the cause of this observation.

In this part, we will discuss RQs identified in Section I.

### RQ1: What is the reason behind using ML ?

In most of the surveyed papers on caching, almost the same subset of reasons was given for justifying the use of AI/ML. We can list them as follows:

* Evolving and complex I/O workloads: one of the main drivers for using AI for caching is its ability to adapt to changing and evolving I/O workloads. This is the top one reason given in most papers. Not only I/O workloads are evolving, but they are also getting more complex because of changing applications and higher multitenancy [131].

* Complexity of the storage stack: not only the workloads are getting more complex, but the storage stack is also more difficult to apprehend because of a high number of different intermediate layers one can find between the user applications and the devices and that can impact the I/O performance [56], [57]. As the designer can hardly understand in a precise way the impacts of all the configuration knobs of the system, AI/ML can help in managing those issues.

* Heterogeneity of the storage technologies: in addition to the storage software stack, the storage devices used are heterogeneous and have different performance behaviors that can be hard to model and understand given the complexity of the storage stack. Here again, AI/ML-based approaches could be used to adapt a solution to the performance models (and even performance change).

* Curiosity: Several contributions have used AI/ML to evaluate to what extent it can help solving traditional caching strategies problems such as scalability [114].
<table><caption>TABLE IV
SUMMARY OF THE METRICS AND AI MODELS USED FOR CACHE OPTIMIZATION</caption><thead><tr><th rowspan="2"></th><th colspan="2">Prediction</th><th colspan="2">Classification</th><th colspan="2">Selection</th></tr><tr><th>Metrics</th><th>AI Models</th><th>Metrics</th><th>AI Models</th><th>Metrics</th><th>AI Models</th></tr></thead><tbody><tr><td>Centralized</td><td>Forward reuse interval [95], Object group utility [96], Zero update objects [97], Learned index [98], File usage [99], [100], Page to evict [101], Next block to access [102], Hit density [103], Eviction probability [104], Next data or address [41], [42]</td><td>LSTM [95], [102], GBM [96], [104], SVM [97], Multivariate regression [98], XGBoost [99], Perceptron NN [101], Handcrafted model [100], [103], Transformers [41], [42]</td><td>Object reuse [105], Performance critical data [106], Workload identification[107], Block hotness [108], Data to migrate [110], Cache size [111], Admission control [94], Files to be accessed [112], [113],</td><td>AdaBoost [105], RNN [106], NN [107], Bayes multinomial [108], SVM [110], K-means [110], RL [111], GBM [94], Hoeffding trees [112], DT [113]</td><td>Expert selection [114], [33], [99], [115], Hot/cold page selection [116]</td><td>RL [114], DRL [33], [99], [116], NN [115], K-NN [116]</td></tr><tr><td>Embedded</td><td>Page frequency [119], Access pattern [40], [120]</td><td>GMM [119], DNN [40], LSTM [120]</td><td>I/O or file criticality [121], [49], Reuse distance [122], [68], Access pattern [49]</td><td>RF [121], [122], NN [49], [68]</td><td></td><td></td></tr><tr><td>Distributed</td><td>Popular content prediction [124], Memory range [125], OPT sequence [38], Object reuse time range [126]</td><td>FL [124], KNN classifiers [124], DT [125], LightGBM [38], LSTM [126]</td><td></td><td></td><td>Expert selection [127], Insertion position [128], Cache policy optimization [129], Eviction candidate selection [130]</td><td>NN [127], RL [128], LSTM [129], NN [130]</td></tr></tbody></table>

Resorting to AI/ML for the reasons above is mainly justified by its ability to be adaptable (to workload changes, heterogeneity, and complexity of the storage stack) and data-driven (thus could be tailored for different applications provided there exist datasets for learning).

**RQ2: How is it practical and how much does it cost?** Talking about the practicality of AI algorithms for caching implies considering several aspects related to their implementation. From the three classes discussed earlier, all of the centralized and embedded cache-related contributions rely on the centralized deployment of AI/ML algorithms, while distributed caching strategies were deployed either in a centralized or distributed way. From the latter, one can mention CacheIn [124] that uses FL and learns the users' behavior locally and aggregates the models while using KNN classifiers for popularity detection. In [129], the authors used RL deployed in each node of a distributed dynamic cellular network to learn the optimal policy to deploy. In OFC [125], the system learns one model per function in an FaaS Cloud, and functions are distributed over several nodes.

From the set of papers studied, around half of them used offline learning with static models, and for the other half, they used either online learning, for instance, by using RL [132], [92], [116], [111], [114], [33], or offline learning with periodic updates [105], [105], [96], [97], [98], [113], [110], [104], [126], [49].

One other important criterion to take into account when evaluating the practicality of a solution is its overhead. In the case of AI/ML-related solutions, it can be split into two parts: the learning overhead and the inference overhead. For the former, very few papers evaluated its impact on the system as most of them probably considered this phase to take place only once and it is supposed to run offline. However, some contributions like [132], [105], [98], [107], [116], [126] tried to give an evaluation and analysis of the training phase. Concerning the inference phase, some contributions surprisingly

did not discuss the overheads of the added AI components, some others discussed it very briefly without a systematic methodology to evaluate it, while some other contributions such as [117], [105], [33], [96], [98], [106], [107], [94], [116], [115], [103], [118], [110], [104], [124], [38], [127], [128], [130], [126], [68], [119], [122], [49] evaluated it in different ways. The three most commonly estimated metrics are the CPU overhead for the online inference, the memory footprint (in terms of memory space) and the storage overhead. Surprisingly, from the embedded caches set of contributions, only half of them discussed in detail the overheads of the AI algorithm used.

**RQ3: How adaptable is the solution?** As discussed earlier in this paper, see Section III-A, adaptability can be defined with different properties: generalizability, scalability, explainability, and reproducibility.

**Generalizability** to other related problems is evaluated as to how the solution designed could be generalizable to other caching systems (other classes of caches for instance, or applications). Generalizability is not necessarily an ultimate goal, and it is fine to fine-tune a solution for a specific case study; the objective here is to initiate a discussion about how AI/ML-based strategies could be tailored for a given caching problem. Rather than claiming that a solution is generalizable or not, we will discuss criteria that could hinder or at least not allow one to directly claim it is generalizable. When required computing resources are high [92], [106], [94] or not detailed [105], [92], [99], [111], [100], [101], [42], [121], the solution could be difficult to generalize. Also, when the devised AI/ML strategy was only tested on a single application [105], [41], [38], [127], [126], [128], or it is specific to one application ([98], [103] for KV stores, [113] for SSD, [104] for databases, [125] for FaaS, [130] for video content), it could be difficult to generalize. Some contributions are also specific to some hardware such as [98] that uses RDMA, [42] for CXL, those were not designed with generalizability in mind. Some others
are related to a specific OS, such as Linux [107], or Android [49], even if those systems are widespread, the cache strategy could hardly be used for other operating systems.

**Scalability** is another important property to consider for adaptability. While it is common in cache-related papers to vary the size of the cache (in terms of proportion relative to the low performing memory or absolute size), few studies evaluated the tested infrastructure scalability (scale up and out). L-Qo-Co [132] is one of the exceptions that evaluated 2 scales (small and large server). From a workload perspective, there are more studies that tested different workloads [33], [98], [106], [101]. It was surprising to note that several papers relied on simulation, but still only one infrastructure and sometimes very few workloads were evaluated. About technological scalability, most of the caching solutions surveyed rely either on flash or DRAM as a cache, and to the best of our knowledge, no study tried to generalize to both technologies.

While there is a consensus about **Explainability** as being one of the main challenges related to AI adoption [133], very few papers have discussed it. Indeed, when the designed caching system does not satisfy some QoS criteria, one can hardly explain why or even find a solution or a specific tuning knob to optimize. As discussed earlier, AI strategies are seldom handcrafted, which hinders introspectability and debuggability. In [107], the authors discussed explainability and how they operated a trade-off between performance and explainability for choosing a given model. As their system is to be integrated into the kernel, discussing the explainability is crucial. Other papers, even if they did not discuss explainability as is, provided a detailed model analysis which would make it possible to understand the sources of problems encountered [112], [103], [38], [127].

**Reproducibility** is very important for AI/ML-based caching strategies. In fact, because the strategies are not handcrafted anymore, one could hardly rely on the description in the paper to reproduce the algorithms and then their results. One can distinguish 3 cases related to reproducibility: 1) the reviewing process guarantees the results' reproducibility, for instance through artifact evaluation such as in [105], [98], [94], [125], [127], 2) the authors can also provide source code with all data necessary to reproduce the results [92], [33], [96], [107], [116], [115], [118], [38], [128], or 3) even if the source code is not available, a particular effort could be made to give a detailed description of the solution [40], [103].

**RQ4: How are learning data managed?** For this RQ, we discuss two aspects: how data are obtained and how they are managed. For the former, several papers relied on common I/O traces repositories such as SNIA iotta [134], especially MSR [135], QQPhoto from Tencent [136], FIU [137], YCSB [138], VDI server [86] especially those in the centralized and embedded cache classes. For distributed caches, more specific traces are used, such as CDN-A, CDN-W, CDN-T [136], [118] or some traces obtained by generation [139] or through simulators [38], [129], [128]. Except for a few contributions such as [130], most of the papers use either state-of-the-art traces or benchmarks or common simulation tools and trace generators, which means they do not specifically use a methodology for data generation (since they use off-the-shelf

data traces).

Concerning data management, we surveyed papers with two criteria in mind: privacy and security of data for the learning. It was striking to see that the majority of the papers did not mention those criteria at all. Very few papers did, such as [124] in which a threat model has been discussed and some specific strategy proposed. This lack of consideration of privacy and security issues for caching strategies might be due to two reasons: 1) as most of the papers relied on state-of-the-art traces, they did not gather specific user data but used open source traces for prototyping, 2) as those traces are already anonymized or do not contain original users' information, it is possible that the authors did not see relevance in dealing with privacy or security issues.

## VIII. SYSTEM-LEVEL OPTIMIZATION

This section surveys how contemporary AI/ML techniques enhance five interlocking storage functions that collectively determine end-to-end system efficiency. We begin with **AI for Data Placement**, examining learning-driven policies that map data to heterogeneous tiers. Next, **AI for Data Deduplication** explores models that identify and eliminate redundancy beyond traditional hash-based matching. **AI for I/O Scheduling** then reviews adaptive algorithms that orchestrate request ordering and quality-of-service in multi-tenant environments. The fourth subsection, **AI for Storage Tuning**, analyzes data-driven frameworks that navigate high-dimensional configuration spaces to balance performance, cost, and fairness. Together, these subsections provide a cohesive view of how AI/ML permeates every layer of the storage stack, transforming static heuristics into predictive, self-optimizing mechanisms.

### A. AI for Data Placement

Within system-level storage optimizations, data placement plays a pivotal role in determining overall system performance, resource utilization, and operational cost. The increasing heterogeneity of storage hierarchies – ranging from NVM to SSDs and HDDs – combined with the growing dynamism of data access patterns, imposes significant challenges for traditional placement policies. Rule-based heuristics, such as frequency-based tiering or recency-driven migration, often fall short in environments that demand high adaptability, low latency, and energy efficiency across geographically distributed and resource-constrained infrastructures.

At the system level, data placement is challenged by a combination of heterogeneity, dynamism, scale, and policy constraints. Storage hierarchies often comprise multiple tiers – such as HDDs, SSDs, and NVM – each with distinct latency, bandwidth, endurance, and energy profiles. This heterogeneity complicates optimal placement, particularly under dynamic workload conditions where temporal shifts in access frequency render static or rule-based policies ineffective. As storage systems scale to accommodate massive data volumes across distributed nodes, the computational complexity of making timely and accurate placement decisions grows. Furthermore, resource constraints – such as bandwidth bottlenecks, cache
contention, and energy limitations – must be considered along-
side performance goals. In edge and multi-tenant environ-
ments, placement decisions are further constrained by security
and privacy requirements, as data sensitivity and isolation
dictate where and how data can be stored.

These challenges motivate the integration of machine learn-
ing techniques into placement engines for more intelligent
and adaptable data allocation. ML-based approaches to data
placement generally fall into three categories: reinforcement
learning, supervised learning, and hybrid or deep learning
methods. Reinforcement learning is leveraged in systems like
MiniCost [54] and DataBot+ [55], where data placement is
framed as a Markov Decision Process (MDP). MiniCost [54]
periodically determines the optimal storage class for each file
(e.g., hot, cold, archive) in a cloud storage setting by min-
imizing long-term monetary costs associated with read/write
operations, storage allocation, and transitions between tiers.
DataBot+ [55] similarly uses an MDP framework to select
migration actions across storage tiers. By decoupling the train-
ing and inference pipelines and deploying neural networks for
Q-value estimation, it reduces tail latency while maintaining
responsiveness in online settings.

Supervised learning techniques are employed to predict
data popularity and guide tier assignments. For instance,
Archivist [140] uses neural predictor trained on access patterns
and file metadata to estimate file popularity and allocate
them to appropriate storage tiers. This prediction-driven strat-
egy outperforms reactive heuristics by avoiding the latency
spikes that arise from misplacement. Another example is ML-
WP [141], which applies Naive Bayes and RF classifiers to dis-
tinguish write-intensive blocks from others, thereby reducing
unnecessary writes to SSDs and improving endurance. These
classification models rely on lightweight features like logical
block addresses and write frequency, ensuring low overhead
during real-time decision making.

Hybrid models offer additional flexibility by combining
clustering and classification methods. K-SVM [110] employs
K-means clustering to select representative samples and uses
SVMs to determine migration decisions for other data. This
approach significantly reduces training overhead while ensur-
ing effective placement, particularly in environments where
access distribution exhibit clear clusters of behavior. By iden-
tifying migratable objects in a two-stage pipeline, the system
achieves a favorable balance between inference latency and
migration benefit.

Deep learning has also been explored to capture complex
access patterns and system-level signals. Geomancy [142] uses
DNNs trained on telemetry data – such as queue depths and
latency histograms – to predict bottlenecks and reconfigure
data layouts accordingly. Its approach is proactive rather than
reactive, allowing storage systems to anticipate rather than
respond to degradation. Meanwhile Secure-Stor [143] extends
placement optimization to the edge computing domain. It clas-
sifies incoming data streams based on deadline requirements
and security labels, ensuring that sensitive data is placed on
encrypted partitions without compromising access latency.

Overall, ML-enabled data placement systems demonstrate
significant improvements in cost efficiency, responsiveness,

and system resilience compared to traditional heuristics. These
techniques not only exploit patterns in historical workloads but
also adapt in real-time to environmental changes and workload
shifts. As storage systems contribute to evolve in scale and
complexity, the integration of AI/ML models into data place-
ment engines is expected to become increasingly central to
achieving optimal performance and policy compliance across
diverse deployment contexts.

B. *AI for Data Deduplication*

Data deduplication is a foundational system-level optimization for eliminating redundant data and reducing storage overhead. It is particularly critical in backup, archival, and cloud-native environments where datasets often contain a high degree of repetition. Traditional deduplication approaches operate at the file, block, or byte-level using techniques such as content-defined chunking (CDC) and cryptographic hashing (e.g., SHA-1 or MD5). While these methods are effective at identifying exact duplicates, they often fail to capture semantically redundant or near-identical data, especially in high-dimensional or transformed content.

Deduplication systems in modern storage environments face
several interrelated challenges that limit their effectiveness
and scalability. Traditional byte-level matching techniques fail
to detect semantic redundancy, particularly in cases where
near-duplicate content – such as images, training samples, or
formatted text – differs slightly at the binary level, resulting in
distinct hashes despite high underlying similarity [47], [144].
Fragmentation introduced by both online and post-processing
deduplication exacerbates I/O overhead, as data chunks be-
come physically dispersed across the storage backend, leading
to degraded read performance [144]. As datasets grow, main-
taining a global fingerprint index becomes increasingly costly
in terms of lookup latency and memory footprint, particularly
when indexes cannot reside entirely in memory [145], [146].
Static heuristics – such as sparse indexing, rule-based candi-
date selection, and fixed prefetching strategies – struggle to
adapt to shifting data distributions and dynamic workloads,
often leading to suboptimal deduplication effectiveness [146],
[147]. Furthermore, resemblance detection methods that rely
on Locality-Sensitive Hashing suffer from high false-negative
rates and limited adaptability, restricting their usefulness in
diverse and evolving storage environments [148], [149].

To address these limitations, ML techniques have been
adopted to enhance deduplication precision, efficiency, and
adaptability. Supervised learning has been applied to fin-
gerprint cache management, where intelligent policies are
trained using features such as reuse frequency and locality.
Performance-Centric Deduplication [146] employs RF and
KNN models to improve fingerprint cache hit rates and reduce
read latency compared to traditional LRU and LFU schemes.

Deep learning has been used to model semantic resemblance
and content similarity more effectively than traditional hash-
based methods. DeepSketch [149] uses a two-stage neural
network to generate compact sketch embeddings of chunks,
enabling fast approximate nearest neighbor search in post-
deduplication delta compression. Chunk2Vec [144] leverages
a pre-trained Sentence-BERT [150] encoder to embed data
chunks into a high-dimensional vector space, allowing sim-
ilarity detection even in the presence of format preserving
transformations. These techniques significantly improve space
savings and detection accuracy in high-variance workloads.

In domains such as image and model training data, custom
architectures have been designed to support domain-specific
deduplication. IDedupNet [148] uses a lightweight CNN based
on MobileNetV3 to identify near-duplicate images in edge-
cloud storage environments. Through contrastive learning and
cosine similarity, it balances accuracy and low inference
overhead for edge deployment. AdaEmb-Encoder [47] ad-
dresses redundancy in high-dimensional training samples by
embedding them into latent space using UMAP and applying
DBSCAN clustering to detect structurally similar entries. This
approach eliminates semantically redundant training samples
while preserving model utility.

RL has been adopted to improve system-level deduplication control in real-time environments. LIPA [145] models segment prefetching as a contextual multi-armed bandit problem, dynamically selecting segment types based on observed reward signals like cache hit rate. SegDedup [147] trains a Deep Q-Network (DQN) to adapt chunking strategies in response to workload feedback, switching between chunking-based and whole-file deduplication modes depending on performance rewards.

Together, these systems illustrates how learning-based dedu-
plication can adapt to content semantics, workload variation,
and system-level performance constraints. While supervised
and deep learning techniques dominate resemblance detection
and chunk selection, RL provides dynamic adaptability at
runtime. As storage systems continue to grow in complexity
and scale, ML-based deduplication offers a path toward more
accurate, efficient, and context-aware redundancy elimination
strategies.

C. AI for I/O Scheduling

I/O scheduling is a critical system-level component of dis-
tributed storage systems, responsible for orchestrating access
to underlying devices while balancing throughput, latency,
fairness, and Service-Level Objectives (SLO). This task be-
comes increasingly complex in cloud environments, where
multiple tenants generate concurrent and unpredictable I/O
workloads. Traditional scheduling mechanisms, often based on
fixed-priority queues, rate limiters, or proportional fairness,
lack the adaptability to manage real-time system dynamics
and typically fail to maintain consistent performance under
contention.

Modern I/O schedulers must address a series of interde-
pendent challenges that degrade performance if not managed
carefully. High variability and burstiness in read/write work-
loads – especially across tenants or over time – introduce
queue contention and unpredictable latency spikes, often lead-
ing to SLO violations during peak demand periods [151].
Background Maintenance activities such as garbage collection,
snapshot deletion, and disk rebuilding can further interfere
with foreground performance, especially when both types of

operations compete for limited I/O bandwidth [152]. Concur-
rent background and foreground tasks exacerbate the need for
robust resource isolation, as interference among operations
leads to degraded latency guarantees and throughput imbal-
ance [153]. Moreover, many production-scale storage systems
are deployed as black boxes, exposing only coarse-grained
or delayed metrics to control plane, making it difficult to
model or predict system response [151]. Finally, the need to
support diverse and dynamic QoS requirements across tenants
complicates scheduling further, especially when the system
must distinguish between latency-sensitive and bandwidth-
intensive workloads on shared hardware [153].

To address these challenges, recent work has proposed
ML-based I/O scheduling techniques that learn directly from
performance signals and system telemetry. A black-boxed
self-learning scheduler [151] for cloud block storage systems
models the I/O decision-making process as a RL task, where
the environment consists of a non-transparent storage stack.
Without requiring instrumentation or access to internal de-
vice states, the system observes latency, request types, and
queue lengths to train a deep Q-network that learns effective
dispatching policies. Its hybrid architecture decouples policy
training from inference, reducing runtime overhead while
enabling continual policy refinement from observed behav-
iors [151].

In parallel, a smart background scheduler [152] applies
reinforcement learning to coordinate background tasks with
active foreground I/O. This system models the I/O backlog,
latency trends, and queue utilization to determine the opti-
mal timing and rate of background task execution. Unlike
traditional fixed-rate scheduling, which risks either under-
utilization or interference, this adaptive scheduler minimizes
disruption by adjusting background operation in response to
real-time conditions [152]. The result is improved foreground
latency stability and higher overall throughput under mixed
workloads.

Complementing these works, another system targets
QoS [153] differentiation across tenants by combining super-
vised learning with low-overhead feedback loops. The system
learns to map observed I/O patterns and tenant-specific per-
formance metrics to scheduling weights, adjusting order and
rate limits accordingly. This enables the scheduler to enforce
differentiated service guarantees, such as high percentage
latency for interactive tenants or minimum throughput for bulk
transfer clients, even when demand shifts dynamically.

Together, these learning-based systems demonstrate that
I/O scheduling can benefit from adaptive, data-driven control
mechanisms. Reinforcement learning agents offer the ability to
learn long-term policies under partially observable conditions,
while supervised models enable targeted QoS enforcement
through performance prediction. By moving beyond hand-
crafted heuristics and fixed dispatch rules, these AI-based
approaches provide a more robust foundation for managing
content, isolation, and service differentiation in modern multi-
tenant storage systems.
## D. AI for Storage Tuning

Storage tuning is essential as a system-level optimization to optimize I/O performance, resource utilization, and cost efficiency. Modern storage stacks span complex hierarchies—ranging from local disks and RAID groups to parallel file systems and cloud object storage—with numerous tunable parameters including I/O concurrency, buffer sizes, file system selection, and data placement strategies [154], [155], [156]. In HPC and cloud environments, suboptimal configurations can lead to performance bottlenecks, unfair resource sharing, or inflated costs. The growing diversity of workloads, coupled with dynamic resource availability and configuration complexity, has rendered manual tuning impractical. As a result, AI/ML-based techniques have emerged to automate tuning decisions, enabling systems to adaptively identify and apply optimal configurations.

Several challenges complicate effective tuning. The parameter space is high-dimensional and includes both continuous and categorical variables, with complex interactions that are often workload-dependent [154]. Effective configurations vary across platforms and job scales, limiting the reusability of static configurations [156], [154]. Evaluation overheads are high, as each configuration may require executing full-scale I/O workloads [155]. Tuning must also balance competing objectives—such as throughput, cost, and fairness—especially in multi-tenant environments [156], all while operating under limited observability in many cloud settings [154].

To address these issues, researchers have proposed a variety of AI-based tuning frameworks. ACIC [154] models the relationship between cloud I/O configurations and performance using black-box learning over a 15-dimensional space, combining system-level and application-level features. It employs classification and regression trees (CART) trained on synthetic workloads, and uses Plackett-Burman design matrices to reduce training cost by identifying dominant parameters. Mimir [156] focuses on selecting cost-optimal combinations of heterogeneous cloud volumes through a three-stage pipeline of profiling, interpolation-based prediction, and dynamic programming, enabling runtime reconfiguration triggered by job slowdowns. Carver [157], in contrast, uses Latin Hypercube Sampling and variance-based parameter importance metrics to guide search over configuration space. This reduces tuning overhead by up to 97.5% without sacrificing model quality.

Falcon [155] addresses the online tuning of file transfer parameters in high-speed networks. It introduces a game-theoretic utility function that balances throughput with fairness and overhead, using Hill Climbing, Gradient Descent, and Bayesian Optimization to find optimal concurrency and parallelism levels. Unlike supervised models, Falcon adapts in real time without requiring prior training data, making it well suited to dynamic workloads and variable I/O paths.

Together, these systems illustrate the breadth of AI applications in storage tuning—from offline supervised modeling in cloud platforms to online black-box optimization in networked transfers, and sample-efficient parameter selection in large configuration spaces. ACIC and Mimir emphasize reusability and cost-awareness, Falcon delivers responsiveness

and fairness under contention, and Carver contributes scalable search techniques. Despite their strengths, limitations remain: ACIC depends on offline synthetic training, Falcon is sensitive to metric noise, and Mimir assumes decomposable workload profiles.

## E. Discussion

Table VIII-D classifies the metrics and AI techniques adopted across the five system-level optimizations (data placement, deduplication, I/O scheduling, storage tuning, and key-value stores) according to their primary objective—prediction, classification, or selection. Several observations emerge:

* **Diverse optimization signals.** No single metric dominates: studies model latency, cost, access frequency, semantic similarity, queue depth, compaction cost, and many others, underscoring the domain-specific nature of each optimization problem.

* **Varied AI model choices.** A wide spectrum of models—tree-based learners, Naive Bayes, regression, CNNs, Transformers, RL agents, Bayesian optimizers, and even LLMs—has been explored, with no consensus on a universally superior approach.

* **Heterogeneous use of prediction, classification, and selection.** Some works frame the problem as pure prediction (e.g., configuration-performance modeling), others as classification (e.g., hot-data or similarity detection), while many rely on selection or control via RL; no single formulation fits all subsystems.

* **Sparse use of classification in certain domains.** Classification is common in data placement and deduplication but largely absent in storage-tuning and key-value-store papers, suggesting unexplored opportunities in those areas.

* **Concentration of online RL.** Selection methods based on reinforcement learning are prevalent in data placement and I/O scheduling, yet appear less frequently in storage-tuning and deduplication studies, where optimization is still often performed offline or with heuristic search.

**RQ1: What is the reason behind using ML?** The justification for integrating machine learning across data placement, deduplication, and I/O scheduling primarily stems from the limitations of static, heuristic-based strategies in dynamic storage environments. For data placement, ML enables predictive and adaptive allocation of data to heterogeneous storage tiers by learning from historical access patterns (e.g., DataBot+ [55], Archivist [140], Geomancy [142]). This approach is especially suitable when workload characteristics are non-stationary, and storage resources are tiered by latency and cost.

In deduplication, ML enhances traditional fingerprinting by capturing semantic similarities among data chunks that are not byte-identical. Systems like DeepSketch [149] and Chunk2Vec [144] illustrate that deep learning is essential when deduplication relies on high-dimensional representations or perceptual similarity. Similarly, supervised models (e.g., ML-Dedup) filter non-beneficial chunks prior to indexing, reducing overhead.
<table><caption>TABLE V
SUMMARY OF THE METRICS AND AI MODELS USED FOR System-level Optimizations. EACH ROW CORRESPONDS TO ONE SUBSECTION; THE THREE TASK-ORIENTED COLUMN GROUPS MIRROR THE STRUCTURE OF TABLE 4 IN THE Caching and Prefetching SECTION. ONLY WORKS REVIEWED IN THIS SECTION ARE INCLUDED.</caption><thead><tr><th rowspan="2">Subsection</th><th colspan="2">Prediction</th><th colspan="2">Classification</th><th colspan="2">Selection / Reinforcement</th></tr><tr><th>Metrics / Features</th><th>AI Models</th><th>Metrics / Features</th><th>AI Models</th><th>Metrics / Features</th><th>AI Models</th></tr></thead><tbody><tr><td>Data Placement</td><td>Access frequency traces; queue depth; latency histograms; cost signals</td><td>DNN predictors (Archivist [140], Geomancy [142])</td><td>File popularity; write intensity; security label</td><td>Naive Bayes, Random Forest (ML-WP [141]); SVM + k-means (K-SVM [110]); CNN (Secure-Stor [143])</td><td>Cost/tail-latency minimization; tier hot/cold status</td><td>DQN/Policy-gradient RL (MiniCost [54], DataBot+ [55]); k-means + SVM (K-SVM [110])</td></tr><tr><td>Data Deduplication</td><td>Fingerprint reuse; cache-hit probability</td><td>Random Forest, KNN (Performance-Centric [146])</td><td>Chunk-similarity embeddings; reuse distance</td><td>Sentence-BERT (Chunk2Vec [144]); CNN (IDedup-Net [148]); UMAP + DBSCAN (AdaEmb [47])</td><td>Segment prefetch type; chunking strategy switch</td><td>Contextual bandit (LIPA [145]); DQN (SegDedup [147])</td></tr><tr><td>I/O Scheduling</td><td>Latency trend; backlog; queue utilization</td><td>DQN (Black-box Scheduler [151])</td><td>Tenant QoS class; workload ID</td><td>Supervised mapping / regression (Zhang et al. [153])</td><td>Dispatch order; background task rate</td><td>RL agents (Smart BG Scheduler [152]; Black-box [151])</td></tr><tr><td>Storage Tuning</td><td>Configuration performance</td><td>CART (ACIC [154]); interpolation-based models (Mimir [156]); regression+sampling (Carver [157])</td><td>Parameter importance</td><td>Variance-based ranking (Carver [157])</td><td>Concurrency, buffer size; volume mix</td><td>Hill-Climbing, Gradient Descent, Bayesian Optimization (Falcon [155]); Latin-Hypercube search (Carver [157])</td></tr></tbody></table>

For I/O scheduling, ML facilitates proactive and QoS-aware decisions in multi-tenant systems. Forecasting and classification models are applied to background task scheduling (e.g., Smart Background Scheduler [152]), while black-box models are effective when system internals are inaccessible. These use cases justify ML adoption due to the need for real-time adaptability and fine-grained resource control.

In storage tuning, ML is used to identify high-impact parameters, optimize performance-cost tradeoffs, and adapt configurations across diverse workloads and environments. Systems like ACIC [154] and Mimir [156] demonstrate that black-box models can effectively predict near-optimal configurations with minimal profiling. Falcon [155] and Carver [157] apply online learning and sampling techniques to reduce tuning overhead and adapt in real time.

**RQ2: How practical and costly are AI/ML solutions in Storage?** ML deployments in storage systems vary in complexity and cost. Lightweight classifiers such as Naive Bayes or decision trees (e.g., ML-WP [141], Performance-Centric Deduplication) impose minimal computational overhead and integrate seamlessly into the storage stack. These models are practical in high-throughput systems where latency is critical.

More complex models like DNNs (e.g., Geomancy [142], DeepSketch [149]) or RL agents (e.g., SegDedup, DataBot+ [55]) demand significant training time and may require GPU acceleration. However, they are typically used offline or in supervisory control loops, reducing runtime cost. Online models like LIPA [145] and Smart Background Scheduler [152] combine fast inference with periodic model updates.

In terms of deployment architecture, systems like

Archivist [140] and MiniCost [54] rely on centralized controllers with a global view, while others (e.g., Secure-Stor, SegDedup) operate in distributed or edge environments. The practical cost includes memory for model states, CPU cycles for inference, and potential storage for training logs. Despite these costs, evaluation across all manuscripts demonstrate tangible gains in latency reduction, deduplication efficiency, and QoS compliance.

In storage tuning, approaches like ACIC [154] and Carver [157] prioritize cost-efficiency by using synthetic workloads or variance-based sampling to reduce training time. Mimir [156] adds minimal overhead by integrating predictive models into periodic profiling loops, and Falcon [155] adapts using lightweight optimizers that converge quickly.

**RQ3: How Adaptable are AI/ML storage solutions?** Adaptability is measured by generalizability, scalability, explainability, and reproducibility. Systems like Chunk2Vec [144] and DeepSketch [149] generalize across workloads by using semantic embeddings trained on diverse datasets. RL-based approaches (e.g., LIPA [145], DataBot+ [55]) adapt to workload evolution without retraining, using online reward feedback.

Scalability is achieved in Performance-Centric system through compact models that support large data volumes with low inference latency. K-SVM [110] and Smart Background Scheduler [152] use clustering and forecasting to reduce computation without sacrificing accuracy.

Explainability varies across models. Decision trees and statistical models offer interpretable logic (e.g., ML-W [141]P, Archivist [140]), whereas deep models lack transparency. Some systems (e.g., AdaEmb-Encoder [47], Smart Back-
ground Scheduler [152]) use visualizations or rule-based triggers to aid interpretability.

Reproducibility depends on dataset availability and implementation details. While many papers provide performance traces and configurations (e.g., DeepSketch [149]), others (e.g., Secure-Stor, SegDedup) rely on simulated environments without public code.

In storage tuning, adaptability is reflected in systems like Falcon [155] and Mimir [156] that adapt to workload variation in real time. ACIC [154] and Carver [157] generalize across applications by training on synthetic or sampled data.

**RQ4: How is learning data obtained and managed?**
Learning data is primarily obtained from operational traces, application logs, or synthetic workload simulations. DataBot+ [55] and MiniCost [54] use profiling tools to extract access frequency and performance metrics. LIPA [145] rely on labeled chunk features and segment access logs. Smart Background Scheduler [152] uses I/O traces to model idle intervals.

Most systems adopt non-intrusive data collection, minimizing interference with live workloads. Privacy and security concerns are not deeply discussed in reviewed works, especially for cloud or edge deployments. Only Secure-Stor incorporates sensitivity-aware classification in placement, indirectly addressing data confidentiality. Broader data governance policies (e.g., tenant isolation, anonymization) remain underexplored in current designs.

In storage tuning, ACIC [154] and Mimir [156] rely on synthetic or periodic profiling to train models with low operational impact. Falcon [155] collects performance metrics online, while Carver [157] samples configuration results for statistical modeling.

# IX. WORKLOAD AND PERFORMANCE PREDICTION

## A. Introduction

Characterizing workloads that run on parallel and distributed systems and predicting data movement performance of applications and the systems are crucial for effective and efficient storage optimizations. As storage systems continue to grow in size and application scenarios continue to diversify, new challenges arise. Advances in machine learning and deep learning provide a unique opportunity to improve workload characterization and performance prediction. In this section, we mainly focus on efforts that use AI/ML for characterizing I/O workloads for a diversity of applications, and also for predicting storage system performance for a given set of I/O applications. In Section VIII, our discussion focused on AI used for storage system-based optimizations focusing on deduplication, key-value stores, I/O scheduling, and storage tuning. In contrast, our focus in this section is on using AI to drive optimizations in storage systems by understanding and predicting workload patterns, performance, and energy consumption.

Storage related workloads refer to several categories, including the characteristics of read and write patterns, numbers of I/O operations (IOPS), rates of file operations (create, open, read/write, update, delete, etc.), metadata requests, file life time on a system, etc. Characterization of workloads and

prediction of storage and I/O performance have been explored broadly in HPC environments as well as in cloud computing environments. We categorize the use cases of AI into studies of performance interference among multiple concurrently running workloads and resulting variability [39], [158], [159], [160], [161], [162], [163], optimized data movement between multiple storage and memory locations [53], [164], [165], [166], [167], understanding I/O behavior and scheduling I/O [24], [48], [29], [168], [169], [170], and understanding I/O performance bottlenecks and analysis of their root causes [171], [172], [173], [174], [175], [176], [177]. A few studies focused on understanding workload characteristics for designing benchmarks that can be used to evaluate designs of applications or systems [178], [23], [179]. In the following subsections, we dive into each of these categories of workload characterization and performance prediction use cases.

## B. Interference and variability

In a shared storage system that serves numerous applications from multiple users, I/O requests on the storage system side get interleaved. This introduces I/O interference and performance variability, which are becoming increasingly important as the number of concurrent applications and the amount of data grow [180], [181], [182]. Several efforts have been made to leverage ML/DL to find and group interleaved accesses to the storage system, and estimate I/O performance and its variability due to interference at the device and storage levels.

The locality and concurrency of sequential accesses are typically lost when I/O requests from multiple applications are interleaved. This may lead to poor performance due to the storage system's serving distinct and potentially random types of accesses. For instance, a workload with sequential write accesses could be sent to a log-structured file systems (LFS) configuration instead of to an SSD-based configuration. Census [39] uses machine learning to identify the number of functional workloads or fworkloads that have functionally distinct usages of a storage system. The objective of Census is to separate functionally distinct features in storage system-side I/O traces. Specifically, Census processes a given I/O trace as a time series dataset, selects various features that define distinct functions of storage system usage, and uses LightGBM and RF ML algorithms to classify the features. The features are grouped as spatial (access address-based) and temporal (time of accesses) patterns. This can lead to better scheduling of the requests. Costa et al. [162] studied the I/O behavior and performance variability in an HPC system. They used agglomerative hierarchical clustering to group read and write runs using 13 metrics from Darshan logs. They observed 497 read clusters and 257 write clusters across applications. These clusters were used to detect performance variability across runs with the same I/O behavior, applications, and clusters.

**Impact of interference at the device level on workloads.**
Workloads suffer from performance degradation when collocated with others on the same SSD due to I/O interference. Thus, workload placement relies heavily on interference performance models to ensure SLOs and improve resource utilization. In [161], the authors investigated the potential of
using machine learning to build predictive I/O performance models for SSDs, with a particular focus on predicting I/O interference issues. They evaluated the accuracy, overhead and learning curve of five learning algorithms including decision trees (DT), Multivariate Adaptive Regression Splines (MARS), adaptive boosting (AdaBoost), gradient boosting decision tree (GBDT), and RF. The authors used different workloads and types of SSDs. They demonstrated that RF for example can achieve high accuracy with a median normalized root-mean-square error (NRMSE) of 2.5 percent and a training time of less than 4 seconds, making it a promising candidate in practice. Jaliminche et al. [160] built on previous efforts to predict performance in the presence of I/O interference by using a gray-box machine learning model. It improves upon black-box ML models by considering a novel feature set that represents the non-uniform nature of workloads (bursty behavior) and corresponds to SSD internals. The proposed approach also uses a feature aggregation technique to enable prediction across an arbitrary number of workloads. The ML model is trained using the RF regression algorithm. It demonstrated high accuracy but considerable overhead and will require retraining in a real production cluster.

**Impact of interference in large scale storage systems.** Interference makes predicting I/O performance in applications difficult. Madireddy et al. [158] have studied how to predict I/O performance and its variability on large-scale HPC systems, such as those at the National Energy Research Scientific Computing Center (NERSC). They used Gaussian Process (GP) regression model to predict I/O performance. The data used in this study comes from Edison, a Cray XC30 system at NERSC. The logs include those collected using Darshan [183] characterization tool, those from Lustre Monitoring Tools (LMT), and job scheduler (Slurm) logs. The applications include IOR, a common I/O benchmark, and HACC-IO, an I/O kernel from a cosmology simulation application. Qiao et al. [159] used discrete Fourier transform (DFT) for monitoring and estimating interference using the periodicity of I/O interference patterns in HPC applications. The performance improvement by reducing I/O interference was evaluated using XGC (plasma physics), GenASiS (2D rendering of velocity in astrophysics data), and Jet (analysis of pressure near the front of a fighter jet in computational fluid dynamics). In [163], the authors evaluated the accuracy of several machine learning algorithms in estimating performance variability using features such as IO Scheduler, Virutal Machine (VM), I/O Scheduler, file size, record size, number of threads, and CPU frequency. These algorithms include linear model (LM), Gamma GLM, Multivariate Adaptive Regression Splines (MARS), Treed Gaussian Processes (TGP), Bayesian Additive Regression Trees (BART), and Categorical Gaussian Process (CGP).

### C. Optimized data movement and placement

Multi-tiered storage architectures have been commonly appearing in HPC and cloud computing systems. Optimized data movement from a source to a destination where the data are needed with low latency needs understanding the

historical workloads and prediction of performance or energy. For instance, PreMatch [53] is a strategy for predicting energy consumption in data centers when data is on SSDs instead of HDDs. Other purposes of analyzing workloads for optimizing data movement includes understanding file life times, predicting frequently used storage blocks, etc.

With data center consumption of energy increasing, balancing high performance, low grid energy consumption, and high green energy utilization are critical to reduce CO₂ emissions. Because storage systems use 20% of energy in data centers, leveraging faster storage devices, such as SSDs, and reducing the number of active devices that use grid energy improves higher green energy utilization while the performance of applications increases. PreMatch is a strategy for predicting future workloads based on historical data and green energy utilization for enabling scheduling of the number of active devices in a data center storage system [53]. PreMatch uses LSTM to predict workloads and green energy trends to guide a proactive system scheduling strategy. The storage system consists of a main pool of HDDs and a cache layer consisting of SSDs and HDDs. LSTM uses historical workload data from Microsoft Research (MSR) Cambridge web servers that included IOPS, write ratios, and average request sizes, and green energy data that consisted of solar and wind power outputs and usage. The accuracy of workload prediction was above 95%, and the green energy predictions had low RMSE (Root Mean Squared Error), demonstrating the effectiveness of LSTM in forecasting. By using LSTM, PreMatch was able to make informed scheduling decisions in advance, which optimized energy consumption while not impacting performance significantly. Compared to Workload-driven scheduling (WDS), PreMatch improved 35% additional usage of green energy utilization and reduced grid energy usage by 50%. This is a simulation-based evaluation, where green energy utilization improved. Performance could be reduced due to the energy savings in real scenarios.

In systems with high performance and high capacity storage tiers, frequently used files are kept in the performance tier to reduce latency in accessing data. Similarly, a file that is not needed anymore can be moved to the slower capacity tier allowing better utilization of the performance tier. In these systems, predicting the lifetime of a file allows moving the file between the performance and capacity tiers. To predict file lifetime, Thomas et al [164] use CNN. The lifetimes are predicted based on an analysis of time between the last access times of files and their creation times, and the time between the last modification times and their creation times. The training of the file life times prediction model is done using 70% of a 5 million log entries from a production system. The training method used early stopping and mixed precision optimization methods to reduce the training time as well as to prevent overfitting. The predicted model is verified with the remaining log entries using accuracy of predicted file lifetime with the actual lifetime and underestimation metrics. Underestimation refers to the ratio of predicted lifetime lower than that of the actual. Overall, the proposed approach achieved 98.6% accuracy and just 2.2% of underestimations. In general, this is a simple approach for two-tiered systems, which are common in supercomputing systems. The training time is about 2 hours
with the mixed-precision and early-stopping optimizations,
running on 4 Tesla V100 GPUs. Without the optimizations, it
takes 4 hours. The analysis was done with the logs provided
by a single system. Once trained for a system, the method is
generally applicable to only that system.

Predicting popular storage blocks in multi-tiered multimedia
storage systems can lead to optimizing data placement between
high-speed SSDs and low-speed HDDs. Cheng et al. [165] pro-
pose spatial and temporal correlations among multimedia data
blocks, revealing strong relationships between neighboring and
historical block access frequencies using a spatial-temporal-
sequential neural network (STSNN). STSNN leverages spatial,
temporal, and sequential correlations in block access data. The
proposed model aims to achieve higher accuracy in predicting
block popularity. To evaluate this approach, the authors used
a synthetic dataset (SPC-1) and three real-world datasets
(Huawei-1, Microsoft-1, and Microsoft-2). A pre-processing
step involved to extract 30-dimensional features for each block
from raw I/O traces, of which 80% of the traces were used for
training and the remaining for testing. The STSNN approach
was compared with various baseline models, such as heuristics
(LRU, CBF), regression (linear regression, moving average,
etc.), and neural networks (RNN and LSTM). Overall, STSNN
achieved better accuracy and ≈3X improvements in I/O hit
ratios and prediction of popular blocks. The method can be
generally applicable to various data movement use cases, such
as cache prefetching and replacement, hot data for moving in
storage tiers, and data migration. The prediction approach de-
pended on feature extractions in the pre-processing step. This
process of designing and extracting 30-dimensional features
(local and neighboring information) may require significant
knowledge of the important features.

Data staging is essential for supporting in-situ/in-transit
workflows at scale, i.e., enabling fast and efficient data ex-
change between coupled applications. Data staging frame-
works buffer data in local memory and then transfer it to
staging servers, where other applications can access it. Staging
servers are usually shared by many users (applications), so
reducing I/O interference when reading and writing data is
important. Subedi et al. [166] developed a grammar-based
prediction technique that predicts the arrival of requests on a
specific staging server. Accordingly it schedules data draining
on staging servers when the load is low, thereby avoiding
interference.

The relevance of data is an important metric widely used by
storage control policies to determine where to store data and
redundancy factors. The main challenge lies in designing algo-
rithms that can learn from small labeled data subsets. Venkate-
san et al. [167] proposed a novel, graph-based algorithm for
estimating data relevance that groups files based on the type
of available metadata. Hierarchical clustering algorithms are
used to learn the similarity between each pair of files in a file
set. Using message passing, the relevance of unlabeled files is
estimated based on the similarity metrics for each file set. The
proposed solution was compared against a logistic regression
classifier and demonstrated a 65% improvement in accuracy.

D. I/O behavior analysis and attribution to scheduling

I/O workload traces have several advantages, such as un-
derstanding the I/O behavior, designing next-generation sys-
tems, driving I/O optimizations and scheduling, and estimating
system requirements. Paul et al. [48] proposed to use ML
approaches to generate anonymized I/O traces of end-to-
end ML workloads based on an analysis of historical traces.
Specifically, they use selection of POSIX-IO features and
then use a light-weight DBSCAN clustering algorithm to
identify the clusters of features and then multi-layer perceptron
generative modeling for generating I/O traces. Wang et al. [24]
propose a multi-dimensional cloud disk resource allocation
method, where it considers IOPS and disk bandwidth along
with capacity. The proposed Smart Cloud Disk Allocation
(S-CDA) uses machine learning techniques, specifically K-
means clustering and decision tree classification, to predict
the load features (IOPS, disk bandwidth, etc.). S-CDA imple-
ments a multi-dimensional resource allocation policy based
on Manhattan distance to optimize resource utilization and
reduce load imbalance across warehouses. Doudali et al. [168]
introduced a page scheduler powered by machine intelligence
that can predict future page access. Specifically, they train
RNNs to recognize patterns in per-page access counts to
determine which pages should be periodically moved across
hybrid memory. Additionally, to address the large number
of pages and the resulting high overhead of RNNs, pages
that share the same pattern are clustered together. Pavan et
al. [169] proposed using unsupervised learning to characterize
the main I/O behaviors in HPC systems. Specifically, they
used traces to extract I/O phases — intervals with particular
I/O access patterns — and applied the K-means clustering
algorithm to group jobs with similar I/O behavior. Block-
Flex [170] is a storage harvesting framework that aims to
enable fine grained and efficient harvesting for both allocated
and unallocated storage. It uses the LSTM network for online
predictions at runtime of both storage demand and availability
in terms of storage capacity, bandwidth, and the time available
for harvesting. In [184], the authors proposed LinnOS, an
operating system that uses a lightweight neural network to
make a binary inference on each I/O operation (whether it is
fast or slow). Fast I/O are submitted to the flash device and
slow I/O are revoked and redirected to another node/device.
In [29], the authors used principal component analysis (PCA)
method to identify the key features of data access in cloud
storage systems. They use DBSCAN to group objects based
on the correlation of these key features, thereby automatically
discovering I/O characteristics and patterns.

E. I/O performance bottleneck attribution and optimization

Understanding I/O performance bottlenecks and attributing them to specific causes is a strategy for directing users to focus on fixing the bottlenecks. This is complimentary to tuning storage systems that was discussed in section 8.4. There have been several studies in this area, most of them focused on statistical analysis [185], [186], [187]. Another set of analysis methods used workload characterization using machine learning methods [171], [172], [174], [176], [177].
We will describe this set of papers that used ML for workload
analysis or performance tuning.

To identify features that impact parallel I/O performance
the most on HPC systems, Isakov et al. developed a data-
driven diagnostic tool called Gauge [171]. This tool analyzes
≈90,000 Darshan [183] logs collected on the Argonne Lead-
ership Computing Facility (ALCF) Theta system from 2017
to 2020 using hierarchical clustering (HDBSCAN) to group
similar I/O jobs to interpret I/O performance bottlenecks. To
interpret feature importance of various factors, i.e., volume of
I/O, number of read/write accesses, % of read/write accesses,
consecutive accesses, etc., this paper uses SHapley Additive
exPlanations (SHAP) value. The features that have the highest
positive or negative SHAP value meant to be the features
that have high impact on the I/O performance. However,
the performance prediction model used by Gauge is based
on the statistical average of groups of logs that have been
clustered. AIIO [172] on the other hand uses a multiple
ML algorithms to train I/O performance prediction models.
When a previously unseen Darshan log is analyzed with these
models, AIIO selects the most closely related model and
then computes SHAP value for the specific application log,
in contrast to Gauge's group of logs. AIIO uses CatBoost,
LightGBM, XGBoost, Multilayer perceptron (MLP), and At-
tentive Interpretable Tabular Learning (TabNet). AIIO uses
RMSE for the ML models during the training process and
RMSE for SHAP in evaluating local accuracy of regression.
With AIIO's approach to attribute I/O features that impact the
I/O performance using SHAP, the most negatively impacting
feature can be analyzed and fixed for better performance.

Another set of recent efforts proposed usage of founda-
tion models for diagnosing I/O performance problems. IO
Navigator (ION) [176] proposed using LLMs for studying
a Darshan log of an application to analyze I/O performance
and identify any bottlenecks. ION uses in-context learning,
chain-of-thought, and code generation capabilities of LLMs to
perform this analysis and to provide a diagnosis of potential
I/O issues. IOAgent [177] takes ION to the next level by
using Retrieval-Augmented Generation (RAG) to integrate
external information from knowledge bases, such as literature
in the field, prompts, etc. to fine tune and interact with users
regarding the I/O performance issues as well as potential
tuning options.

There are several efforts on automatically tuning I/O per-
formance using parameter search. For instance, Babak et al.
[173] used genetic algorithms (GA) to find tuning parameters
at each of the HPC storage layers, i.e., high-level I/O libraries,
parallel I/O middleware, and parallel file system. Because
each of these layers have numerous tuning parameters and
each of parameter has a large number of potential values,
the parameter search space becomes significantly large with
millions of configurations. Because exploring all these con-
figurations by empirically, i.e., by running an application,
measuring performance, and detecting the best performing
configuration, is impossible, Babak et al. have used GA to
prune the search space. To further reduce the time spend in
this search, they used a non-linear regression-based modeling
to find the top-K candidates to search. Agarwal et al. [174]

explored an online approach by using Bayesian Optimization
that had PreExec and PreAct strategies, where the former
tries execution-based evaluation and the latter with prediction-
based evaluation of parameter space. While these approaches
improved performance for known applications, I/O patterns
that were previously unseen still lacked optimizations. In
TunIO, Rajesh et al. [175] explored extracting previously
unseen I/O pattern and using Reinforcement Learning for
identifying parameter space. All these approaches used RMSE
or R² values for measuring the accuracy of performance
models, TunIO also proposed a new metric, called Return on
Tuning Investment (ROTI), which evaluated the cost of ML
method in improving performance. It is defined as the ratio
of performance improvement and the amount of time spent in
running ML method.

F. Workload characterization for other purposes

Understanding workloads and predicting I/O performance
on storage systems has also been a general practice in de-
signing new systems as well as optimizing the use of storage
devices. In this subsection, we group the usage of workload
characterization for other reasons that did not fit well in the
previous purposes.

Because SSDs lack support for in-place updates, requiring
an erase-then-write process, write amplification occurs when
the number of physical writes to the storage exceeds the
number of logical writes requested by the user. Reducing this
write amplification is crucial in extending the lifetime of flash
drives. Predicting the number of writes before a logical block
address (LBA) is overwritten and grouping LBAs with similar
death-times into the same block is an approach for reducing the
write amplification. To predict the death-times, Chakrabortii et
al. [178] proposes ML-DT that predicts death-times of LBAs
using temporal convolutional networks (TCNs). TCNs were
used to learn the spatial and temporal patterns in I/O write
accesses, enabling predictions of death-time ranges for LBAs.
The authors compared TCNs with LSTM, RF, and SVMs, and
showed TCNs outperform the others. The authors used ten
real-world workloads from sources like VDI, RocksDB, and
TPC-H (MonetDB), along with synthetic traces (sequential,
random, and mixed workloads). ML-DT consistently reduced
WA across all traces, achieving up to 14%. The training
time for one epoch ranged between 84 and 192 seconds,
depending on the trace dataset. Models were trained for 10
to 32 epochs until convergence. Inference cost is around 100
to 315 microseconds. ML-DT performs better on workloads
with skewed write patterns (e.g., VDI and RocksDB). For
workloads with more uniform distributions of LBAs (e.g.,
TPC-H), the performance improvement is less significant.
ML-DT needs maintaining metadata such as the death-time
counter, valid pages bitmap, and write pointer for each block.
Maintenance of these metadata could turn out to be extra
overhead.

Traditionally, storage services use heuristics to optimize
metrics such as cache hit rate and disk footprint. These
heuristics rely on statistical workload properties. In [23],
the authors argued that it is possible to use the high-level
information, which is already stored in systems in a distributed tracing framework, to predict future workloads. This can in turn empower decision-making with more accurate and up-to-date information. Specifically, the paper introduces an API for applications to generate traces of storage requests, called Census Tags. The paper demonstrates how these Tags can be used to predict inter-arrival times, file lifetimes, file sizes, and read/write fractions to improve storage system performance through intelligent caching, prefetching, and block allocation. The paper implements three models—including a lookup table, k-nearest neighbor (k-NN), and a neural network—and demonstrates that these models are robust to workload evolution and can provide greater accuracy than traditional non-machine learning approaches. The work focuses on two use cases, including caching and tiered storage.

HPC systems are shared by multiple users, each of whom runs different applications with various characteristics. The performance of these applications strongly depends on their characteristics and the underlying system configurations, especially the I/O stack. Given the large number of possible parameters (and values) and the growing diversity of HPC applications, finding the optimal configuration settings is difficult. Bang et al. [179] proposed using the K-Nearest Neighbor (KNN) prediction algorithm to group applications with similar I/O characteristics and build prediction models based on the clustering results to improve the accuracy of the I/O performance of HPC workloads. The prediction is offline and can be performed periodically.

## G. Discussion

In Table VI, we summarize the use of AI techniques, metrics, and workload traces used in various studies that performed workload characterization and I/O performance prediction. In the following we summarize the purposes, practicality, adaptability, and discuss the research gaps.

**RQ1: What is the reason behind the use of AI?** Workload characterization and data movement performance prediction has used AI/ML algorithms for a variety of purposes, which include interference and variability analysis, optimized data movement and placement in multi-tier memory/storage hierarchies, analysis of I/O behavior, and performance bottleneck analysis. These analyses led to optimizing energy consumption, scheduling data movement, designing storage systems, diagnosing I/O problems in applications, identifying groups of I/O patterns used on HPC systems, improving utilization of storage hardware, etc. These analysis were done with logs from HPC systems and cloud data centers. Most of these analyses perform better than previously used statistical approaches. In performance tuning, using AI improved the return on tuning investment (RoTI) significantly [175]. Recent methods [177], [176] are using foundation models for diagnosing I/O performance bottlenecks and tuning demonstrating progress in using the latest AI methods. In terms of I/O behavior analysis and attribution to scheduling, clustering algorithms are primarily used to group jobs, features, objects, and memory pages with similar patterns. This is a common approach to understanding I/O behavior in HPC systems and reducing

scheduling overhead. In addition, machine learning is used to automatically select key data access features, which can be complex and require excessive analysis given the large number of data access features and applications. Machine learning is rarely used for online prediction, as this was discussed in one paper. This paper [170] uses LSTM because of its low overhead and effectiveness in time-series predictions.

**RQ2: How is it implemented and how much does it cost?** Most of the workload characterization and prediction methods used offline analysis approach, where large sets of logs were collected and analyzed using ML algorithms. So the overhead is not discussed. An exception includes active learning [174], such as Reinforcement Learning (RL) and Bayesian Optimization strategies for learning the data access patterns to tune I/O parameters. BlockFlex [170] another exception that uses the LSTM network for online predictions of both storage demand and availability in terms of storage capacity, bandwidth, and the time available for harvesting. Another exception is [184], which can achieve high accuracy in real time by simply classifying each I/O operation as fast or slow. The training time is evaluated in [174], while the inference time, along with the cost in terms of CPU resources and memory space, is evaluated in [170], [184] as the prediction is applied to real-time optimization. For example, the lightweight neural network used in [184] has an inference overhead of 4-6 µs and consumes 0.3 to 0.7% of the host CPU resources. Usage of offline methods was reasonable when considering historical context of applications and the hardware usage needed to understand the workloads and performance estimations. When using LLMs for I/O performance bottleneck diagnosis [176], [177], LLM-based inference uses interactive prompts for combining RAG for finetuning responses. However, no quantitative analysis of the overhead of LLM inference is provided.

**RQ3: How adaptable is the solution?** Most of the workload characterization and performance prediction use logs and traces that have been collected over certain periods of time. In some cases, the logs are collected over a short period of time (online analysis) and also over long periods of time. For instance, Isakov et al. [171] use Darshan logs collected on a HPC system over 4 years. Most of the AI methods used are well-known for analyzing various types of logs. They are generally adaptable to different sets of I/O workload and performance logs. However, the AI training models and performance tuning options for I/O kernels are not highly adaptable as the options are interdependent and storage systems have significant performance variability. In most cases, AI methods focused on accuracy than explainability, which is a limitation of the existing methods. As a result the training models and tuning options need to be reconstructed each time new data is used limiting the reproducibility.

**RQ4: How are learning data managed?** In most studies we investigated in this section, traces were collected from systems (supercomputing, cloud, or data centers) or applications (logs from data center applications and Darshan logs from applications running on supercomputing systems). The logs have been collected over a few days to a few years. Some of the history of these logs have been used for training and part
<table><caption>TABLE VI
Summary of AI techniques and input datasets used in workload characterization and prediction.</caption><thead><tr><td>Purpose</td><td>AI Technique</td><td>Metrics</td><td>Workloads or traces used</td></tr></thead><tbody><tr><td>Interference and variability [39], [158], [159], [160], [161], [162], [163]</td><td>LightGBM and RF [39], GP [158], DFT [159], RF [160], [161], DT, MARS, AdaBoost, GBDT, Agglomerative hierarchical clustering [162], LM, MARS, TGP, BART, CGP [163]</td><td>MAPE [39], MSE and MLPD [158], relative error [159], R2 score and MAE [160], NRMSE[161], MAE AND RMSE [163]</td><td>FIU, MSR, and EMORYML [39], Production traces from Edison [158], IO traces from Alibaba Cloud and Tencent [160], Experimental Traces [161], I/O data set collected on Blue Waters [162], Experimental traces [163]</td></tr><tr><td>Data movement and placement [53], [164], [165], [166], [167]</td><td>LSTM [53], CNN [164], STSNN [165], n-gram [166], hierarchical clustering [167]</td><td>RMSE [53], file life time prediction [164], I/O hit rate [165], performance gain [166], file relevance [167]</td><td>Logs from MSR [53], file access logs, block access logs [165]</td></tr><tr><td>I/O behavior analysis and attribution to scheduling [24], [48], [29], [168], [169], [170], [184]</td><td>DBSCAN [48], k-means [24], PCA and DBSCAN [29], RNN [168], K-means [169], LSTM [170], LNN [184]</td><td>RMSE [48], [29], MAE [168], [29], accuracy [184]</td><td>Traces from Tencent data center [24], Experimental Traces [48], [29], I/O workload of Intrepid Blue Gene/P supercomputer [169]</td></tr><tr><td>Performance bottleneck attribution and optimization [171], [172], [173], [174], [175], [176], [177]</td><td>HDBSCAN, SHAP [171], MLP, CatBoost, LightGBM, XGBoost [172], LLM, RAG [176], [177], GA [173], BO [174], RL [175]</td><td>MSE, RMSE [171], [172], accuracy [173], [174], ROTI [175], response time [176], [177],</td><td>Darshan logs, I/O kernels (VPIC-IO, BD-CATS, and h5bench).</td></tr><tr><td>Other workload characterization [178], [23], [179]</td><td>KNN [179], TCN [178], k-nearest neighbor [23]</td><td>R-squared score [179], MSE [23]</td><td>TPC-H [178], Darshan logs [179]</td></tr></tbody></table>

of the logs have been used for verifying the trained models. Logs collected on cloud computing or data centers, such as Microsoft Research (MSR), Alibaba, and Tencent, have been available online. However, logs collected on supercomputing systems, e.g., Darshan logs, have not been made available to public. All these analysis performed on logs that are private are not reproducible.

In terms of reproducibility of the output of the AI models developed for applying on storage related optimizations and characterization, most of the models are not available for reuse. Almost all the models are not shared on any public repositories, such as Huggingface. There are a few studies that provided source code [171], however their reproducibility is limited because of limited availability of the logs. Some of the recent tools, such as AIIO [172] and LLM-based IO Agent [177] are providing online services that could be used for predicting performance, for characterizing I/O performance, and for identifying bottlenecks. While privacy and security concerns were not discussed in most of the papers, some of the logs released to public or those used in I/O behavior analysis, have been anonymized when they were released. This anonymization process consists of replacing the user names and application names with generic names, e.g., user_# and application_#. This prevents revealing any links to the supercomputing user identity.

# X. ANOMALY DETECTION FOR STORAGE SYSTEMS

## A. Introduction of Disk Failures and System-Level Anomalies

As the scale and complexity of storage systems continuously increases, failures become the norm rather than exception [188]. To address the grand challenge, great efforts have been made to model various failure events in the context of storage systems and handle them accordingly via AI techniques. We briefly introduce relevant concepts in this section, and elaborate on two main categories of research efforts in the following two subsections (§X-B and §X-C) respectively.

Based on the classic taxonomy by Avizienis et. al. [189], a failure can be defined as an event that occurs when the delivered service deviates from the correct service. While there are various types of failure in practice, the most heavily studied failure type in the context of storage systems is disk failures [35], [190], [191], [192], [193], [194], [36], [37], [195], [196], [197], [27], [198], [199], [200], [201], [202], [203], [204], [205], [206], [207], [208], [22], [209], [210], [52]. Based on the device type, there are two classes of disk failures:

* **HDD failures:** A typical hard-disk drive (HDD) consists of multiple components including magnetic storage media, mechanical (e.g., disk arm assembly) and electrical (e.g., buses) parts, on-drive cache and firmware, and a transport interface (e.g., SCSI, SATA) connecting the device to the host. Consequently, an HDD failure may be caused by various reasons including erroneous media (e.g., bit flips on magnetic surfaces), bad sectors scratched by the read/write head, inaccurate disk arm movements, power spikes damaging on-drive circuits, firmware bugs, unstable transport between device and host, etc [211], [35], [196].

* **SSD failures:** Different from conventional HDDs, modern solid-state drives (SSDs) are semiconductor devices that store data in NAND flash chips consisting of floating gate transistors. Since NAND flash can only be written at the page granularity (e.g., 4KB) and be erased in even larger blocks, SSDs using NAND flash have sophisticated firmware called a Flash Translation Layer (FTL) to make the device appear as if it can do in-place updates (see §VI-A), which is a reminiscent of the classic log-structured file system [212], [56], [57]. Due to the different internals, SSDs may exhibit more complicated failure modes compared to HDDs, such as metadata corruptions in FTL, unserializability (i.e., the final state of storage does not result from a serializable operation order), etc [213], [27], [22], [28], [214].
Since HDDs and SSDs serve as the foundation of most practical storage systems, a disk failure may lead to severe consequences such as system downtime or even permanent data loss if there is insufficient redundancy or fault tolerance (e.g., replication or erasure coding). Note that in large-scale storage systems, HDDs and SSDs may be deployed together on the same machine or cluster, which could potentially introduce more complicated failure modes. Due to the prime importance, it is not surprising to see that various AI models have been explored to predict disk failures in advance, which will be discussed in more details in §X-B.

Besides disks, a practical storage system typically includes other hardware (e.g., RAID controller [215]) and software (e.g., operating system kernels, parallel or distributed file systems) components, each of which may fail and lead to abnormal system behaviors. Interestingly, multiple terminologies have been used interchangeably by different researchers in the field to describe system-level abnormal behaviors (e.g., anomalies [31], [216], [217], [218], errors [51], and failures [28], [34]), probably due to the variety of components involved and the complexity of issues that may occur at the system level. Without loss of generality, we will use anomalies to refer to all kinds of system-level abnormal behaviors in the rest of this section for simplicity. The system-level anomalies can be roughly classified into the following classes based on the target systems:

*   **RAID system errors.** Redundant array of independent/inexpensive disks (RAID) is one classic way to provide high reliability and performance for data storage [215]. Unfortunately, with the rapid growth in complexity, RAID systems may also exhibit abnormal behaviors. For example, NetApp ONTAP is one representative enterprise storage system which consists of multiple RAID groups [51]. Such enterprise-grade RAID systems may generate up to 1,450 error events per day per system, which may involve various unique types of issues ranging from storage hardware, networking, built-in software stack, etc [51].

*   **DFS anomalies.** Parallel/Distributed file systems (DFS) are responsible for managing file data in a cluster of nodes and they may exhibit various abnormal behaviors at scale [218], [216], [31], [34]. For example, Hadoop file system (HDFS) may exhibit various anomalies including write exception at client, NameNode not updated after deleting a data block, replication monitor timeout, empty packet for blocks, etc [218]. Similarly, other parallel distributed file systems (e.g., Lustre, OrangeFS, GlusterFS) may experience abnormal events (e.g., metadata inconsistency) under various conditions and record diverse error messages in logs [31].

*   **Cloud storage failures.** Besides RAID and DFS, storage systems in cloud data centers typically involve additional software/hardware layers for managing data, which may generate various abnormal events in practice [28], [217]. For example, the fail-slow issue is gaining increasing attention recently [28]. It manifests as a system component delivering lower-than-expected performance but

still functioning, which can be caused by various reasons including buggy software scheduling, hardware defects, environmental factors (e.g., temperature and power), etc. as reported by researchers from Alibaba [28]. With more high-performance hardware (e.g., NVMe SSD) and advanced software features (e.g., kernel bypassing) being used in storage systems, it is expected that such fail-slow anomalies will have more significant impact on large-scale storage systems in the foreseeable future.

Note that the three classes of abnormal behaviors above are not exclusive. For example, DFS may be built atop of RAIDs and be affected by RAID errors [34], and cloud systems may include other storage services (e.g., NoSQL service [28]) which may affect the behavior of DFS. We will discuss the AI approaches for handling such complex system-level anomalies in details in §X-C.

## B. AI for Predicting Disk Failures

Given the fundamental role of disks in storage systems, great efforts have been made to predict disk failures in advance. The majority of studies build the AI models by leveraging attributes from SMART (Self-Monitoring, Analysis and Reporting Technology), which is an on-drive monitoring system supported by most HDDs/SSDs that reports on various indicators of drive health (e.g., count of read errors that could not be recovered by hardware ECC, count of reallocated sectors, power-on hours). We summarize representative studies on disk failure prediction from multiple dimensions below.

**Classic Techniques.** First, a variety of classic AI techniques have been applied to predict disk failures for replacement in advance. For example, [35] introduces a four-step methodology which includes a changepoint detection algorithm to identify the changes of SMART attributes, an encoding algorithm to generate compact representation of time series data for each disk, a RGF-based classification model to identify failure-impending drives, and a TL algorithm for prediction on data from new disk models. Based on the evaluation, this RGF-based approach may outperform other techniques including GBDT, RF, SVM, LR, and DT. Along the same lines, [190] introduces a HDD residual life prediction model based on GBRT. To address the “model aging” problem, which means the prediction effectiveness of offline models may degrade due to the distribution shift of cumulative SMART attributes, [192] introduces a disk failure prediction model using Online Random Forests (ORFs) to adapt to the variance of SMART attributes over time. [193] analyzes the internals of SSDs (e.g., proactive/reactive firmware functions) to derive important features for ML models, and shows that RF may outperform LR. Similarly, [194] finds that the drive age is the most important feature for SSD failure prediction and RF may outperform five other ML predictors. In addition, to improve training efficiency, LightGBM [203] and variants of DT [199] have also been applied for disk failure prediction.

**Deep Learning Techniques.** More recently, deep learning techniques have been explored too. For example, SPA [36] partitions SMART data via a sliding window and converts them into a 2D image-like representation, and introduces
a semi-supervised deep learning method which only uses samples from healthy disks to train a GANs-based model for predicting failures. AMENDER [37] introduces an attention-augmented deep architecture. It uses GRU networks, a variant of RNNs, to capture the long temporal dependencies from SMART data, and implements an attention mechanism to generate an attention distribution for the hidden states based on the differences between the healthy context vector and the current hidden state. HDDse [196] introduces a unified high dimensional disk state embeddings and uses a LSTM based network to learn the long-term behavior of disk healthy states for predicting failures of heterogeneous disks. Similarly, TCN and custom sequential networks and have been applied to capture the temporal characteristics of SMART data [204], [205].

**Hybrid Techniques.** Recognizing the tradeoffs of different AI models for different disk datasets, researchers have explored a combination of multiple models for disk failure prediction. For example, [197] implements four models (i.e., Bayes, RF, GBDT, and LSTM) and finds that no single model can always outperform others across all cases in their dataset. To address the limitation, it implements a hybrid model (i.e., CNN-LSTM) and demonstrates its effectiveness across different disk groups. Similarly, [202], [207], [206] explores ensemble learning with different models (e.g., Bayes, KNN, RF, LSTM, and LightGBM with GBDT/DART boosting) for improving failure prediction with different disk groups. In addition, to mitigate the inherent class imbalance problem, researchers have explored hybrid models based on healthy disks only (e.g., VAE and LSTM in [201], IF and AE in [27]) and applied transfer learning (e.g., TLDFP [198]) for failure prediction on different disk groups.

**Beyond SMART.** To improve the quality of SMART features, DFPE [195] performs a series of replacement tests to measure the importance of features for RF model-based prediction. Similarly, WEFR [200] proposes a ranking algorithm to rank learning features for five classic prediction approaches (Pearson correlation, Spearman correlation, J-index, RF, XG-Boost). SMOTE [209] uses an over-sampling technique to balance the SMART datasets across different disk groups and shows that it can improve the performance of multiple popular models (i.e., RF, XGBoost, LSTM and FFN). Moreover, researchers have explored other device characteristics beyond basic SMART data. For example, MVTRF [22] extracts multiple features (e.g., raw, histogram, sequences) to characterize SSD states from different dimensions and uses a variant of RF, i.e., learning different types of features with different sets of decision trees in parallel, and shows that MVTRF can outperform other models including vanilla RF, NN, AE, and LSTM on their dataset. APTN [52] identifies the NAND flash wear characteristics of SSDs as a critical indicator in addition to SMART data, and proposes a Pseudo Twin Network with two non-identical sub-networks (NN for SMART data, and LSTM for aging data) for SSD failure prediction. RL-watchdog [210] implements a lightweight watchdog to check SSD liveness by proactively issuing a customized NVMe command to the SSD, and applies Q-learning to predict the NVMe command latency online to detect SSD failures.

**Partial Failures.** In addition to whole-disk failures which necessitate replacement, partial-disk failures (e.g., individual sectors on a disk cannot be read) is another threat to storage reliability [191], [219], [208]. A variety of AI techniques have been explored to address partial failures too. For example, [191] explores five ML models (i.e., CART, RF, SVM, NN and LR) for predicting sector errors on HDDs and SSDs with high accuracy, and shows that predictors trained on one disk model may be used to predict errors on a different disk model. [219] further finds that XGBoost may achieve better performance compared to other models for capturing uncorrectable sector errors. Additionally, LightWarner [208] implements two reinforcement learning algorithms (i.e., SARSA and Q-learning) for predicting flash memory errors on six types of NAND flash chips accurately.

### C. AI for Handling System-Level Anomalies

As briefly mentioned in §X-A, system-level anomalies are diverse given the complexity of large-scale storage systems. To address the challenge, researchers typically leverage different system logs beyond disks' SMART attributes and apply various AI/ML techniques to detect the anomalies at (near) real time. We elaborate on three main classes of efforts below.

**RAID Systems.** First, in terms of RAID systems, one representative work is SEFEE [51] which analyzes 2-year error-event logs collected from NetApp ONTAP storage systems deployed in production. The target systems include 14,371 disks in 739 RAID groups in total, which contains 1,625 unique types of error events in the study period. Based on the key observation that there are complex spatio-temporal inter-dependency between error types and their locations, SEFEE takes the error-event logs as streaming input and constructs a tensor model of observed error events with multiple dimensions of information (i.e., error type, location, timestamp, severity). Based on the tensor model, SEFEE reconstructs the model matrix along the time dimension during runtime, predicts potential errors in the near future (e.g., 2 hours ahead), and updates the model matrix accordingly. In this way, SEFEE positions itself as a lightweight error forecasting method for RAID systems. And based on the evaluation, SEFEE is practical as it can proactively detect about 90% of anomalies that could result in potential data loss. On the other hand, SEFEE is closely tied to NetApp RAID systems as its tensor model is built based on the unique error patterns of NetApp systems. Overall, we notice that research at the RAID system level is relatively limited, probably because RAID systems are typically proprietary and the error event logs are too sensitive to be publicly available.

**Distributed File Systems.** Next, at the DFS layer, research efforts are relatively more abundant thanks to the wide adoption of open-source file systems (e.g., HDFS, Lustre) [218], [216], [31], [34]. One representative work is from Xu et. al. [218] which proposes a general four-step methodology that combines machine learning and information retrieval techniques to detect anomalies in large-scale systems including HDFS. One key observation is that the source code can serve as the "schema" of unstructured log messages to recover the
inherent structures and help derive useful features. Based on the key observation, the work applies static source code analysis to convert a log message to a data structure with message types and state variables, and constructs two feature vectors (i.e., state ratio vector and message count vector) by choosing appropriate variables and grouping related messages. Based on the extracted feature vectors, the work applies PCA to separate out repeating patterns in feature vectors and detect anomalies. To improve the PCA detection results, it further applies Term Frequency / Inverse Document Frequency (TF-IDF), a classic heuristic in information retrieval, to pre-process the feature vectors. Based on the evaluation with over 24 million lines of logs generated from a 203-node Hadoop cluster, the method can automatically discover many HDFS anomalies with low false positive rates.

Inspired by [218], multiple follow-up works have improved the anomaly detection of PFS/DFS further [216], [31], [34]. For example, DeepLog [216] uses LSTM to model system logs as natural language sequences. Each log entry from normal system executions is parsed into a log key and a parameter value vector, which are used to train a log key anomaly detection model and a parameter value anomaly detection model respectively. Based on the evaluation with the same HDFS dataset used in [218], DeepLog can achieve better overall performance. Another example along the direction is Drill [31], which analyzes the logs of multiple PFS/DFS (e.g., OrangeFS, CephFS, DAOS, GlusterFS) and leverages system-specific sentiment language models and contexts in the source code to generate high-quality feature vectors (i.e., sentiment features and context features) from runtime logs. The feature vectors are used to train a BiLSTM model which contains two layers with a total of 17K parameters. Experimental results on HDFS and Lustre datasets show that Drill is effective in detecting anomalies in both file systems. In addition, Kaleidoscope [34] introduces a near real-time anomaly detection framework for the Cray Sonexion storage subsystem of Blue Waters supercomputer, which uses Lustre to manage data and metadata servers on RAID devices. It consists of two domain-guided models: (1) a failure localization model which uses PGM to describe the statistical dependence between various Lustre components (e.g., data servers, metadata servers) and the I/O path tracing data, and (2) a failure diagnosis model which uses an LOF [220] to identify the root cause of anomalies observed.

**Cloud Storage Systems.** Finally, in the context of Cloud data centers, anomaly detection is also important [28], [217]. For example, PERSEUS [28] analyzes the characteristics of fail-slow incidents in Alibaba data centers and proposes a four-step detection method. The input of PERSEUS is a time-series dataset continuously collected from Alibaba cloud storage systems. To detect fail-slow events, PERSEUS first uses a combination of PCA and DBSCAN to exclude outliers from the raw log entries, and then builds a polynomial regression model based on the clean dataset to establish a mapping between latency variation and workload pressure. Based on the regression model, it uses a sliding window and a slowdown ratio to identify fail-slow events as well as the severity with a risk-score mechanism. Based on the evaluation,

PERSEUS can achieve high precision and recall on production systems, outperforming previous methods. Notably, PERSEUS assembles and releases a large-scale fail-slow dataset from production traces to facilitate follow-up research. Similarly, LogLens [217] provides a generic framework for anomaly detection based on data center logs. It classifies anomalies into two categories: stateless (i.e., detectable via a single log entry) and stateful (i.e., involve a log sequence with multiple entries). For stateless anomaly detection, it parses logs into GROK patterns [221] and cluster similar logs using LogMine algorithm [222]. For stateful anomaly detection, it further leverages a variant of the Apriori algorithm [223] for building the model. LogLens has been applied to six different datasets collected from data centers, including storage servers, OpenStack, etc.

## D. Discussion

We summarize the main techniques used for anomaly detection in Table VII, and discuss a few key research questions further in this section.

**RQ1: What is the reason behind the use of AI?** As briefly discussed in §X-A, storage failures is a practical problem in large data centers today. For example, both HDD and SSD may fail completely or partially due to various reasons including accumulation of sector errors, firmware bugs, unstable transport, etc. Similarly, storage systems building on top of HDD/SSD (e.g., RAID, DFS, and cloud storage) may also exhibit abnormal behaviors due to software bugs, misconfigurations, etc. To address the issue, a series of reactive fault tolerance mechanisms (e.g., replication, erasure coding) have been introduced to production systems. But unfortunately, such passive protection mechanisms may lead to recovery overheads and thus affect the cost and tail latency of storage systems [52]. Moreover, the protection and recovery mechanisms may also fail and lead to cascading damage in practice. Therefore, it is important to address the challenge proactively. In this context, researchers have explored various AI techniques to predict failures of storage systems in advance or detect anomalies timely to avoid performance instability, system downtime, or data loss.

**RQ2: How is it implemented and how much does it cost?** The majority of work surveyed in this category use trace-based experimentation without integration with real storage systems, probably due to the complexity of system integration which may involve non-trivial engineering efforts including intercepting system events at different levels, triggering corresponding failure handling routines, mitigating false positives, etc. Therefore, the practical cost (e.g., runtime overhead) of them is relatively unclear. On the other hand, a few works explicitly cover deployment in the context of real systems. For example, [35] notably discusses how to integrate their predictive disk replacement model in a RAID array by signaling the disk with impending failure, triggering the mirroring process on the spare disk, and finally replacing the unhealthy disk with the healthy mirror. But unfortunately, there is no actual implementation with a real RAID system for quantitative cost measurement in [35]. Most recently, a few techniques
<table><caption>TABLE VII
Summary of AI techniques and input datasets for anomaly detection.</caption><thead><tr><th>Problem</th><th>AI Technique</th><th>Input Type</th><th>Public Dataset</th></tr></thead><tbody><tr><td>HDD Failures</td><td>RGF [35], GBRT [190], CART [191], RF [191], [192], [195], SVM [191], NN [191], LR [191], GAN [36], GRU [37], CNN [197], LSTM [197], TrAdaBoost [198], DT [199], XGBoost [219], LightGBM [203], TCN [205]</td><td>SMART [35], [190], [191], [192], [36], [37], [195], [196], [197], [198], [199], [204], Performance Metrics [197]</td><td>Backblaze [35], [191], [192], [36], [37], [195], [196], [198], [199], [204], Baidu [195]</td></tr><tr><td>SSD Failures</td><td>RF [191], [193], [194], [200], [202], [206], [209], SVM [191], [194], NN [191], [204], [52], LR [191], [194], CART [191], KNN [194], [202], DT [194], [199], [22], IF [27], TrAdaBoost [198], XGBoost [200], [209], AE [27], VAE [201], Bayes [202], GBDT [202], LSTM [201], [202], [207], [209], [52], LightGBM [206], SARSA [208], Q-Learning [208], [210], FFN [209]</td><td>SMART [52], [22], NVMe latency [210], Firmware functions [193], customized attributes [194], [52], [22]</td><td>Backblaze [198], [199], [204], Alibaba [200], [22], [209]</td></tr><tr><td>RAID errors</td><td>custom tensor model [51]</td><td>NetApp ONTAP logs [51]</td><td>N/A</td></tr><tr><td>DFS Anomalies</td><td>PCA [218], LSTM [216], BiLSTM [31], PGM [34], LOF [34], NLP [31]</td><td>HDFS logs [218], [216], [31], Lustre logs [34], [31]</td><td>HDFS [218], [216], [31]</td></tr><tr><td>Cloud Failures</td><td>Apriori [217], PCA [28], DBSCAN [28]</td><td>Alibaba cloud logs [28], customized logs [217]</td><td>Alibaba [28]</td></tr></tbody></table>

have been deployed in real systems and demonstrated the practicality. For example, the fail-slow detection framework has been deployed at Alibaba cloud [28] with low overhead (e.g., 0.21±0.14 seconds per-node execution time as measured in their environment), which demonstrates the promising direction of applying AI techniques in real production systems at scale.

**RQ3: How adaptable is the solution?** In terms of disk failure prediction, the majority of AI models (e.g., [35], [190], [191], [192], [36], [37], [195], [196], [197], [198], [199], [204]) are built based on the standard SMART attributes which are provided by all major disk manufacturers, so the techniques are largely adaptable across disks from different vendors. On the other hand, some AI models are highly customized for proprietary attributes [194], [52], [22], so the adaptability of them for the general disk population is relatively less clear. Also, we notice that compared to the traditional HDD failure prediction techniques, more input types (e.g., NVMe command latency [210], firmware functions [193], non-standard attributes [194], [52], [22]) beyond the traditional SMART attributes have been considered for SSD failure prediction, which suggests that purely SMART-based models might not be sufficient or optimal for predicting complex SSD failures [210], [193], [194], [52], [22]. That said, some techniques have been designed and evaluated for both HDDs and SSDs (e.g., [198], [199]) which suggests their adaptability. In terms of system-level anomalies (i.e., RAID, DFS, and Cloud failures), the solutions are typically highly customized based on the unique features or patterns of the logs of the target systems. For example, [31] shows that the AI models designed for HDFS (e.g., [218], [216]) may not work well for Lustre due to the irregularity of Lustre logs [31]. To address the limitation, [31] combines sentiment analysis in NLP with non-AI techniques (e.g., static code analysis) to derive more effective features, which makes the overall solution relatively more effective and adaptable for handling the complexity caused by log irregularity. In terms of

reproducibility, few papers explicitly discussed this property, partially because the proprietary nature of datasets or systems (e.g., [193], [51]). In addition, we notice that a few papers took one step further to explain the root causes of failures (e.g., [28], [22]), but there is little discussion on the explainability of AI models in general.

**RQ4: How are learning data managed?** While some works rely on proprietary datasets (e.g., NetApp ONTAP logs [51]) for building their models, the majority of the work in this category leverages publicly available dataset for learning. For example, Backblaze has curated and published a large collection of disk failures (including both HDD and SSD failures) and associated SMART attributes in their data centers since 2013. The dataset is well-maintained and documented and has enabled many failure prediction works in this survey (e.g., [35], [191], [192], [36], [37], [195], [196], [197], [198], [199], [204]). More recently, a few industry leaders have also released datasets from production systems publicly for the community (e.g., Alibaba [28]). On the other hand, we notice that in general there is little discussion in terms of privacy and security of data management in the papers surveyed.

## XI. RQ5: WHAT IS MISSING IN AI FOR STORAGE - DISCUSSION AND FUTURE DIRECTIONS:

As discussed throughout the different sections of this survey, a significant body of work has been done on the application of AI/ML for storage optimization at different levels of the storage stack and with different models and methods.

This section discusses blind spots we identified on the different topics surveyed and challenges still to be covered. It is organized in two parts: the first one discusses issues specifically related to the use of AI/ML in the surveyed papers, and the second one explores new venues, not yet fully explored, for storage optimizations thanks to AI/ML.