Fast and Actionable Classification of HPC I/O Time Series

arXiv:2611.09646v1 [cs.DC] 6 Nov 2026

Fast and Actionable Classification of HPC I/O Time Series Maxime Gonthier

Luan Teylo

Francesco Antici

Inria France maxime.gonthier@inria.fr

Inria France luan.teylo@inria.fr

RIKEN Center for Computational Science Japan francesco.antici@riken.jp

Mihail Popov

Francieli Boito

Inria France mihail.popov@inria.fr

University of Bordeaux, Inria France francieli.zanon-boito@u-bordeaux.fr

Abstract—Input/output (I/O) is a major bottleneck for highperformance computing (HPC) performance. One of the challenges is the contention between jobs when sharing the parallel file system. However, tackling this issue depends on knowing the temporal behavior of jobs. In this paper, we propose a clusteringbased approach to characterize jobs’ temporal I/O behavior. We propose SAGE, a lightweight method that cuts I/O traces into short windows and learns an alphabet from them. The trace then becomes a sequence of symbols, which we call “genome”, and we use clustering to separate them into classes. We evaluate SAGE and its two-stage variant SAGE-2 on 819,771 real traces from 2 HPC systems. We compare them against other techniques from the state of the art on three metrics, including one we propose. Compared to K-shape, the best baseline available, SAGE-2 lowers the median intra-cluster metrics by 9.1% on average, and achieves this in 2 minutes of clustering time versus 3.8 hours, a 109× speedup. More importantly, clusters created by SAGE and SAGE2 carry enough information to act on: we evaluate the use of the cluster centroids for I/O scheduling, and show that our approach can decrease I/O stretch by up to 24% compared to the state of the art (round-robin placement). Index Terms—high-performance computing, parallel I/O, workload characterization, temporal I/O behavior, clustering

I. I NTRODUCTION High-performance computing (HPC) systems typically rely on a parallel file system (PFS) (such as BeeGFS [1] and Lustre [2]) to enable access to persistent data from system resources. The PFS is shared among all the running jobs, and concurrent I/O can create interference [3]–[5], which degrades application performance. Depending on their characteristics, some applications impose a heavier slowdown on the others, and executing certain operations together may even lead to degradation of overall system performance [4], [6], [7]. Measurements on a production supercomputer show this effect [8]: as I/O concurrency increases, contention causes system performance to decline. Interference leads to a waste of expensive, power-hungry compute resources, which are often idle while waiting for I/O to finish, especially when the system performance is impacted. Moreover, interference causes high performance variability [9]–[11], which complicates resource

management and performance explainability, as application performance depends not only on its operations, but also on the behavior of other applications. I/O scheduling approaches have been proposed to alleviate this problem [5], [12]–[15]. They explore techniques such as delaying job start times [13], [15], preventing concurrent I/O activity of specific jobs [5], [12], [14] and assigning priorities [5]. However, for those techniques to work, they require the knowledge (or, rather, the prediction) of when jobs issue I/O requests. In this paper, we work to provide this information without depending on assumptions about job behavior, such as periodicity [13], [16]. We argue against trying to predict the exact temporal behavior for all jobs, but rather to classify them. Indeed, the exact temporal I/O behavior of a job is difficult to predict and likely to change across executions, as it is impacted by performance variability and I/O interference. Moreover, related work [8] has indicated that a relatively small number of patterns can represent most HPC jobs. A scheduling algorithm could use the general behavior of such classes as proxies for job behavior in order to mitigate interference. Finally, such a classification would add great value to the community, allowing for studies of the temporal behavior of HPC applications. Such a classification also allows for properly representing a system’s workload when creating benchmarks, for example, allowing for more realistic evaluation of new proposals. In this paper, we extensively study the problem of clustering1 I/O behavior and present a use case of I/O scheduling that uses our classification to improve I/O performance by mitigating interference. Our main contributions are as follows. •

We propose two techniques, namely Shape-Amplitude Genome (SAGE) and SAGE-2, which rely on a clustering-based encoding of I/O time series that learns an alphabet from short windows, categorizing them by shape and amplitude.

1 We use the terms cluster and class interchangeably throughout the paper.

II. M OTIVATION In this paper we focus on classifying the I/O operations of production jobs to perform informed job scheduling and prevent interference. To achieve so, it is fundamental to thoroughly characterize job executions (e.g. phases, minimum, peaks, idle). This can be achieved by leveraging time series of I/O activity collected periodically during job execution. However, characterizing and clustering such data comes with notorious difficulties. a) Clustering I/O time series is challenging: There are many techniques to cluster time series, but they rely on a certain quality of the signal in order to properly discriminate different behaviors [17]. I/O bandwidth over time has a lot of zeroes, values span multiple orders of magnitude [10], [11], and tend to be bursty [18]. Moreover, job duration varies immensely, creating time series of different lengths [8]. Fig. 1a compares the signal-to-noise ratio of our I/O traces with that of data sets commonly used to evaluate clustering2 . We can observe that I/O time series have the second worst signal-tonoise ratio. It sits just above seismic activity, which is known to be very noisy. This makes I/O traces3 difficult to analyze and extract patterns from. b) Typical techniques fall short: Fig. 1b shows one of the clusters created by K-means for the System A data set. We can see the jobs were placed together because of their similar average performance, with their lines presenting very 2 Pulled from [19]: Heartbeat audio [20], Seismic activity [21], Pedestrian traffic [22], Sleep brain activity [23], [24]. 3 Throughout this paper, we use “traces” or “jobs” to refer to I/O time series.

Sleep brain activity

Pedestrian traffic

−10

Bandwidth (MiB/s)

0

Seismic activity

10

Heartbeat audio

20

System A I/O

Signal-to-Noise Ratio (dB)

We introduce Phase-Level Distance (PLD), a noiseresistant metric that captures both amplitude and temporal shape differences. • Our extensive evaluation includes approaches from the state of the art, namely K-means, K-shape, Tsfresh, and K-means(DTW) as well as multiple metrics. It is based on real data sets from 2 systems, comprising 819,771 read and write traces, and shows that SAGE and SAGE2 improve clustering quality results over the state of the art, while also being on average 54× faster. • We show the usefulness of our classification by evaluating an I/O scheduling algorithm that takes the classes’ behaviors into consideration for placing jobs on distributed PFS resources. Our results show that we decrease I/O stretch by up to 24% compared to the state of the art (roundrobin placement). • We create and publicly release a data set containing the I/O traces of 108,433 HPC jobs in order to support further work in this field. The paper is organized as follows. Section III discusses related work. We present SAGE and SAGE-2 in Section IV. Section V describes the baselines and the data sets used in our experiments. Section VI evaluates the quality of the resulting clusters. Section VII uses these clusters to co-schedule jobs in a simulated system. •

10000 8000 6000 4000 2000 0

0

25 50 75 100 Fraction of trace duration (%)

(a) Signal-to-noise ratio of the (b) One of the clusters created by System Aa I/O time series and of K-means for the System A data four data sets commonly used to set. The centroid is shown in blue, and the gray lines show a random evaluate clustering algorithms. selection of 100 jobs that belong a Machine names in blue were to this cluster. omitted for double-blind review.

Fig. 1: I/O traces are noisy, and typical clustering techniques group them poorly.

different shapes. That means this classification is not useful for knowing when I/O will happen. In this same classification, K-means created 11 clusters, but assigned 64% of the jobs to just two of them. Section VI provides further examples of how existing techniques fail for I/O time series. c) Classifying temporal I/O behavior is useful: Fig. 2 previews results obtained with an I/O scheduling algorithm that uses jobs’ clusters to avoid interference, discussed in Section VII. The algorithm places jobs on PFS resources, trying not to place together jobs that will do I/O at the same time, and using cluster centroids as proxies for job behavior. The plot shows the geometric mean I/O stretch, i.e., the slowdown experienced by a job when sharing the system with other jobs. We compare round-robin placement, Clairvoyant (which knows the jobs’ exact time series), and results obtained using clusters generated by different techniques. We can see that, by taking temporal behavior into consideration, SAGE and SAGE-2 decrease I/O stretch by up to 24% compared to round-robin placement. III. R ELATED W ORK Related work tackles the I/O performance improvement by characterizing jobs’ I/O behavior [5], [12]–[15]. Tarraf et al. [16] characterize periodic I/O using frequency techniques. Omnisc’IO [25] builds a grammar of function called by the code, and uses it to predict future I/O activity. A popular strategy is to apply supervised machine learning techniques [26]– [31]. Unsupervised clustering is also used to classify jobs by energy consumption [32], performance [31], failures [33], and combinations of multiple metrics [34]. Bang et al. [35] combine logs from different layers of the I/O stack and extract summary features before clustering the jobs using K-means. AIOT [36] extracts I/O phases from traces using Discrete Wavelet Transform and clusters jobs based on metrics obtained from their I/O phases, such as peak bandwidth. In contrast, our technique keeps the time series format, instead of summarizing it by metrics, because we are interested in characterizing the temporal I/O behavior.

1.5

2.44 1.97

2.36 2.20

2.11 1.73

Write

1.95 1.71

1.95 1.81

2.0

1.57 1.32

2.5

2.38 2.26

I/O stretch (geo. mean)

Read

1.0

e ) 2 E in ns nt W Eap ob ea ya SAG AG s(DT K-sh K-m d-r irvo S n a a Cl me K-

n ou

R

Fig. 2: Results of an I/O scheduling algorithm using job clustering. We plot the geometric mean I/O stretch, i.e., the slowdown experienced by jobs due to sharing I/O resources. We compare the round-robin placement baseline, different clustering techniques, and a fictitious Clairvoyant solution that knows the actual I/O time series of every job. Workloads of 80 jobs on 4 object storage targets (OSTs) with a storage load ρ = 1 (see Section VII-C). Solid bars use the read traces from System A, and hatched bars the write traces. We later show that the clustering of K-means(DTW) is on average 63× slower than that of SAGE (Table I). Betke and Kunkel [37] cluster one million jobs by encoding time series of I/O statistics into features and applying the Levenshtein distance as a similarity metric. They use more information than we do, encoding per-node data and metadata activity into a single time series. In contrast, we classify one metric at a time. The idea is that a job would belong to different classes regarding its read/write/metadata activity over time. Our classification thus provides information that is readily exploitable by optimization techniques. As discussed, we focus on being able to tell when I/O happens. To process the large number of traces, Betke and Kunkel i) randomly select a small subset for clustering, ii) train a classification model to predict classes of jobs, and iii) use the model to classify the rest of the data set. They also compress the traces to the granularity of tens of minutes. We were not faced with this issue, and one of the reasons is that SAGE is faster than most other techniques, as shown in Section VI. Moreover, our clustering-based encoding achieves compression without sacrificing details. Boito et al. [8] use K-means (with Dynamic Time Warping (DTW), as a distance metric) for clustering I/O time series to identify common behaviors. They separate the traces by length and peak performance, apply clustering on each group separately, and then merge the identified clusters by hand. In this paper, we propose an automatic approach, with no manual input. Another important difference is that their classification focuses more on the shape, as they merge classes from different amplitudes, while we work to keep both shape and amplitude, as they are both important for I/O scheduling. Once workloads are characterized, a common practice is to infer a job’s I/O profile (e.g., its cluster) from the history of the user/group/project [27], [28], [30], [36], [38]. Yazdani

et al. [38] propose an I/O profiling tool based on past user activity and user-provided information. AIOT [36] builds a sequence of clusters by the same user, project, and scale, and uses a neural network to predict the next cluster. There is evidence in the literature for I/O behavior being somewhat stable for the same user/group/project [8], [36], [39], and we can reasonably assume that predicting a class will be easier than predicting an exact time series, evidencing the importance of our contribution in this paper. Predicting classes for jobs will be the focus of our future work. IV. T RANSLATING T RACES INTO “G ENOMES ” AND C LUSTERING T HEM WITH SAGE The goal of Shape-Amplitude Genome (SAGE) is to group jobs according to both when they perform I/O during their execution and what their I/O profile looks like. This will, for example, help a scheduler avoid placing jobs that perform I/O at the same time. As shown in Section II, this is challenging because I/O traces are noisy and their bandwidth spans several orders of magnitude. The key intuition behind SAGE is that, although each trace is unique as a whole, its short segments are not. Similar patterns, such as brief I/O bursts, recur both within and across traces. SAGE learns these patterns once from windows extracted from all traces and assigns each pattern a symbol, much like a genome is represented using a small alphabet. Each trace is then translated into a sequence of these symbols. Replacing each window with a symbol also filters out much of the noise and produces a representation that is considerably shorter than the original trace, making subsequent clustering faster. SAGE therefore consists of three steps (see Fig. 3): learning the alphabet, translating each trace using this alphabet, and clustering the resulting representations. A. Alphabet Learning SAGE first learns an alphabet from the set of traces. The goal of this stage is to identify recurring I/O patterns. We therefore pool all traces from the data set and divide them into non-overlapping windows of W consecutive samples. We use W = 5, which gives the best results on System A (Fig. 4). Clustering techniques combine shape and amplitude, allowing one to potentially dominate the other. To avoid this, we distinguish for each window: its shape, which captures the temporal variation of its I/O activity, and its amplitude, which captures its absolute bandwidth level. The alphabet is therefore learned in two stages, as illustrated in Fig. 3 (left). a) Shape clustering: The goal is to ensure that windows with the same up-and-down pattern are assigned to the same shape cluster. To do so, we first z-normalize each window by subtracting its mean and dividing by its standard deviation, removing differences in absolute level and scale. We then compute the differences between consecutive points to get the shape vector of the window. Z-normalization removes the absolute scale of a window, so the same pattern at 1 MiB/s and 1 GiB/s produces the same shape vector. Consequently, two windows are considered similar when their I/O activity rises

1. Alphabet learning

2. Genome translation

3. Clustering

cut all traces into windows of length W

each window mapped to its nearest symbol

genome of every trace A2 B3 A3 Z1 B2 . . . B1 B2 B2 A1 A1 . . .

shape: k-means on z-normalized differences

normalization to L symbols

→

A2

A

B

amplitude: k-means on raw bandwidth

amplitude: k-means on raw bandwidth

A1

B1

A2

A3

B2

B3

B3

SAGE each symbol becomes its similarity distance to the alphabet

A3

A1 0.97 0.71 0.90 A2 1.00 0.79 0.96 genome A2 B3 A3 . . .

SAGE-2 similarity distance on letters only A 1.00 0.42 1.00 B 0.42 1.00 0.42 C 0.65 0.58 0.65 letters A B A ...

or

→ k-means: clusters α, β, ...

→ k-means on vectors

A2 B3 A3 the genome of the trace

Alphabet + Z1 for a window with no I/O

then k-means on the numbers

cluster α

α1

α2

cluster β ...

β1 ...

β2

Fig. 3: SAGE workflow. The alphabet learning pools windows of length W from all traces and infer an alphabet based on their shape (letters) and amplitude (numbers). The genome translation translates each trace into a sequence of symbols from the alphabet. The clustering normalizes every genome to L symbols and replaces each symbol by how close it is to the others, then simply clusters the traces (SAGE), or clusters them first on the letters and then on the numbers (bandwidth levels) inside each shape cluster (SAGE-2). SAGE-2 clusters are named with a Greek letter and a level (for instance α1), so a cluster is never confused with an alphabet symbol (like A1).

10000

4000 2000 0

0.2

0.4 0.6 Aggregate Score

0.8

1.0

Fig. 4: Aggregate score (see Section VI-A) for SAGE-2 with three W values. Write traces of System A. Higher is better. and falls at the same time steps, rather than simply reaching similar values. We then cluster (K-means) the shape vectors. We select the number of clusters between 2 and 50 using an elbow search based on the Kneedle [40] algorithm. b) Amplitude clustering: Within each shape cluster, we apply a second clustering step to distinguish windows with different amplitude levels. The number of amplitude subclusters is selected using an elbow search over all windows and is shared across all shape clusters. The amplitude subclusters are labeled with numbers, and a higher number always means a higher bandwidth within the letter, as illustrated by B2, B3, and B5 in Fig. 5. The amplitude centroids are learned independently for each shape. Thus, A3 and H3, for example, both denote the third amplitude level of their respective shapes, but they do not necessarily correspond to the same absolute bandwidth. A window without any I/O activity is assigned the symbol Z1. The resulting set of letter-number pairs (that we call symbols) constitutes the learned alphabet. B. Genome Translation To represent each trace as a sequence of recurring I/O patterns, we translate it window by window, first identifying

0

1

2 Timesteps (windowed)

3

0

4

0

1000

2 Timesteps (windowed)

3

B2 0

1

2 Timesteps (windowed)

3

4

4000

F3 0

1

2 Timesteps (windowed)

3

4

1

2 Timesteps (windowed)

3

4

30000

6000 4000

0

6000

0

4

8000

2000

8000

2000

1

10000

1500

0

2000

H3

2000

500

4000

A3

2500 Bandwidth (MiB/s)

0.0

Bandwidth (MiB/s)

6000

6000

Bandwidth (MiB/s)

0.29

8000

Bandwidth (MiB/s)

0.47

Bandwidth (MiB/s)

10000

0.88

Bandwidth (MiB/s)

5 s windows 10 s windows 20 s windows

20000 15000 10000 5000

B3 0

25000

1

2 Timesteps (windowed)

3

4

0

B5 0

Fig. 5: Example of an alphabet built by SAGE. Top row: three shapes (A, H, F), each at its third amplitude level. Bottom row: shape B at levels 2, 3 and 5. The y-axes are all different.

the nearest shape centroid and then the nearest amplitude centroid within that shape, as illustrated in Fig. 3 (middle). The time-ordered sequence of symbols obtained from a trace is what we call its “genome”. The “genome” provides a lightweight representation of the original trace while preserving the recurrence and temporal ordering of its local patterns. C. Clustering Finally, we create clusters from the genomes (right of Fig. 3). The intuition is that two jobs with similar I/O profiles should have genomes containing similar symbols at similar relative positions. We therefore compare genomes position by position. For this comparison to be meaningful, genomes must have the same length, motivating the normalization step. In addition, directly comparing symbols would treat all distinct symbols as equally different. We therefore represent each symbol by a vector of its similarities to the other symbols.

2000

cluster α3

1000 0 7000

cluster β3

3500 0

Bandwidth (MiB/s)

Because our symbols encode both shape and amplitude, we propose two variants. SAGE clusters genomes in a single step using the full symbols (so letters and numbers). This representation primarily groups jobs according to when and with which shape they perform I/O, while amplitude has a smaller influence. SAGE-2 instead first groups jobs according to the shapes in their genomes and then splits each shape group by amplitude level. SAGE-2 clusters are therefore able to capture both when a job performs I/O and at which bandwidth, but at the cost of producing more clusters, some of which may be very similar. a) Normalization: The genome length is normalized to L symbols. A genome of n ≤ L symbols is stretched to L symbols by nearest-neighbor interpolation, so each of its symbols is repeated about L/n times. The ordering of the symbols is preserved, so symbol si at the i-th position will be at the i×L n -th position of the genome. That way, we capture the proportion of a job’s duration that had elapsed before a given symbol. For instance, the genome A2 B3 B3 A3 brought to L = 8 positions becomes A2 A2 B3 B3 B3 B3 A3 A3. A longer genome is split into L bins of equal length. For each bin, the centroids of its symbols are concatenated and resampled to W points by interpolation. The bin is then given the closest symbol from the alphabet. b) Similarity vectors: With the default clustering distances, every pair of distinct symbols would be at the same distance, so A1 and A2 would be as distant as A1 and K3 for example. Instead, we replace each symbol si by a vector that encodes how close it is to every other symbol, and these vectors are then used for clustering as explained below. c) SAGE clustering: The similarity of two symbols, Simsi ,sj , is the cosine similarity of their centroids. Z1 is similar to no other symbol. Each symbol of each genome is replaced by the vector of its similarities to all other symbols of the alphabet. For instance, as shown in Fig. 3, A2 becomes (SimA2,A1 = 0.97, SimA2,A2 = 1, ...). A final clustering step (K-means with the elbow method) gives the clusters for SAGE. d) SAGE-2 clustering: SAGE-2 runs the clustering step twice, first on shape and then on amplitude, like alphabet learning does for windows. In the first stage, we cluster the genomes, but we only keep the letters of the symbols, so A1, A2, A3, . . . all become A. Each letter is replaced by the vector of its similarities to other letters, computed between the shape centroids, so two letters with a similar up-and-down pattern are close in similarity. In the second stage, we cluster the genomes from each shape cluster by keeping only the numbers, and each number n is replaced by a vector of n − 1 ones followed by zeros. We choose to do this because, since Kmeans uses the squared Euclidean distance, using the numbers directly would square their difference. To avoid this, we build vectors that represent linear distances. For example, with three amplitude levels, 1 becomes (0, 0, 0), 2 becomes (1, 0, 0) and 3 becomes (1, 1, 0), so 1 and 3 are at squared distance 2. The final clusters are named with a Greek letter for the shape and a number for the level, for instance α2 for the second amplitude cluster of shape cluster α.

1000 500 0 9000

cluster γ3

4500

cluster δ3

0 9000

cluster 3

4500 0 3000

cluster ζ3

1500 0 9000

cluster η3

4500 0

0

20

40

60

80

100

Fraction of trace duration (%)

Fig. 6: Centroids of the level-3 clusters built by SAGE-2 on the System A write traces. Only level 3 of each shape cluster is shown, for readability.

If a cluster has fewer than five traces, it is merged with the cluster that has the closest centroid (for SAGE-2, the closest within the same shape class). Note that our approach uses Kmeans for clustering, with the Euclidean distance for comparisons and the elbow method to select the number of clusters. Nonetheless, SAGE is not specific to these techniques, and other clustering techniques could be applied to the workflow depicted in Fig. 3. D. SAGE in Practice Fig. 6 shows the level-3 clusters that SAGE-2 builds from the System A write traces. β3 writes throughout the run, ϵ3 at the end, δ3 at the beginning and in the middle, and ζ3 writes more and more as the job progresses. A scheduler can, for example, use this to allocate jobs that write at the same moment to different I/O resources. Time series of I/O activity (read/write/metadata) over time can be collected by a profiling tool such as Darshan [41], [42], Recorder [43], or an online collection tool such as TOTO [44]. SAGE can be used periodically to identify/update the classes. A job will belong to multiple classes, one for each metric being monitored (write/read/etc.). Then, at execution time, a trace from a previous execution of the same application could be used to find its class [15], [45], or one could predict its class from job submission information [36] and/or from a partial time series [37]. Then, an I/O scheduler can use the classes’ and jobs’ information to make decisions (either online or offline). We plan on studying the prediction of classes as future work, since our focus here is clustering I/O time series. V. BASELINES AND W ORKLOAD This section describes the clustering techniques and the data sets we use. Both serve the clustering quality evaluation of Section VI and the scheduling use case of Section VII.

A. Clustering Baselines We implement SAGE in Python with scikit-learn, and compare it to other commonly used techniques. All of them except Tsfresh first resample each trace to L points by linear interpolation (L = 300 by default; Section VI-D shows that L has little impact). As for SAGE (Section IV-C), we merge every cluster of fewer than five traces into the cluster with the closest centroid, so that a single outlier does not form a cluster of its own. a) K-means: combined with the Euclidean distance to compare the points, is widely used for clustering I/O information in HPC [34], [35], [37], [46], [47]. We used the elbow method to select the number of clusters between 2 and 50, using the Kneedle algorithm [40], [48]. b) K-shape: is another clustering algorithm [49], [50] that aims at optimizing a distance metric called SBD [51], [52], which tries to give more importance to the shape of curves. We used the tslearn implementation [53]. c) Tsfresh: from the Python package of the same name, extracts features from time series [54]–[57]. It extracts a large number of features and then uses a feature selection method to select the most relevant ones for the clustering task (we used the EfficientFCParameters method [58]). We then use K-means for clustering on the extracted features. d) K-means + Dynamic Time Warping (DTW): uses DTW, from tslearn [59], to compute the distance between the time series [8], [60]. DTW is considered a suitable choice for shape-based clustering as it matches the series by stretching or compressing segments, allowing it to compare patterns that occur at different time periods. B. Data Curation and Pre-processing Techniques are compared using 2 data sets, which represent all jobs executed on a system in a certain time period. a) System A: is an experimental platform composed of 192 nodes and a BeeGFS file system. This data set, composed of 108,433 jobs, covers a period from May 2022 to June 2026. Data was collected with the beegfs-ctl command, called every second. We make this data set publicly available.4 b) System B: is a 520-node production supercomputer with a Lustre file system. This publicly available data set, composed of 860,006 Darshan traces, covers all of 2025. Darshan’s heatmap module records bytes read and written in up to 200 time bins, distributing I/O operations across bins proportionally to their duration. c) Filtering: First, we discard jobs that contain too few samples for meaningful patterns: jobs shorter than 30 seconds on System A (47.4%) and jobs with fewer than 20 bins on System B (9.1%). On System A, we discard jobs longer than 3 hours (2.6%), which are rare and expensive to process for slow techniques such as K-means(DTW). Second, we set all samples below 1 MiB/s to 0 to decrease noise. Third, we discard time series with fewer than 5 non-zero samples on System A, and time series without any non-zero sample on 4 It will be available in the camera-ready version of the paper.

System B. Read and write traces are filtered independently, so, for example, the read time series of a job could be retained while its write time series is discarded. In the end, we obtain 28,281 read and 40,208 write traces on System A, and 582,316 read and 168,966 write traces on System B. VI. C LUSTERING Q UALITY E VALUATION This section evaluates the quality of the clustering, using the baselines and workloads presented in Section V and the metrics presented in Section VI-A. Section VI-B presents the aggregate score results, Section VI-C the clustering time, and Section VI-D the impact of trace resolution. A. Metrics A good clustering groups jobs that are similar, and separates jobs that are not. Hence, we compute each metric twice: i) the intra value is the distance from a trace to the centroid of its cluster, and ii) the inter value is the distance between the centroids of every pair of clusters. The goal is to achieve low intra and high inter values. We report the median values. Note that we are interested in characterizing jobs not only by their amplitude (i.e., their I/O bandwidth), but also by their shape (i.e., when they do I/O). In this context, simple metrics such as the Euclidean distance are dominated by the amplitude and fail to capture differences in shape. So, we present here two shape-oriented metrics from the literature, DDTW and SBD. We then propose a new metric, PLD, which addresses shortcomings of DDTW and SBD by accounting for both when a job performs I/O and at which bandwidth. a) Derivative Dynamic Time Warping (DDTW) [61]: is a variant of DTW which compares the derivatives of the time series, focusing on differences in their slopes and temporal variations. To reduce the cost of DDTW, we restrict the warping window to sixty points on either side of each point. b) Shape-Based Distance (SBD): is a distance metric [52] that focuses on the shape of time series rather than their absolute amplitude [50], [51]. c) Phase-Level Distance (PLD): SBD ignores amplitude, and DDTW warping can lead to uneven results. Fig. 7 shows this on a trace A and three versions of a trace B: A with small changes, A delayed by 30% of the job duration, and A scaled twofold. Intuitively, the second and third cases should yield worse metric values than the first. SBD ignores the amplitude of both series, so it scores the scaled B at exactly 0, as if it were A itself. DDTW warps the time axis to absorb the delay, and ranks the delayed B (119) closer to A than the slightly changed one (122). We therefore propose PLD, the only one of the three metrics that ranks the slightly changed B closest (0.10), ahead of the scaled (0.36) and the delayed (0.44) ones. PLD cuts the time axis into phases and the bandwidth axis into levels, and checks whether B sits in the same level as A in every phase. Both series, resampled to length L, are cut into P phases of L/P points. Let āp and b̄p be the mean bandwidth of A and B in phase p, and Amax the peak bandwidth of A.

Phase mean of A

B: A delayed by 30% PLD = 0.44 DDTW = 119 SBD = 0.16

Phase mean of B

B: A × 2, same shape PLD = 0.36 DDTW = 156 SBD = 0.00

20

800

16

640 ∆` = 5

480

12 8

320 0

4

1 ∆` = 3 ∆` =∆` =1

160 0

20

40

60

80 100

0

20

40

60

80 100

0

20

40

60

Write

Trace B

Phase level

Bandwidth (MiB/s)

Trace A

B: A with small changes PLD = 0.10 DDTW = 122 SBD = 0.09

0 80 100

Averaging within a phase absorbs small time shifts, and the levels absorb small bandwidth differences. Levels are not capped, so a B above the peak of A is still penalized in proportion. A PLD of 0 means B sits in the level of A in every phase, and 0.1 that it is one level away on average. We use P = 10 phases and ℓ = 10 levels by default in the paper. d) Cluster balance: We observed that some clustering techniques have a tendency to make clusters of a single job or very few jobs, which skews the metrics. Hence, we add the normalized Shannon entropy [62] to represent the balance in cluster size. The closer the value is to 1, the more evenly the traces are split across the clusters. e) Aggregate score: To compare strategies using a single value, we combine the median intra and inter values of the previous distance metrics and the cluster balance metric into an aggregate score. Each metric is then min-max normalized across the compared strategies to [0, 1], with 1 given to the best strategy and 0 to the worst. The aggregate score of a strategy is the mean of the normalized metrics. B. Aggregate Score Results Fig. 8 summarizes the clustering results on System A (Fig. 8a) and System B (Fig. 8b). SAGE or SAGE-2 obtain the highest aggregate score in three of the four cases. On System A’ writes, K-shape is within 0.01 of SAGE-2, but takes on average 54 times longer across both systems (Section VI-C). Kmeans(DTW), Tsfresh, and Random take the last three places on both systems, and Tsfresh runs out of memory on System B read traces. SAGE-2 does well because its hierarchical construction produces many homogeneous clusters that cover a broad range of I/O behaviors and amplitude levels, so each trace finds a cluster that closely matches its activity. K-means, in contrast, produces 11 clusters on System A, and two of

0.2

0.67 0.66 0.58 0.53 0.46 0.34 0.30 0.78 0.76 0.68 0.49 0.45 0.42 0.35 0.4 0.6 Aggregate Score

0.8

1.0

0.8

1.0

(a) System A.

Write

A level is Amax /ℓ wide, so the levels follow the scale of A, whether it peaks at thousands or at tens of MiB/s:    P  ℓ b̄p ℓ āp 1 X (1) − PLD(B, A) = P × ℓ p=1 Amax Amax

SAGE K-shape SAGE-2 K-means Random tsfresh K-means DTW

0.0

Read

Fig. 7: Example of PLD usage. Markers are the samples, and the thick steps are the phase means, from which the levels of PLD are computed. Dashed vertical lines separate the P phases and dotted horizontal lines separate the ℓ levels. Red capped lines (left fig) mark the phases that land in different levels. PLD is the sum of these differences divided by P × ℓ.

Read

Proportion of job duration (%)

K-shape SAGE-2 K-means SAGE tsfresh K-means DTW Random

SAGE-2 SAGE K-shape K-means K-means DTW Random tsfresh

0.61 0.56 0.54 0.51 0.40 0.30 0.28

SAGE-2 SAGE K-means K-shape K-means DTW 0.33 Random 0.23 tsfresh ran out of memory

0.0

0.2

0.62 0.56 0.49 0.47

0.4 0.6 Aggregate Score

(b) System B.

Fig. 8: Aggregate score of all metrics for each data set, write (top) and read (bottom). Higher is better.

them, both constant-bandwidth plateaus, gather 64% of the traces (clusters 1 and 5 in Fig. 10). Behaviors that SAGE-2 separates are thus merged by K-means, which increases their intra distance. The heatmap in Fig. 9 breaks down the System A read scores per metric. SAGE-2 obtains the best intra DDTW and SAGE the best intra PLD, meaning that their cluster centroids closely represent their members. Only K-shape, which optimizes SBD directly, also does well on intra metrics. Looking at the inter scores, SAGE performs well on both SBD and PLD, while SAGE-2 obtains intermediate scores. This is expected from its hierarchical construction, which creates multiple classes with similar shapes but different amplitude levels, reducing separation between clusters. Fig. 11 illustrates this effect for the write activity of the δ classes, whose centroids share similar shapes. It also shows a limitation of SAGE-2 clustering. We observe that δ4 does not retain the same shape as the other δ classes. This does not mean that

2000

intra DDTW

0.93

1.00

0.40

0.79

0.11

0.00

0.66

intra SBD

0.56

0.73

0.87

1.00

0.65

0.00

0.51

intra PLD

1.00

0.95

0.38

0.84

0.95

0.00

0.95

inter DDTW

0.14

0.49

0.69

0.11

1.00

0.71

0.00

inter SBD

0.88

0.68

0.45

0.84

0.03

1.00

0.00

cluster δ1

1000 0 10000

cluster δ2

inter PLD

1.00

0.22

0.14

0.77

0.16

0.23

0.00

balance

0.96

0.67

0.53

0.94

0.00

0.52

1.00

SAGE

SAGE-2

K-means

K-shape

tsfresh

K-means (DTW)

Random

6000

cluster 0

0 100 50 0 3000

cluster 1

1500

cluster 2

0 10000

cluster 3

5000

Bandwidth (MiB/s)

0 5000

cluster 4

2500 0 1000

0 9000

cluster δ3

4500 0 2000

cluster δ4

1000 0 10000

cluster δ5

5000 0 10000

cluster δ6

5000 0

Fig. 9: Breakdown of the System A read scores of Fig. 8a per metric. Each cell is the median of the metric over every trace. 1 is the best strategy for that metric and 0 the worst.

3000

Bandwidth (MiB/s)

5000

0

20

40

60

80

100

Fraction of trace duration (%)

Fig. 11: δ clusters produced by SAGE-2 on System A. Write. TABLE I: Clustering time, in minutes, on System A and System B. Includes the elbow search for the number of clusters for the strategies that perform it, namely SAGE, SAGE-2, Kmeans, and Tsfresh. OOM: ran out of memory. System A

System B

Strategy

Read

Write

Read

Write

Random K-means SAGE-2 SAGE K-shape Tsfresh K-means(DTW)

0.2 0.5 1.8 4.4 82 87 256

0.1 0.7 2.1 4.5 229 70 306

0.5 2.1 8.3 16 299 OOM 309

0.2 0.7 3.0 12 142 30 141

cluster 5

500 0 6000

cluster 6

3000 0 10000 5000 0 9000

cluster 7

cluster 8

4500 0 5000

cluster 9

2500 0 10000

cluster 10

5000 0

0

20

40

60

80

100

Fraction of trace duration (%)

Fig. 10: Clusters produced by K-means on System A. Write.

Tsfresh achieves the best inter DDTW score but the worst cluster balance, with nearly all traces assigned to a single cluster. The few traces assigned to the other clusters are therefore very different from the dominant cluster, resulting in large inter DDTW distances. C. Clustering Time All times are measured on a single node with two 8-core Intel Xeon E5-2620 CPUs at 2.10 GHz and 64 GiB of memory. SAGE-2 is the fastest strategy after Random and K-means on every data set (Table I). K-shape, which matches SAGE and SAGE-2 in quality on System A, takes 36 to 109 times longer. K-means(DTW) is the slowest strategy overall. D. Does Trace Resolution Impact Results?

its members have a different shape. Rather, averaging their individual windows can smooth or distort the shape identified during the first clustering stage. Similarly, δ3, δ5 and δ6 have only small differences in peak amplitude. Such small differences can nevertheless be sufficient to separate clusters, for example when the height of a secondary peak or the proportion of zero-I/O windows differs. These observations suggest that the hierarchical construction could be refined by manually tuning the number of amplitude levels per shape. We deliberately avoid such specialization so that SAGE-2 remains fully automated and independent of the workload.

Fig. 12 shows the impact of the resample length L on the aggregate score on System A. A larger L increases clustering time. On reads at L = 900, SAGE-2 takes 3.4 minutes, Kshape 158 minutes, and K-means(DTW) 887 minutes, against 1.8, 82, and 256 minutes at the default L = 300 (Table I). Since results are stable up to L = 700 and a larger L only prolongs clustering, there is no reason to use a large value. E. Summary of Clustering Quality Analysis Table II summarizes where each strategy falls short. Tsfresh assigns nearly every trace to a single cluster, which poorly

SAGE SAGE-2

K-means K-shape Write

tsfresh K-means DTW

Random

1.0

j3

j1

0

0.2

1.4

0.2

0.8 Aggregate Score

j1 0.4

Read

0.5

j2

j3 +j4 0.6

0.1

j4

j2

0.6

Fig. 13: Greedy merging on four jobs and < 4 OSTs. The edges of the merged node are the sums of the edges they replace (1.4 = 1.0 + 0.4).

0.4

100

300

500 700 900 100 300 Resample length (points per job)

500

700

900

Fig. 12: Aggregate score against resample length. Traces of System A. Write (left) and read (right). Higher is better. TABLE II: Summary of the clustering quality analysis on System A writes: ✓ good, ∼ mixed, ✗ poor. SAGE SAGE-2 Time intra inter Balance

✓ ✓ ∼ ✓

✓ ✓ ∼ ✓

K-means K-shape Tsfresh K-means(DTW) ✓ ∼ ∼ ∼

✗ ✓ ∼ ✓

✗ ∼ ∼ ✗

✗ ✗ ∼ ∼

represents different I/O behaviors. K-means is fast but achieves only average cluster balance, intra distances, and inter distances. K-shape has a substantially longer clustering time than SAGE. SAGE and SAGE-2 obtains the best aggregate score on both System A and System B, except for System A’ writes, where K-shape and SAGE-2 are almost tied. These metrics, however, only measure how well the clusters represent the traces. In Section VII, we evaluate whether good scores translate into better decisions in an I/O scheduling use case. VII. U SE C ASE : OST S CHEDULING FROM C LUSTER C ENTROIDS As discussed in Section I, I/O scheduling techniques need to know when jobs do I/O in order to mitigate interference. One such technique is the scheduling of object storage targets (OSTs) [44]. A PFS stores data on several OSTs, and each I/O request accesses one or more of them. If we consider only data access (and ignore metadata and network effects), jobs that use different OSTs do not interfere, because they share no I/O resource. The problem is then to decide which OSTs each job uses, that is, which jobs share them, so as to minimize the competition for bandwidth [63]. In practice, however, the exact time series of a job is only known after its execution. As argued in Section I, predicting the exact temporal behavior of a job is hard, whereas identifying its cluster is a more realistic goal. We therefore consider a scheduler that only knows the cluster of each job, and uses the cluster centroids for placement decisions. Our assumption is that a better clustering produces centroids that represent jobs well, and therefore gives better information for placement. In this section, we evaluate the clustering strategies on this problem. To do so, we use a simulator built on top of SimGrid [64] (Section VII-A), in which a placement algorithm (Section VII-B) selects one OST for each job.

A. Simulation Model We rely on SimGrid 4.1, a mature framework for simulating distributed platforms whose resource-sharing models have been validated against real systems [64], and which has already been used to evaluate I/O scheduling techniques [5]. We built a simulation where each OST is a disk (we use 4 OSTs) whose bandwidth is equally shared by competing jobs. Jobs are represented by a sequence of compute and I/O phases, and a placement algorithm decides, once per job (for simplicity), the OST it should use. To build the job phases, we take traces from the System A data set. From each trace, all time spent at bandwidth lower than 1 MiB/s becomes compute time (duration does not depend on the schedule), and time spent on I/O becomes an I/O phase defined by the amount of data that was moved (so its duration will depend on the obtained bandwidth). To measure the impact of interference, we use the I/O stretch of a job j, defined as Tj /Tjisol , where Tj is the total time spent by the I/O phases of j during the simulation, and Tjisol is the time they would take in isolation. It therefore measures how many times slower the I/O of a job was because it competed with others. We take the geometric mean of the I/O stretch of all jobs in an execution. B. Placement Algorithm Our greedy placement algorithm relies on the notion of I/O overlap. We compare all pairs of jobs a and b, using their expected time series in isolation and their start times, and measure the time tov during which they would do I/O at the same time. The expected time series comes from the cluster centroid, re-scaled to match the job duration. We compute I/O overlap as the mean of the proportion of time spent competing for I/O:   tov tov 1 + isol . (2) w(a, b) = 2 Taisol Tb It goes from 0, when the two jobs never do I/O at the same time, to 1, when they always do. a) Step 1: greedy merging: The algorithm builds a complete graph where nodes are jobs, and edges are weighted by their I/O overlap. While the number of nodes is greater than the number of OSTs, it merges the two nodes joined by the lightest edge (ties are broken by selecting the nodes with the fewest jobs). The collapsed edges are updated with the sum of their weights. This process is illustrated in Fig. 13.

C. Workloads and Settings For a simulation time (or horizon) H, and O OSTs, we define the storage load of a workload of n jobs as Pn T isol (3) ρ = i=1 i , O·H

that is, the I/O time requested by all jobs divided by the I/O time available over H. With ρ > 1, the storage is overloaded and jobs must share OSTs while doing I/O. We build workloads with System A read traces lasting between 10 and 60 minutes (H = 60). We randomly draw workloads of n jobs until their load is within 0.02 of the target ρ, then we draw start times at random so that all jobs start and end within the simulated time. We build workloads of 40 and 80 jobs, with loads ρ of 0.5, 1, 1.5, 2, 2.5 and 3, and 10 random workloads per load. We then simulate each workload with the placement algorithm of Section VII-B, using the output of each clustering strategy. We also add three baselines: round-robin and random placement, which require no information about jobs, and Clairvoyant, which uses the actual time series of jobs instead of clustering information. The latter is our “bestcase” reference. Among the clustering strategies, we show the placements obtained with SAGE, SAGE-2, K-means (the most widely used clustering technique), K-shape (the best baseline in the clustering evaluation from Section VI), and Kmeans(DTW). The results for all strategies will be available in a research report after publication. D. Results Fig. 14 shows our results. For each workload, we report the difference in I/O stretch against round-robin, so that a negative value means an improvement. We can see that taking jobs’ temporal behaviors into consideration for placement (the first row, using the precise information) improves on round-robin in every scenario, by up to 42%. The potential for improvement grows with the number of jobs. SAGE, which has the best aggregate score on the read traces (Fig. 8a), also improves on round-robin in every scenario, with the largest average reductions of all clustering strategies: it decreases the I/O stretch by up to 24%. It is followed by SAGE-2 and K-means(DTW), which decrease it by up to 18% and 12%, respectively. The clustering of K-means(DTW), however, is about 58× slower than that of SAGE on the read traces (Table I). K-means and K-shape, on the other hand, lead to placements worse than round-robin in most scenarios. The experiments with write traces have similar results (some are shown in Fig. 2) and will be available in a research report after publication.

40 jobs Clairvoyant SAGE SAGE-2

−21.0

−24.8

−33.5

−32.5

−30.3

−20.9

−4.3

−10.9

−11.3

−3.1

−6.8

+30%

K-means(DTW) K-means K-shape Random placement

−0.6

−4.9

+0.8

+20%

−6.6

−6.1 −4.0

+4.4

+4.0

−15.7 −7.1 +4.4

−12.6

−12.2

−4.1

−6.6

+1.0

+3.0

−11.9 −2.0

+6.8

+6.7

+10.1

+5.3

+10.3

+4.8

+8.6

+11.4

+11.8

+7.0

+8.5

+4.7

Clairvoyant SAGE SAGE-2

−22.0

−33.6

−37.9

−39.2

−38.0

−41.5

−6.2

−11.1

−7.1

−10.4

−11.4

K-means(DTW) K-means K-shape Random placement

−4.4

−17.7

+0%

80 jobs −4.8

+2.5 +1.3 +8.7

0.5

−17.6 −11.4 +2.2

−20.7 −5.4 +0.2

−0.4

+6.3

+7.2

1

−23.8 −6.3 −1.4

+10%

−19.0 −11.5 +3.5

−18.2 −5.9 +0.1

+4.5

+6.4

+4.3

+7.2

+3.2

+3.9

+2.2

1.5

2

2.5

3

−10% −20% −30%

Geometric mean I/O stretch vs. round-robin

b) Step 2: local search: At the end of step 1, each node contains the jobs that will be placed on the same OST. A local search then improves the placement by considering all possible moves or swaps until no change can decrease the overlap between co-located jobs.

Storage load ρ

Fig. 14: Difference in I/O stretch (%) compared to roundrobin. Lower is better, with negative meaning an improvement. Read traces of System A.

VIII. L IMITATIONS Our approach proposes an accurate I/O time series classification that addresses the unique I/O patterns. Specifically, SAGE specializes meta-parameters (e.g., number of symbols L to address various durations, size of the window) and performs a dedicated encoding per system. However, transferring our workflow to different systems or time series signals (e.g., energy consumption, performance counters) may require adjustments to the meta-parameters or the encoding to capture their properties. Studying these adjustments is interesting to identify common patterns or differences from data across various domains of research. Moreover, the resampling to a common length L hides the frequency of I/O phases for periodic applications. To avoid losing this information, we would recommend using SAGE in addition to some periodicity characterization technique such as FTIO [16]. Finally, we relied on simulation to provide a proof of concept for the clustering-based OST scheduling use case. Our focus for future work is to implement this full workflow, including the prediction of classes, into a real system. IX. C ONCLUSION We presented SAGE and SAGE-2, two techniques to cluster HPC jobs from their I/O activity over time. Our approach cuts each trace into short windows, learns an alphabet of shapes and amplitude levels from these windows, and translates each trace into a sequence of symbols before clustering it. We also proposed PLD, a metric that accounts for both when a job does I/O and at which bandwidth, tackling weaknesses of existing metrics. All source code required to apply our approach to new data sets is publicly available [once the paper is published]. Finally, we release a data set with the I/O traces of 108,433 jobs to support further work in the field.

We evaluated our approach on 819,771 traces from 2 systems. It obtains the best aggregate score in three of the four cases, while K-shape, the closest baseline in quality, takes 36 to 109 times longer to produce a clustering. Clustering metrics are useful to compare strategies, but they are not enough to judge whether the clusters are useful. We therefore evaluated the clusters on a downstream task, the placement of jobs on the OSTs of a PFS, where the scheduler only knows the centroid of the cluster of each job. In this task, using our clusters, we decrease I/O stretch by up to 24% compared to the state of the art (round-robin placement). The ranking of the strategies, however, does not follow the metrics exactly. K-shape, whose aggregate score is close to ours, leads to placements worse than round-robin on read traces, whereas K-means(DTW), which, along with Tsfresh, has the lowest aggregate score, gives good placements on write traces. On write traces, SAGE-2 has the best aggregate score, but SAGE gives slightly better placements. The downstream task is therefore the best judge of a clustering. Under this criterion, SAGE and SAGE-2 remain the best strategies on read traces and among the best on write traces. ACKNOWLEDGMENT As part of the "France 2030" initiative, this work has benefited from a State grant managed by the French National Research Agency (Agence Nationale de la Recherche) attributed to the Exa-DoST project of the NumPEx PEPR program, reference: ANR-22-EXNU-0004. Experiments presented in this paper were carried out using Grid5000, one of the precursor infrastructures of the SLICESFR testbed, operated by a scientific interest group including 14 major French academic institutes and Universities (see https://slices-fr.eu/). Experiments presented in this paper were carried out using the PlaFRIM experimental testbed, supported by Inria, CNRS (LABRI and IMB), Université de Bordeaux, Bordeaux INP and Conseil Régional d’Aquitaine (see https://www.plafrim.fr). This data was generated from resources of the Argonne Leadership Computing Facility, which is a DOE Office of Science User Facility supported under Contract DE-AC0206CH11357. R EFERENCES [1] ThinkParQ GmbH, “BeeGFS: Architecture and overview,” https://www. beegfs.io, 2018. [2] P. J. Braam and P. Schwan, “The lustre storage architecture,” Cluster File Systems, Inc., Tech. Rep., 2004. [3] O. Yildiz, M. Dorier, S. Ibrahim, R. Ross, and G. Antoniu, “On the root causes of cross-application i/o interference in hpc storage systems,” in 2016 IEEE International Parallel and Distributed Processing Symposium (IPDPS), May 2016, pp. 750–759. [4] M. Trochon, J.-T. Acquaviva, F. Z. Boito, B. Goglin, F. Tessier, and L. Teylo, “On the impact of interference from concurrent jobs on checkpointing performance,” Proceedings of the 38th International Conference on Scalable Scientific Data Management, 2026. [Online]. Available: https://api.semanticscholar.org/CorpusID:282922987 [5] F. Boito, G. Pallez, L. Teylo, and N. Vidal, “Io-sets: Simple and efficient approaches for i/o bandwidth management,” IEEE Trans. Parallel Distrib. Syst., vol. 34, no. 10, p. 2783–2796, Oct. 2023. [Online]. Available: https://doi.org/10.1109/TPDS.2023.3305028

[6] B. Yang, X. Ji, X. Ma, X. Wang, T. Zhang, X. Zhu, N. El-Sayed, H. Lan, Y. Yang, J. Zhai, W. Liu, and W. Xue, “End-to-end I/O monitoring on a leading supercomputer,” in 16th USENIX Symposium on Networked Systems Design and Implementation (NSDI 19). Boston, MA: USENIX Association, Feb. 2019, pp. 379–394. [Online]. Available: https://www.usenix.org/conference/nsdi19/presentation/yang [7] M. R. Wyatt, S. Herbein, K. Shoga, T. Gamblin, and M. Taufer, “Canario: Sounding the alarm on io-related performance degradation,” in 2020 IEEE International Parallel and Distributed Processing Symposium (IPDPS), 2020, pp. 73–83. [8] F. Boito, L. Teylo, M. Popov, T. Jolivel, F. Tessier, J. Luettgau, J. Monniot, A. Tarraf, A. Carneiro, and C. Osthoff, “A deep look into the temporal i/o behavior of hpc applications,” in 2025 IEEE International Parallel and Distributed Processing Symposium (IPDPS), 2025, pp. 749– 762. [9] L. Pottier, R. F. da Silva, H. Casanova, and E. Deelman, “Modeling the performance of scientific workflow executions on hpc platforms with burst buffers,” in 2020 IEEE International Conference on Cluster Computing (CLUSTER), 2020, pp. 92–103. [10] M. Isakov, E. d. Rosario, S. Madireddy, P. Balaprakash, P. Carns, R. B. Ross, and M. A. Kinsy, “Hpc i/o throughput bottleneck analysis with explainable local models,” in SC20: International Conference for High Performance Computing, Networking, Storage and Analysis, 2020, pp. 1–13. [11] T. Wang, S. Byna, G. K. Lockwood, S. Snyder, P. Carns, S. Kim, and N. J. Wright, “A zoom-in analysis of i/o logs to detect root causes of i/o performance bottlenecks,” in 2019 19th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing (CCGRID), 2019, pp. 102–111. [12] E. Karrels, L. Huang, Y. Kan, I. Arora, Y. Wang, D. S. Katz, W. Gropp, and Z. Zhang, “Fine-grained policy-driven i/o sharing for burst buffers,” in Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, ser. SC ’23. New York, NY, USA: Association for Computing Machinery, 2023. [Online]. Available: https://doi.org/10.1145/3581784.3607041 [13] A. Gainaru, G. Aupy, A. Benoit, F. Cappello, Y. Robert, and M. Snir, “Scheduling the i/o of hpc applications under congestion,” in Proceedings of the 2015 IEEE International Parallel and Distributed Processing Symposium, ser. IPDPS ’15. USA: IEEE Computer Society, 2015, p. 1013–1022. [Online]. Available: https: //doi.org/10.1109/IPDPS.2015.116 [14] Z. Zhou, X. Yang, D. Zhao, P. Rich, W. Tang, J. Wang, and Z. Lan, “I/oaware batch scheduling for petascale computing systems,” in 2015 IEEE International Conference on Cluster Computing, 2015, pp. 254–263. [15] Y. Liu, R. Gunasekaran, X. Ma, and S. S. Vazhkudai, “Server-side log data analytics for i/o workload characterization and coordination on large shared storage systems,” in SC ’16: Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, 2016, pp. 819–829. [16] A. Tarraf, A. Bandet, F. Boito, G. Pallez, and F. Wolf, “Capturing periodic i/o using frequency techniques,” in 2024 IEEE International Parallel and Distributed Processing Symposium (IPDPS), 2024, pp. 465– 478. [17] S. Aghabozorgi, A. Seyed Shirkhorshidi, and T. Ying Wah, “Timeseries clustering – a decade review,” Information Systems, vol. 53, pp. 16–38, 2015. [Online]. Available: https://www.sciencedirect.com/ science/article/pii/S0306437915000733 [18] W. Yang, X. Liao, D. Dong, and J. Yu, “A quantitative study of the spatiotemporal i/o burstiness of hpc application,” in 2022 IEEE International Parallel and Distributed Processing Symposium (IPDPS), 2022, pp. 1349–1359. [19] “Time series classification datasets,” https://www. timeseriesclassification.com/dataset.php, Accessed on 2026-09-17. [20] P. Bentley, G. Nordehn, M. Coimbra, and S. Mannor, “The PASCAL Classifying Heart Sounds Challenge 2011 (CHSC2011) Results,” http://www.peterjbentley.com/heartchallenge/index.html. [21] “Dataset: Earthquakes,” https://www.timeseriesclassification.com/ description.php?Dataset=Earthquakes, Accessed on 2026-09-17. [22] “City of melbourne pedestrian counting system,” http://www.pedestrian. melbourne.vic.gov.au/#date=11-06-2018&time=4, Accessed on 202609-17. [23] B. Kemp, A. Zwinderman, B. Tuk, H. Kamphuisen, and J. Oberye, “Analysis of a sleep-dependent neuronal feedback loop: the slow-

wave microcontinuity of the eeg,” IEEE Transactions on Biomedical Engineering, vol. 47, no. 9, pp. 1185–1194, 2000. [24] T. Pollard, B. E. Moody, L.-w. H. Lehman, B. J. Gow, C. Fernandes, C. Xie, A. Johnson, R. G. Mark, and T. Heldt, “PhysioNet as a global platform for biomedical research,” Nature Health, vol. 1, no. 8, pp. 792–795, Aug. 2026. [Online]. Available: https://doi.org/10.1038/s44360-026-00096-z [25] M. Dorier, S. Ibrahim, G. Antoniu, and R. Ross, “Using formal grammars to predict i/o behaviors in hpc: The omnisc’io approach,” IEEE Transactions on Parallel and Distributed Systems, vol. 27, no. 8, pp. 2435–2449, 2016. [26] S. Kim, A. Sim, K. Wu, S. Byna, and Y. Son, “Design and implementation of I/O performance prediction scheme on HPC systems through large-scale log analysis,” Journal of Big Data, vol. 10, no. 1, p. 65, 2023. [27] R. McKenna, S. Herbein, A. Moody, T. Gamblin, and M. Taufer, “Machine learning predictions of runtime and io traffic on high-end clusters,” in 2016 IEEE International Conference on Cluster Computing (CLUSTER), 2016, pp. 255–258. [28] Y. Li, L. Xiao, J. Feng, J. Zhang, G. Zheng, and Y. Yuan, “Ioscout: an i/o characteristics prediction method for the supercomputer jobs,” in 2023 IEEE 3rd International Conference on Computer Communication and Artificial Intelligence (CCAI), 2023, pp. 205–210. [29] K. Youssef, S. Neuwirth, N. Rajesh, and H. Devarajan, “Metis: Agentic knowledge synthesis for explainable i/o performance in hpc systems,” in Proceedings of the 35th International Symposium on High-Performance Parallel and Distributed Computing, ser. HPDC ’26. New York, NY, USA: Association for Computing Machinery, 2026, p. 817–826. [Online]. Available: https://doi.org/10.1145/3806645.3816129 [30] J. Emeras, S. Varrette, M. Guzek, and P. Bouvry, “Evalix: Classification and prediction of job resource consumption on hpc platforms,” in Job Scheduling Strategies for Parallel Processing, N. Desai and W. Cirne, Eds. Cham: Springer International Publishing, 2017, pp. 102–122. [31] F. Antici, A. Proia, R. Ohara, T. Hanawa, Z. Kiziltan, A. Bartolini, and J. Domke, “Automated configuration of power-management knobs for optimal hpc job executions,” in 2026 IEEE 26th International Symposium on Cluster, Cloud and Internet Computing (CCGrid), 2026, pp. 210–220. [32] E. Ahmadzada, P. Stolf, J.-M. Pierson, and L. Lefevre, “Sufficiency in Data Centers: Energy-Aware Resource Recommendation System,” Jun. 2026, this document is the preprint version of the paper. The accepted manuscript and publisher’s version are currently subject to an embargo imposed by the publisher. They will be made available after the embargo period ends, in compliance with the publisher’s open access policy. [Online]. Available: https://hal.science/hal-05658205 [33] T. Daradkeh, G. Roper, C. Alarcon Meza, and S. A. Mokhov, “Hpc jobs classification and resource prediction to minimize job failures,” in Proceedings of the International Conference on Computer Systems and Technologies 2024, ser. CompSysTech ’24. New York, NY, USA: Association for Computing Machinery, 2024, p. 95–101. [Online]. Available: https://doi.org/10.1145/3674912.3674914 [34] M. S. Halawa, R. P. Díaz Redondo, and A. Fernández Vilas, “Unsupervised kpis-based clustering of jobs in hpc data centers,” Sensors, vol. 20, no. 15, p. 4111, Jul. 2020. [Online]. Available: http://dx.doi.org/10.3390/s20154111 [35] J. Bang, C. Kim, K. Wu, A. Sim, S. Byna, S. Kim, and H. Eom, “Hpc workload characterization using feature selection and clustering,” in Proceedings of the 3rd International Workshop on Systems and Network Telemetry and Analytics, ser. SNTA ’20. New York, NY, USA: Association for Computing Machinery, 2020, p. 33–40. [Online]. Available: https://doi.org/10.1145/3391812.3396270 [36] B. Yang, Y. Zou, W. Liu, and W. Xue, “An end-to-end and adaptive i/o optimization tool for modern hpc storage systems,” in 2022 IEEE International Parallel and Distributed Processing Symposium (IPDPS), 2022, pp. 1294–1304. [37] E. Betke and J. Kunkel, “Classifying temporal characteristics of job I/O using machine learning techniques,” Journal of High-Performance Storage, 2021. [38] A. H. Yazdani, A. K. Paul, A. M. Karimi, F. Wang, and A. Butt, “User-based i/o profiling for leadership scale hpc workloads,” in Proceedings of the 26th International Conference on Distributed Computing and Networking, ser. ICDCN ’25. New York, NY, USA: Association for Computing Machinery, 2025, p. 181–190. [Online]. Available: https://doi.org/10.1145/3700838.3700865

[39] E. Costa, T. Patel, B. Schwaller, J. M. Brandt, and D. Tiwari, “Systematically inferring i/o performance variability by examining repetitive job behavior,” in SC21: International Conference for High Performance Computing, Networking, Storage and Analysis, 2021, pp. 1–15. [40] V. Satopaa, J. Albrecht, D. Irwin, and B. Raghavan, “Finding a "kneedle" in a haystack: Detecting knee points in system behavior,” in 2011 31st International Conference on Distributed Computing Systems Workshops, 2011, pp. 166–171. [41] P. Carns, R. Latham, R. Ross, K. Iskra, S. Lang, and K. Riley, “24/7 characterization of petascale i/o workloads,” in 2009 IEEE International Conference on Cluster Computing and Workshops, 2009, pp. 1–10. [42] S. Snyder, P. Carns, K. Harms, R. Ross, G. K. Lockwood, and N. J. Wright, “Modular hpc i/o characterization with darshan,” in 2016 5th Workshop on Extreme-Scale Programming Tools (ESPT), 2016, pp. 9– 17. [43] C. Wang, J. Sun, M. Snir, K. Mohror, and E. Gonsiorowski, “Recorder 2.0: Efficient parallel i/o tracing and analysis,” in 2020 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW), 2020, pp. 1–8. [44] F. Boito, L. Teylo, M. Popov, L. Aimi, A. Bandet, L. Lima Pilla, and G. Pallez, “TOTO: Transparent I/O Tuning for HPC Applications,” in ICS 2026 - International Conference on Supercomputing, Belfast, United Kingdom, Jul. 2026. [Online]. Available: https://inria.hal. science/hal-05662894 [45] J. L. Bez, A. Miranda, R. Nou, F. Boito, T. Cortes, and P. Navaux, “Arbitration policies for on-demand user-level I/O forwarding on HPC platforms,” in 2021 IEEE International Parallel and Distributed Processing Symposium (IPDPS), 2021, pp. 577–586. [46] P. J. Pavan, J. L. Bez, M. S. Serpa, F. Z. Boito, and P. O. Navaux, “An unsupervised learning approach for i/o behavior characterization,” in 2019 31st International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD). IEEE, 2019, pp. 33–40. [47] J. Kunkel and E. Betke, “Toward a workflow for identifying jobs with similar i/o behavior utilizing time series analysis,” in High Performance Computing: ISC High Performance Digital 2021 International Workshops, Frankfurt Am Main, Germany, June 24 – July 2, 2021, Revised Selected Papers. Berlin, Heidelberg: SpringerVerlag, 2021, p. 161–173. [Online]. Available: https://doi.org/10.1007/ 978-3-030-90539-2_10 [48] “Kneed,” https://pypi.org/project/kneed/, Accessed on 2026-09-08. [49] J. Paparrizos and L. Gravano, “k-shape: Efficient and accurate clustering of time series,” SIGMOD Rec., vol. 45, no. 1, p. 69–76, Jun. 2016. [Online]. Available: https://doi.org/10.1145/2949741.2949758 [50] Y. Li, D. Shen, T. Nie, and Y. Kou, “A new shape-based clustering algorithm for time series,” Information Sciences, vol. 609, pp. 411– 428, 2022. [Online]. Available: https://www.sciencedirect.com/science/ article/pii/S0020025522007940 [51] J. Paparrizos and L. Gravano, “Fast and accurate time-series clustering,” ACM Trans. Database Syst., vol. 42, no. 2, Jun. 2017. [Online]. Available: https://doi.org/10.1145/3044711 [52] “sbd pairwise distance,” https://www.aeon-toolkit.org/en/stable/api_ reference/auto_generated/aeon.distances.sbd_pairwise_distance.html, Accessed on 2026-07-22. [53] “Kshape,” https://tslearn.readthedocs.io/en/latest/gen_modules/ clustering/tslearn.clustering.KShape.html, Accessed on 2026-07-22. [54] M. Christ, N. Braun, J. Neuffer, and A. W. Kempa-Liehr, “Time series feature extraction on basis of scalable hypothesis tests (tsfresh – a python package),” Neurocomputing, vol. 307, pp. 72–77, 2018. [Online]. Available: https://www.sciencedirect.com/science/article/pii/ S0925231218304843 [55] “tsfresh,” https://tsfresh.readthedocs.io/en/latest/api/modules.html, Accessed on 2026-09-12. [56] I. Prakaisak and P. Wongchaisuwat, “Hydrological time series clustering: A case study of telemetry stations in thailand,” Water, vol. 14, no. 13, 2022. [Online]. Available: https://www.mdpi.com/ 2073-4441/14/13/2095 [57] P. M. B. Abrasaldo, S. J. Zarrouk, and A. W. Kempa-Liehr, “Featurebased time series clustering for efficient labelling of geothermal data,” Geothermics, vol. 138, p. 103656, 2026. [Online]. Available: https://www.sciencedirect.com/science/article/pii/S0375650526000611 [58] “Efficientfcparameters,” https://tsfresh.readthedocs.io/en/latest/api/ tsfresh.feature_extraction.html#tsfresh.feature_extraction.settings. EfficientFCParameters, Accessed on 2026-09-12.

[59] “Dtw,” https://tslearn.readthedocs.io/en/stable/user_guide/dtw.html, Accessed on 2026-09-11. [60] H. Izakian, W. Pedrycz, and I. Jamal, “Fuzzy clustering of time series data using dynamic time warping distance,” Engineering Applications of Artificial Intelligence, vol. 39, pp. 235–244, 2015. [Online]. Available: https://www.sciencedirect.com/science/article/pii/S0952197614003078 [61] E. J. Keogh and M. J. Pazzani, Derivative Dynamic Time Warping, pp. 1–11. [Online]. Available: https://epubs.siam.org/doi/abs/10.1137/1. 9781611972719.1 [62] C. E. Shannon, “A mathematical theory of communication,” Bell System Technical Journal, vol. 27, no. 3, p. 379–423, 1948. [63] A. Bandet, F. Boito, and G. Pallez, “Scheduling distributed I/O resources in HPC systems,” in 30th International European Conference on Parallel and Distributed Computing 26 - 30 August 2024 Madrid, Spain 30th International European Conference on Parallel and Distributed Computing, Madrid, Spain, Aug. 2024. [Online]. Available: https://inria.hal.science/hal-04394004 [64] H. Casanova, A. Giersch, A. Legrand, M. Quinson, and F. Suter, “Versatile, scalable, and accurate simulation of distributed applications and platforms,” Journal of Parallel and Distributed Computing, vol. 74, no. 10, pp. 2899–2917, 2014.