{"id":"8425db6f-f60a-4546-a369-efa4cc8a60b7","arxiv_id":"2607.05095","paper_version":1,"verdict":"ACCEPT","confidence":"HIGH","novelty_score":6.0,"correctness_risk":"low","formal_verification":"none","parameter_count":4,"one_line_summary":"FAST delivers 2.1× average (up to 4.7×) end-to-end speedup for TGNN training via SlimCache, thread-efficient operators, and topology-aware sampling while preserving accuracy.","lead":"FAST jointly optimizes sampling, host-GPU data movement, and sparse graph operators to train temporal GNNs 2.1× faster on average. Systems builders and practitioners training recommenders or traffic models on large dynamic graphs can cut wall-clock time without accuracy loss.","discovery_kind":"new_method","skeptic_critique":{"model":"grok-4.5","headline":"No significant objection identified","rationale":"The paper's strongest claim is an empirical systems result: end-to-end training speedup without accuracy loss on four real dynamic graphs. The three co-designed components are independently ablated, the code is released, and the experimental regime (single A100, top-k=10, batch=2000, 2-layer models) is fully specified. The pre-sampling stationarity assumption identified by the reader is the softest modeling choice, yet the measured gains survive even when that assumption is only partially true (low cache ratios still show large I/O reductions from compression alone; operator speedups are topology-driven rather than affinity-driven). Because the claim is not a mathematical theorem but a measured wall-clock improvement under stated conditions, and because those measurements already include the one-shot configuration the authors actually use, the assumption does not threaten the claim. No stronger load-bearing flaw (incorrect complexity, missing baseline, accuracy regression, or unstated hardware dependence) appears. Verdict therefore remains ACCEPT; the concrete test above is only a useful sensitivity check, not a required correction.","tokens_in":24679,"tokens_out":542,"duration_ms":5378,"concrete_test":"Re-run the TGN/WIKITALK and TGN/BITCOIN configurations of Table 4 while forcing a fresh pre-sampling pass (hot-ID list + affinity matrix) every epoch instead of once; if the per-epoch wall-clock time rises by more than ~8 % relative to the published one-shot numbers, the stationarity assumption is material; otherwise it is not.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The reader's weakest assumption (one-shot pre-sampling of root-node hot IDs and affinity matrices remaining valid for a full epoch under fixed batch size and top-k=10) is real but not load-bearing for the central claim. SlimCache's greedy placement and topology-aware binding are offline configuration steps whose effectiveness is already measured end-to-end; the dominant speedups come from within-batch compression and the redesigned AGG/ESM kernels, both of which do not depend on the pre-sampling remaining perfectly stationary. Table 4, the I/O ablations in Figure 8, and the operator profiles in Table 5 show consistent gains even when cache ratios are low or when sampling affinity is only partially exploited. No internal inconsistency, circular derivation, or untested regime that would overturn the reported 2.1\times average speedup is present under the paper's stated single-GPU CTDG setting.","agreement_with_reader":"agree"},"referee_report":{"model":"grok-4.5","summary":"The paper presents FAST, a single-GPU framework that jointly optimizes the three main stages of continuous-time temporal GNN training: temporal neighbor sampling, host–device feature movement, and sparse graph operators (aggregation and edge-softmax). SlimCache combines within-batch ID compression with a greedy cross-batch cache that treats nodes and edges differently under a fixed GPU budget (Algorithm 1). Thread-efficient CUDA kernels replace node-parallel aggregation with a COO edge-centric scheme and replace warp-shuffle edge-softmax with a CSR thread-loop reduction that enlarges the per-block working set. A topology-aware sampler builds a thread-affinity matrix from a lightweight pre-sampling pass and binds high-affinity threads to shared L2/L3 domains via Blossom matching (Algorithm 2). On four public dynamic graphs and three models (TGN, TGAT, DySAT) the system reports average 2.1\times (up to 4.7\times) end-to-end speedup over TGL, ETC and SIMPLE while preserving average-precision accuracy (Table 4), with component ablations (Figures 8–11) and kernel counters (Table 5) supporting the claimed sources of gain.","tokens_in":24982,"tokens_out":1065,"duration_ms":8633,"significance":"If the reported speedups hold, FAST supplies a practical, modular co-design that simultaneously attacks the three dominant bottlenecks of large-scale CTDG training—an area where prior systems have largely optimized stages in isolation. The public code release, the explicit accuracy tables, and the kernel-level counters (L1/L2 hit rates, active warps/threads) make the claims falsifiable and reusable by other frameworks. The work is therefore of clear engineering value to the systems-for-GNN community and to practitioners training TGNNs on graphs with tens to hundreds of millions of edges under realistic single-GPU memory budgets.","major_comments":[{"comment":"Table 4 and §6.2: several baseline entries are OOM (ETC/SIMPLE on GDELT and BITCOIN). While the paper correctly notes that FAST still runs, the relative speedups versus those systems become undefined; the abstract’s “average 2.1× over state-of-the-art systems” should be recomputed only over the configurations where every baseline finishes, or the OOM cases should be reported separately so that the headline number is not inflated by incomplete runs.","section":null},{"comment":"§6.1 and Table 4: results are stated to be averages of five independent runs, yet no standard deviations or confidence intervals appear for either wall-clock time or AP. For the largest claimed gains (4.7× on WIKITALK-TGN, 4.2× on GDELT-TGN) the absence of variance makes it impossible to judge whether the differences are statistically stable; adding error bars or a short variance table is load-bearing for the central performance claim.","section":null}],"minor_comments":[{"comment":"Abstract vs. Table 4: abstract claims “average of 2.1×”; the body text in §6.2 quotes 2.6× over TGL. Align the two numbers or clarify the exact averaging set.","section":null},{"comment":"Figure 1 caption and §3.1: the 78 % I/O figure is given for WIKITALK; a one-sentence note that the same breakdown holds (or does not) for the other three datasets would strengthen the motivation.","section":null},{"comment":"Algorithm 2 and §4.4: the complexity argument uses hop=0 (roots only) yet still writes O(S^K); a brief remark that K is set to 0 in the implementation would remove the apparent discrepancy.","section":null},{"comment":"Table 1 “Thread efficiency” column is derived from average degree; a short formula or footnote would make the 53–76 % numbers reproducible.","section":null},{"comment":"§5: the compression engine is said to emit “CSR-style ind_ptr”; a one-line clarification that this is used only for the ESM kernel (not for the COO AGG) would avoid reader confusion.","section":null},{"comment":"Typographical: “FASTintroduces”, “FASTemploys”, missing spaces after system names appear repeatedly in the abstract and introduction; also “edgeSoftmax” vs. “edge-softmax” inconsistency.","section":null}],"recommendation":"minor_revision","confidential_remarks":"The manuscript is a solid systems paper with reproducible artifacts and no internal circularity. The two major points (OOM-inflated averages and missing variance) are easily fixable and do not threaten the core technical contribution. Fit for a systems/parallel-processing venue is good; novelty relative to the concurrent SWIFT disk-pipeline work is adequately discussed in §6.4 and §7."},"author_rebuttal":null,"desk_editor":{"model":"grok-4.5","letter":"This is a clean systems paper. The new pieces are SlimCache (within-batch ID compression plus a greedy node/edge-asymmetric static cache under a fixed GPU budget), COO edge-parallel aggregation plus a CSR thread-loop edge-softmax tuned for the small-degree temporal subgraphs, and a one-shot Blossom matching that binds sampling threads by root-node affinity. None of the ingredients is revolutionary on its own—ETC, SIMPLE, TASER, FastGL, dGNN and NextDoor are all visible ancestors—but the joint co-design that treats node versus edge redundancy differently and wires the three stages together is new and useful.\n\nWhat they do well is the measurement. Four public graphs (including BITCOIN and GDELT), three models, end-to-end numbers against TGL/ETC/SIMPLE, component ablations (Figures 8–11), kernel counters (Table 5), and accuracy tables that stay flat. Code is released. The dominant wins come from compression and the redesigned operators; those do not depend on the pre-sampling remaining perfectly stationary. The topology-aware sampler and greedy hot-ID lists are offline configuration steps whose benefit is already baked into the end-to-end numbers.\n\nSoft spots are minor and proportional. No standard deviations despite five-run averaging. Some baselines OOM, which inflates relative speedups on the largest graphs. Scope is single-GPU CTDG only; DTDG is left for later. The one-shot pre-sampling assumption (hop-0 roots, fixed batch size and top-k=10) is the weakest modeling choice, but the stress-test is right: it is not load-bearing for the central claim. Disk-based SWIFT is slower on their hardware for bandwidth reasons, not a conceptual flaw.\n\nThis is for people who actually train TGNNs on large continuous-time graphs and care about wall-clock under limited GPU memory. It will not open new scientific questions, but it will change practice for single-GPU pipelines. I would send it to referees; the evidence is already strong enough that revision should be light.","headline":"Solid single-GPU systems paper that co-designs the three real TGNN bottlenecks and delivers measured 2× wall-clock gains with open code; the pre-sampling stationarity assumption is real but not load-bearing.","tokens_in":25556,"tokens_out":546,"would_cite":true,"duration_ms":5249,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"grok-4.5","headline":"Joint optimization of sampling, memory I/O, and sparse operators yields up to 4.7× faster TGNN training without accuracy loss.","keywords":["temporal graph neural networks","dynamic graphs","memory I/O optimization","graph operators","neighbor sampling","GPU caching","thread affinity"],"falsifier":"Re-run the full training suite while regenerating hot-ID lists and affinity matrices every few batches instead of once; if end-to-end speedup collapses or accuracy drifts, the static-pre-sampling premise fails.","tokens_in":25591,"feed_emoji":"⚡","tokens_out":674,"duration_ms":5583,"temperature":0.7,"pith_summary":"Temporal Graph Neural Networks learn from timestamped interactions, but training them on large dynamic graphs is slowed by three bottlenecks that compound: repeated host-to-GPU feature transfers, load-imbalanced aggregation and edge-softmax on sparse subgraphs, and cache-unfriendly neighbor sampling on the CPU. Existing systems attack these stages separately and leave large performance gaps. FAST shows that a single pre-sampling pass can expose both within-batch repetition and cross-batch overlap, allowing a unified SlimCache to compress transfers while greedily placing the hottest node and edge features in limited GPU memory; the same structural observations let the authors redesign aggregation as edge-parallel work and edge-softmax as thread-efficient reduction, and bind sampling threads to CPU cores that share cache. On four real dynamic graphs the combined design delivers an average 2.1× (peak 4.7×) end-to-end speedup while preserving model accuracy, demonstrating that co-design across the three stages is both necessary and sufficient for practical large-scale TGNN training.","feed_headline":"TGNN training sped up 2.1× by co-designing I/O, compute, sampling","feed_subtitle":"One pre-sampling pass feeds cache, kernels, and CPU binding; accuracy stays intact on large graphs.","key_machinery":"SlimCache (within-batch ID compression plus greedy cross-batch placement of hot node/edge features under a fixed GPU budget), together with edge-centric aggregation, thread-loop edge-softmax, and topology-aware CPU thread binding derived from the same pre-sampling statistics.","core_discovery":"The paper establishes that the three dominant bottlenecks of TGNN training—memory I/O, irregular graph operators, and temporal sampling—share measurable redundancy and locality patterns that can be harvested once by a lightweight pre-sampling pass and then exploited jointly, producing average 2.1× and peak 4.7× end-to-end speedups over prior systems with no accuracy loss.","pith_inferences":[],"forward_implications":[],"fun_headline_variants":["FAST co-optimizes TGNN I/O, compute, sampling for 2.1× speedup","Pre-sampling unifies TGNN bottlenecks: 2.1× avg, 4.7× peak","Holistic cache, kernels, sampling cut TGNN training 2.1×","SlimCache plus topology sampling yields 2.1× TGNN end-to-end gain","Joint locality harvest speeds TGNN training 2.1× without accuracy loss"],"cache_read_input_tokens":16512,"weakest_assumption_plain":"A single pre-sampling pass that looks only at root nodes under a fixed batch size and top-k sampling remains representative enough for the whole subsequent training epoch.","fun_headline_variants_meta":{"raw":{"variants":["FAST co-optimizes TGNN I/O, compute, sampling for 2.1× speedup","Pre-sampling unifies TGNN bottlenecks: 2.1× avg, 4.7× peak","Holistic cache, kernels, sampling cut TGNN training 2.1×","SlimCache plus topology sampling yields 2.1× TGNN end-to-end gain","Joint locality harvest speeds TGNN training 2.1× without accuracy loss"]},"model":"grok-4.5","effort":"low","cost_usd":0.00562,"raw_usage":{"total_tokens":1524,"prompt_tokens":785,"num_sources_used":0,"completion_tokens":123,"cost_in_usd_ticks":56200000,"prompt_tokens_details":{"text_tokens":785,"audio_tokens":0,"image_tokens":0,"cached_tokens":256},"completion_tokens_details":{"audio_tokens":0,"reasoning_tokens":616,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}},"tokens_in":785,"tokens_out":123,"duration_ms":4659,"temperature":1.0,"reasoning_tokens":616,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-07-11T08:53:00.845896+00:00","model_set":{"reader":"grok-4.5"},"falsifier":"Re-run the full training suite while regenerating hot-ID lists and affinity matrices every few batches instead of once; if end-to-end speedup collapses or accuracy drifts, the static-pre-sampling premise fails.","supporting_citations":[],"review_version":1}