{"id":"5c375891-3781-434f-b8d3-c99514a3069f","arxiv_id":"2509.01919","paper_version":1,"verdict":"CONDITIONAL","confidence":"LOW","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"DiTTO uses diffusion models trained on rasterized storage traces to generate configurable, realistic multi-device I/O workloads with under 8% error on user-specified properties.","lead":"This paper proposes DiTTO, a diffusion model that turns storage system logs into images, then generates new logs that match user-specified read/write ratios and device usage with reported errors near 8%. It could give storage engineers a fast way to synthesize test workloads instead of collecting real traces.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"No discrete-event reconstruction path is specified: the generated artifact is a smoothed image, not an operational storage trace, so the 8% config error cannot substantiate the central claim.","rationale":"The paper's central promise is to generate storage traces; a storage trace is an event stream. The authors describe only an encoding into image space and show generated images. The load-bearing step is the inverse, and it is absent. I considered the concern that the 8% error is partly self-referential (config conditioning) and the lack of baselines; those are real but secondary. Even with baselines, if no decoder is specified, the output cannot be used by any storage-system tool, and the reported metrics may be computed on the smoothed image rather than on discrete events. The fixed time-bin representation is inherently lossy: with the coarseness implied by a 256×256 image and bursts much shorter than a bin, multiple requests merge, and the Gaussian smoothing makes event positions continuous. The paper even calls the traces 'continuous', which suggests the authors are not generating discrete I/O requests but intensity images. A conditional verdict is appropriate: the claim is not refuted, but it is unverified until the authors define and validate the inversion. I therefore agree with the reader's conditional verdict and recommend no change.","tokens_in":4999,"tokens_out":4036,"duration_ms":49433,"concrete_test":"Have the authors release the exact inversion from generated image to event log (threshold rule, event-time sampling, op-type assignment), then for a held-out real trace apply encode→generate→decode and compare the resulting event stream to the original: precision/recall of events, inter-arrival time distribution, and per-device read ratio. If multiple real events collapse into one smoothed pixel or the recovered arrival process differs significantly from the original, the 8% error is not sufficient evidence for realistic trace generation.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section II converts raw logs into a fixed time-bin × device image with Gaussian smoothing, and the rest of the paper treats the diffusion output as the trace. No inverse transform is described: there is no thresholding, event-time sampling, or op-type decoding from pixel intensities back to timestamped read/write requests. The Section III evaluations (R/W ratio error, device utilization, t-SNE, visual comparison) can all be computed on the continuous image; none demonstrates that a discrete event stream usable by a storage simulator can be recovered. Because the rasterization collapses multiple events in the same bin and smoothing removes the exact timing of bursts, the output may not preserve the fine-grained arrival process that workload evaluation depends on. Until the authors define and validate the image-to-event decoding, the central claim that DiTTO 'generates storage traces' is unverified; the 8% and 2% figures quantify conditioning alignment, not event-level fidelity.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes DiTTO, a diffusion-based framework for generating synthetic multi-device storage traces. Raw logs are rasterized into multi-channel images (time bins × devices, read/write channels); a contrastively learned encoder CHIP embeds user-specified numeric workload configurations; Gaussian noise augmentation is used to counter sparsity; and outpainting is used to extend traces to arbitrary lengths. Evaluation on Alibaba Block IO traces reports an average error below 8% for read/write ratio and below 2% for device utilization, together with t-SNE and visual comparisons against real traces. The central claim is that DiTTO produces realistic, diverse, and precisely configurable storage traces.","tokens_in":5205,"tokens_out":3727,"duration_ms":44706,"significance":"If fully substantiated, DiTTO would address a real and timely problem: generating controllable, realistic storage traces without expensive instrumentation. The combination of image-based diffusion, contrastive numeric conditioning, sparsity-aware augmentation, and outpainting is original in the storage-trace domain and could provide a useful tool for workload evaluation. However, the current evidence is preliminary. The paper does not specify how the generated continuous image is turned back into a discrete event stream, the headline accuracy numbers are reported without an evaluation protocol, and fidelity/diversity are supported mostly by qualitative figures. The contribution is promising but needs substantial additional validation before it can support the stated claims.","major_comments":[{"comment":"The paper never describes an inverse transform from the generated continuous image back to a storage trace: there is no thresholding, event-time sampling, or op-type decoding that would yield timestamped read/write requests. Rasterizing time into fixed bins and applying Gaussian smoothing collapses multiple events in one bin and erases exact burst timing. All metrics in Fig. 2 (R/W ratio error, device utilization, t-SNE) are computed on the image representation, not on a discrete event stream usable by a storage simulator. Consequently, the headline '<8% error' quantifies conditioning alignment on images, not event-level fidelity. Please define and validate the image-to-event decoding and report metrics on the recovered event stream (e.g., inter-arrival time distributions, burst lengths, per-device request sequences).","section":null},{"comment":"The central quantitative result, an average error of less than 8% for read/write ratios and less than 2% for device utilization, is reported without error bars, number of seeds, train/test split, or held-out configurations. Because the metric is measured against the exact configuration vector used as the conditioning signal, it demonstrates that the model can memorize or regress to its input condition, not that it generalizes to unseen configurations. Please provide a clear evaluation protocol: separate training and test configurations, multiple random seeds, variance across runs, and comparison with a non-conditioned baseline or an existing synthetic trace generator to calibrate how tight 8% is.","section":null},{"comment":"The claims of high fidelity and diversity rest on qualitative evidence: a t-SNE plot with overlapping clusters and side-by-side images. t-SNE can show cluster structure but is not a quantitative measure of distributional fidelity or diversity. Please report distributional distances (e.g., Wasserstein distance or MMD on request-rate, spatial-locality, and burstiness features) and a diversity metric (e.g., average pairwise distance among generated traces). Similarly, outpainting is validated only by a single visual example in Fig. 3(c); no quantitative measure of long-horizon coherence or continuity is provided. This is load-bearing because arbitrary-length generation is one of the paper's stated contributions.","section":null},{"comment":"The paper claims a \"sparsity-aware training approach\" and the use of local Gaussian noise augmentation, but gives no details: no augmentation variance, schedule, or training loss modifications. More importantly, the transformation is asserted rather than validated. Storage workloads are characterized by bursty, heavy-tailed arrival patterns; smoothing events into intensity gradients may wash out the fine-grained timing structure that downstream system evaluation depends on. Please provide the concrete augmentation scheme and an analysis showing that the image representation preserves or controllably trades off event-level arrival statistics, especially burstiness and idle-period structure.","section":null}],"minor_comments":[{"comment":"The manuscript has no related-work section, so the novelty claim relative to [1] and other ML-based trace generators is not clearly positioned. A short discussion of prior statistical models and feature-engineered ML approaches would help readers assess the contribution.","section":null},{"comment":"The text contains a long garbled block of hexadecimal-like characters immediately after \"implemented DiTTO using Pytorch 2.4\". This appears to be a corrupted passage and should be removed or replaced.","section":null},{"comment":"The figures are hard to read: Fig. 2(a) lacks units and definitions of \"Most accessed\" and \"Most used ID\"; Fig. 3 panels are very small and the read/write channel labels are not clearly legible. Please enlarge and annotate.","section":null},{"comment":"The paper does not state how many traces are used for training versus testing, how the 50 generated traces in Fig. 2(a) are sampled, or what subset of the Alibaba dataset is used. These details are necessary to interpret the accuracy numbers.","section":null}],"recommendation":"major_revision","confidential_remarks":"This is a late-breaking-results paper, and its current length is insufficient to support the central claims. The missing inverse transform is a fundamental gap: without it, the method generates images, not traces. The evaluation protocol also needs substantial strengthening. With a clear decoding step, held-out evaluation, and quantitative fidelity/diversity metrics, the paper could become a solid contribution; as is, I cannot recommend acceptance. I see no problematic citation pattern or novelty-disclosure issue beyond the need for a related-work discussion."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The short version: this is a sensible first pass at using diffusion models for storage trace generation, and the CHIP conditioning trick plus outpainting makes it more interesting than a toy. But the paper as written validates an image generator, not a storage trace generator. There is no description of how the smoothed, time-binned image gets converted back into timestamped read/write events, so the 8% and 2% error numbers measure how well the generated image matches the conditioning vector, not whether the result is usable by a storage simulator.\n\nThe application is new relative to what I know of the storage trace synthesis literature. The sparsity-aware Gaussian augmentation is a practical answer to a real problem, and the outpainting mechanism is a reasonable way to get long traces without retraining. The three-stage pipeline is clearly described and the writing is easy to follow.\n\nThe experimental section is thin, even for a late-breaking paper. One dataset, no baselines, no error bars, no code, no held-out configurations. The t-SNE plot and side-by-side images are suggestive but qualitative. The spatial locality check is a nice touch, but it's one figure. The stress-test is right: without an inverse transform, you can't tell whether bursts and inter-arrival times survive the rasterization. Storage workloads are dominated by fine-grained timing; aggregate statistics like read/write ratio and utilization can be preserved while the arrival process is destroyed.\n\nI wouldn't call the 8% error circular—it's a legitimate check that the conditioning mechanism is doing something—but it's not evidence of fidelity. It's the expected outcome if the contrastive embedding works. The real gap is that nothing in the paper demonstrates the generated artifact can be fed into a storage simulator or otherwise used for evaluation.\n\nWho is this for? People working on synthetic workload generation who want to see whether diffusion is a productive direction. It deserves a serious referee because the core idea is worth pinning down; any competent reviewer would ask for the decoding step and a downstream evaluation (e.g., feeding traces into a simulator and comparing performance). If the authors can show that, it could become a real tool. As is, I would not cite it as a reliable generator, but I would definitely read the extended version.","headline":"Plausible new diffusion-based approach to multi-device storage trace generation, but the missing image-to-event decoding means the headline 8% config error supports conditioning, not realism.","tokens_in":5693,"tokens_out":2426,"would_cite":false,"duration_ms":28135,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"A diffusion-based framework, DiTTO, generates realistic multi-device storage traces, matching user-specified read/write ratios within 8 percent average error and device utilization patterns within 2 percent.","keywords":["diffusion model","storage trace generation","multi-device storage","workload conditioning","contrastive learning","outpainting","synthetic workload","sparsity-aware training"],"falsifier":"Take a real trace and a DiTTO-generated trace matched to the same configuration, replay both through the same storage emulator or stack, and compare inter-arrival-time distributions, queue depths, cache hit ratios, and tail latencies. If generated traces meet their read/write and utilization targets but their inter-arrival distributions lack the heavy-tailed burstiness of the originals, or replay outcomes diverge, the fidelity claim collapses. A direct check on the pipeline alone: extract discrete events from a generated image and compare burst-length and inter-arrival statistics against the t","tokens_in":4903,"feed_emoji":"🗄️","tokens_out":9104,"duration_ms":89292,"temperature":0.7,"pith_summary":"DiTTO is a diffusion-based generative framework for producing synthetic storage workloads — the streams of read and write operations that distributed storage systems such as RAID arrays and CephFS must serve. Real workload traces are costly to collect and raise privacy concerns, while template-based synthetic generators miss the complex, evolving behavior of real systems; DiTTO argues that a conditional diffusion model can fill that gap with traces that are both realistic and precisely controllable. The framework rasterizes access logs into multi-channel images (time on one axis, storage devices on the other, separate channels for reads and writes), conditions generation on quantitative workload parameters through a contrastively trained embedding called CHIP, and uses outpainting to extend traces to arbitrary lengths. The reported result: generated traces follow user-specified read/write ratios within 8% average error and device utilization within 2%, while remaining diverse and structurally similar to real traces.","feed_headline":"Synthetic storage traces hit read/write specs within 8%","feed_subtitle":"A diffusion pipeline turns numeric workload targets into realistic multi-device traces of any length","key_machinery":"The load-bearing mechanism is a conditional diffusion pipeline over an image-like encoding of the trace. Raw logs (timestamps, operation type, device ID) are rasterized into a grid: the x-axis is normalized time binned into fixed intervals, the y-axis indexes storage devices, and separate channels mark read versus write presence. Because storage workloads are extremely sparse, local Gaussian smoothing around each event creates intensity gradients that make the structure learnable; this sparsity-aware treatment is essential to preserving bursty access patterns. CHIP — Contrastive Hyperconfiguration-Image Pretraining — is the conditioning bridge: it contrastively aligns embeddings of user-supp","core_discovery":"The paper's central claim: image-diffusion techniques can generate high-fidelity, precisely controllable multi-device storage traces, and DiTTO is the first diffusion-based trace generator. Three design choices carry the argument: rasterizing access logs into image-like grids (time by device, with separate read/write channels) so a U-Net captures temporal dynamics and cross-device correlations; CHIP, a contrastive-learning mechanism that aligns embeddings of numeric workload configurations with trace-image embeddings so generation obeys explicit quantitative constraints; and outpainting, which extends traces arbitrarily in time while keeping bursts and coordinated device behavior consistent.","pith_inferences":["If the claims hold, storage benchmarking can treat configuration-matching traces as experimental controls — but the paper does not yet show that generated traces reproduce system-level outcomes (cache hit rates, tail latencies) of real traces matched on the same configuration; replay-based validation is the natural next test.","The paper never specifies how continuous image intensities are binarized back into discrete read/write events; until that inverse mapping is described and checked against inter-arrival-time distributions, the discrete trace artifact has an unproven step.","The CHIP conditioning idea is workload-agnostic: the same contrastive alignment of numeric specifications with an image-like rasterization could generate other structured event streams, such as network traffic or user session logs, with quantitative targets.","Spatial locality emerging without explicit conditioning hints that the latent space organizes real workload archetypes; inverting the embedding could classify unknown workloads or flag anomalous access patterns, applications the paper does not pursue."],"forward_implications":["Storage-system researchers can synthesize large, privacy-free test workloads whose read/write ratios and device utilization are set by the user, substituting for traces that are costly or impossible to collect.","Trace length no longer depends on collected data: outpainting extends generation arbitrarily, keeping periodic bursts and coordinated device accesses consistent across segment boundaries.","Un-conditioned properties carry through: generated traces separate by spatial-locality cluster even though locality is never part of the conditioning, indicating the representation retains real workload structure.","The reported accuracy (under 8% read/write-ratio error and under 2% utilization error across 50 generated traces) means configuration targets can be treated as reliable experimental controls in workload studies."],"supporting_citations":[{"why":"The ML-assisted trace-generation baseline whose hand-crafted application features DiTTO's learned representation is meant to replace.","marker":"[1]"},{"why":"The text-conditional image-diffusion work whose conditioning paradigm DiTTO adapts, replacing text prompts with quantitative workload embeddings.","marker":"[2]"},{"why":"The CLIP contrastive-learning method that CHIP builds on to align workload-configuration embeddings with trace-image embeddings.","marker":"[3]"}],"fun_headline_variants":["Diffusion-based trace generator meets configs with 8% error","Storage traces on demand: DiTTO's diffusion approach","Synthetic multi-device traces shaped by diffusion, 8% off","Configurable trace synthesis via diffusion, within 8%","First diffusion-based storage trace generator hits target"],"cache_read_input_tokens":2688,"weakest_assumption_plain":"The framework depends on the assumption that converting discrete timestamped events to a fixed-resolution image grid, with Gaussian blur around each event, preserves the fine-grained timing and burst structure that storage workloads need — and that the smoothed image can then be converted back into discrete read/write events; the paper validates neither direction of that conversion.","fun_headline_variants_meta":{"raw":{"variants":["Diffusion-based trace generator meets configs with 8% error","Storage traces on demand: DiTTO's diffusion approach","Synthetic multi-device traces shaped by diffusion, 8% off","Configurable trace synthesis via diffusion, within 8%","First diffusion-based storage trace generator hits target"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000199,"raw_usage":{"total_tokens":1118,"prompt_tokens":567,"completion_tokens":551,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":311,"completion_tokens_details":{"reasoning_tokens":468}},"tokens_in":311,"tokens_out":551,"duration_ms":6431,"temperature":1.0,"reasoning_tokens":468,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-05T12:02:54.270327+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a real trace and a DiTTO-generated trace matched to the same configuration, replay both through the same storage emulator or stack, and compare inter-arrival-time distributions, queue depths, cache hit ratios, and tail latencies. If generated traces meet their read/write and utilization targets but their inter-arrival distributions lack the heavy-tailed burstiness of the originals, or replay outcomes diverge, the fidelity claim collapses. A direct check on the pipeline alone: extract discrete events from a generated image and compare burst-length and inter-arrival statistics against the t","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"The ML-assisted trace-generation baseline whose hand-crafted application features DiTTO's learned representation is meant to replace."},{"cited_title":"Machine learning assisted hpc workload trace generation for leadership scale storage systems","cited_arxiv_id":null,"evidence_quote":"The text-conditional image-diffusion work whose conditioning paradigm DiTTO adapts, replacing text prompts with quantitative workload embeddings."},{"cited_title":"Hierarchical Text-Conditional Image Generation with CLIP Latents , 2022","cited_arxiv_id":null,"evidence_quote":"The CLIP contrastive-learning method that CHIP builds on to align workload-configuration embeddings with trace-image embeddings."}],"review_version":1}