{"id":"67288bff-2a37-43d9-ad57-b2a543811f5c","arxiv_id":"2608.07078","paper_version":1,"verdict":"CONDITIONAL","confidence":"HIGH","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"SparkleDock accelerates LightDock's glowworm-swarm flexible docking by rewriting energy scoring as tensor-core matrix operations, achieving 9.7x to 18.9x single-GPU speedups and strong scaling to 512 GPUs.","lead":"SparkleDock is a new GPU-accelerated version of the flexible protein docking program LightDock, redesigned to use tensor cores and scale to hundreds of GPUs. It speeds up single-GPU docking by 10 to 20 times and cuts large docking jobs from hours to seconds on a 512-GPU system.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Table I lists SparkleDock at 51/55 BM5.2 successes, but Section IV-F measures only nine complexes (88.9% Top-10); the flagship 'high-fidelity' claim rests on an unmeasured extrapolation from LightDock's success rate.","rationale":"Strengths: The HPC work is coherent and the kernel-level claims (TCU reformulation, register remapping, pipeline overlap, roofline, strong scaling, performance model) are supported by internal experiments; the CUDA-core vs TCU ablation is a sound way to isolate tensor-core benefit. The concern is not about the speedups; it is about whether the 'high-fidelity' modifier survives the algorithmic transformation. The reader's weakest assumption correctly identifies this. My reading adds a sharper evidentiary problem: the only full-benchmark accuracy number attributable to SparkleDock, 51/55 in Table I, is not backed by any reported experiment, since Section IV-F covers nine complexes and Fig. 10's 88.9% Top-10 is 8/9, not 51/55. Even a perfect 9/9 success rate would be a weak basis for 51/55. Additionally, the Eq. 2 reformulation is algebraically exact but not guaranteed bit-identical in FP64; the zero-padding and TCU accumulation order can produce different distances near bin boundaries. The paper provides no comparison of per-agent trajectories or energy values, so the assumption that LightDock's benchmark results transfer is unverified. None of this contradicts the engineering results, and a full benchmark could settle it, hence the verdict remains CONDITIONAL. If the 51/55 row cannot be reproduced or is retracted, the paper should be downgraded; if reproduced with released artifacts, it would be a strong ACCEPT.","tokens_in":22179,"tokens_out":5204,"duration_ms":50439,"concrete_test":"Run SparkleDock on all 55 BM5.2 complexes using the same protocol as the LightDock row in Table I (same swarms, agents, 100 steps, random seeds, and Top-10 success criterion), and recompute the SparkleDock success count. If it is not 51/55, the accuracy-equivalence claim and the 'high-fidelity' wording must be revised. As a secondary check, on the nine complexes run both Eq. 1 and Eq. 2 scoring from identical initial agent states with identical seeds, and count agents whose DFIRE binning or subsequent movement differs; any nonzero count shows the reformulation is not numerically neutral.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's central claim is that SparkleDock preserves LightDock's docking accuracy while achieving large speedups. The weakest premise is that the reordered/fused GSO and the Eq. 2 Gram-matrix reformulation leave the swarm's visited poses and ranking unchanged, so LightDock's 51/55 success rate transfers unchanged. This premise is asserted, not demonstrated. Section IV-F evaluates only nine BM5.2 complexes, and Fig. 10 reports an 88.9% Top-10 success rate on those nine; Table I nevertheless lists 'SparkleDock (ours)' as 51/55 (92.7%), identical to the LightDock row. No run over the full 55-complex benchmark is reported, so the headline accuracy figure appears to be inherited from LightDock rather than measured for SparkleDock. The FP64 argument for Eq. 2 helps, but it is not a substitute for a trajectory comparison: the Gram expansion subtracts large nearly equal terms, so a small numerical difference can land on a different DFIRE bin, and any difference in binning can alter neighbor selection and movement in subsequent GSO iterations. Without per-complex results, code, or a full benchmark, the 'high-fidelity' claim is not independently supported.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents SparkleDock, a GPU-accelerated reimplementation of the LightDock flexible macromolecular docking algorithm. The authors redesign the GSO simulation loop to expose agent-level parallelism, reformulate the dominant DFIRE pairwise-distance energy computation as a Tensor Core-compatible matrix product via a Gram-matrix expansion (Eq. 2), and add a performance-model-driven load-balancing and out-of-core chunking scheme for multi-GPU execution. The paper reports 9.7x/18.9x single-GPU speedups over LightDock-Rust on A100/H100, 183.1x strong scaling speedup on 512 A100 GPUs for 4GAM, and identical Top-N success rates to LightDock on nine BM5.2 complexes. The central claim is that SparkleDock preserves LightDock's docking accuracy while achieving the reported performance gains.","tokens_in":22425,"tokens_out":3387,"duration_ms":31662,"significance":"If the accuracy claim were fully supported, this would be a substantial contribution: it would reduce flexible protein-protein docking from an hour-scale batch job to a second-scale screening tool on GPU supercomputers, and the TCU reformulation of irregular pairwise distance computations is a transferable systems contribution. The performance measurements are the strongest part of the paper: the controlled CUDA-core comparison isolates the TCU benefit (1.99x on A100, 2.43x on H100), the roofline and breakdown analyses are informative, and the performance model is validated with a 12.55% MAPE on representative complexes. The authors also provide explicit scaling and load-balance measurements up to 512 GPUs. However, the 'high-fidelity' component of the central claim rests on an unmeasured extrapolation: Table I asserts a 51/55 success rate for SparkleDock, but Section IV-F evaluates only nine complexes, and the reported success rates are identical to LightDock's. The paper needs either a full BM5.2 run for SparkleDock or a clear, evidence-backed argument that the transformations preserve the search trajectory exactly.","major_comments":[{"comment":"Table I lists 'SparkleDock (ours)' with 51/55 (92.7%) on BM5.2, identical to the LightDock rows, but Section IV-F evaluates docking accuracy on only nine selected complexes (Tab. III), reporting 88.9% Top-10 success in Fig. 10. No full 55-complex run of SparkleDock is reported anywhere in the paper. The headline accuracy figure therefore appears to be inherited from LightDock rather than measured for SparkleDock. This is load-bearing for the 'high-fidelity' claim in the abstract and conclusion. The authors should either run the full BM5.2 benchmark (or provide per-complex SparkleDock results) or explicitly state that the 51/55 figure is a LightDock value carried over, which would require rewriting the abstract, Table I, and the accuracy discussion.","section":"Section IV-F and Table I"},{"comment":"The paper argues that the Gram-matrix reformulation of the pairwise distance computation preserves semantics, but Eq. (2) computes distances as ||A||^2 + ||B||^2 - 2A·B, which subtracts large, nearly equal floating-point values. In FP64 this can still produce rounding errors that change the bin index assigned by DistBinning (Alg. 1, line 11), and a single bin change can alter the energy score, the neighbor list, and subsequent GSO movement. The use of FP64 is not by itself a proof of numerical equivalence. The authors should provide a direct comparison---for example, the fraction of distance matrix entries that land in the same DFIRE bin under Eq. (1) versus Eq. (2) on the nine test complexes, or a comparison of final poses and energy ranks---to demonstrate that the reformulation is indistinguishable from the original scoring computation.","section":"Section III-B, Eq. (2), and Algorithm 1 line 11"},{"comment":"The statement that SparkleDock's success rates are 'identical to those obtained by the LightDock implementation' is only supported for the nine selected complexes, yet the conclusion generalizes to 'preserves the docking accuracy of LightDock.' Even on those nine complexes, the Top-1 success rate is 55.6% (5/9) and the Top-10 is 88.9% (8/9), so the 'identical' claim is not uniformly true across rank thresholds. The authors should qualify the equivalence claim to the measured set and thresholds, or supply per-complex success/failure data for both methods so the reader can judge whether the selected nine are representative of the full benchmark.","section":"Section IV-F, final paragraph"}],"minor_comments":[{"comment":"The rows labeled 'Chunk Division ✔ - -' are ambiguous: it is unclear which complexes required automatic out-of-core chunk division on A100 and H100, and the dash symbols are not explained in the caption or text.","section":"Table IV"},{"comment":"The success rate bars in Fig. 10 appear to be computed from only nine complexes; the figure should state the number of complexes and ideally show per-complex counts (e.g., 5/9, 8/9, 8/9, ...) rather than percentages alone, to prevent overinterpretation.","section":"Section IV-F and Fig. 10"},{"comment":"The phrase 'effective strong scaling' is not standard; the paper should report parallel efficiency or the achieved speedup relative to the single-GPU baseline for each complex, especially for 2VXT where the speedup plateaus at 32.1x on 256 GPUs.","section":"Section IV-H"},{"comment":"The performance model parameters T_H[ener/nei/move/pose] are described as obtained through microbenchmarks, but the paper does not list the measured values; including them (or a reference to a reproducibility appendix) would strengthen the model's credibility.","section":"Section III-C"},{"comment":"No code or artifact availability statement is provided. For a systems paper whose central claim is that a specific implementation preserves another algorithm's accuracy, releasing the source code and benchmark scripts is important for independent verification.","section":"General"},{"comment":"The phrase 'high-fidelity' in the abstract and conclusion should be qualified in light of the limited accuracy evaluation; a phrase such as 'preserves accuracy on the evaluated BM5.2 subset' would be more precise until the full benchmark is run.","section":"Abstract and Conclusion"}],"recommendation":"major_revision","confidential_remarks":"The speedup and scaling results are direct measurements and appear sound; the TCU reformulation and the controlled CUDA-core comparison are well executed, and the performance model has a reasonable validation error. The main risk is the accuracy claim: the 51/55 success rate in Table I is not supported by any SparkleDock measurement, and the abstract's 'high-fidelity' claim rests on it. I believe this is fixable within the scope of a revision---either by running the full BM5.2 benchmark, which the authors seem capable of doing, or by clearly reformulating the claim as 'preserves accuracy on the evaluated subset.' I would not reject the paper on these grounds, but the revision must address the mismatch between Table I and Section IV-F."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"You should know two things about this paper. First, the systems work is genuinely good: agent-level parallelization of the GSO simulation, a TCU formulation of the pairwise-distance DFIRE score via the Gram identity, register-level remapping for the FP64 MMA fragments, and a performance model that predicts runtime with ~12.5% MAPE and drives static MPI load balancing. Second, the headline accuracy claim is not supported by the experiments they report.\n\nThe paper evaluates 9 of the 55 BM5.2 complexes for accuracy (Section IV-F) and reports 88.9% Top-10 success on those nine, identical to LightDock. Yet Table I lists SparkleDock at 51/55 (92.7%)—the same number as LightDock. Nobody ran the full benchmark for SparkleDock; that figure is inherited. The FP64 argument for the Eq. 2 reformulation helps, but the GSO trajectory is nonlinear: reordering loops, fusing kernels, and rewriting the distance computation can change binning, neighbor selection, and movement. Without per-complex results or a trajectory comparison, the 'high-fidelity' claim rests on an assertion.\n\nWhat is solid: the kernel engineering is credible, the TCU-vs-CUDA-core ablation isolates the tensor-core benefit (1.99x A100, 2.43x H100), the strong scaling curves are internally consistent, and the static load-balancing results show tiny inter-rank variance. The claimed end-to-end speedups (9.7x, 18.9x; >100x at scale) are direct measurements against LightDock-Rust, so those stand on their own.\n\nThe accuracy gap is the main issue and it is load-bearing. Missing code/data makes it worse. Minor points: no error bars on speedups, and the performance model is calibrated on the same kernels it predicts, but it is used only for scheduling so that is not circular.\n\nWho is this for: HPC researchers working on irregular scientific workloads mapped to tensor cores, and docking users will care about the speedups. It deserves a serious referee: the systems contribution is strong, and the accuracy claim can be fixed with a full BM5.2 run or an artifact. I'd accept it conditional on that. Send it to peer review; ask for the full benchmark or code release.","headline":"Solid systems paper with a real accuracy-evidence gap: the speedups look real, but the 51/55 success rate is inherited from LightDock, not measured for SparkleDock.","tokens_in":22990,"tokens_out":1830,"would_cite":true,"duration_ms":16565,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"SparkleDock claims it keeps LightDock's 51/55 docking success rate while cutting runtime by 9.7x on A100, 18.9x on H100, and over 100x at scale.","keywords":["flexible macromolecular docking","glowworm swarm optimization","GPU acceleration","tensor core units","DFIRE energy scoring","load balancing","strong scaling","protein-protein docking"],"falsifier":"Run SparkleDock on all 55 BM5.2 complexes with the same settings and compare the Top-10 success rate against LightDock's reported 51/55; a success rate materially below 51/55, or a divergence in the final pose distributions on the untested 46 complexes, would falsify the high-fidelity claim even if the speedups hold. A cheaper check would compare the per-step glowworm agent states after a fixed random seed between LightDock and SparkleDock to see whether the trajectories agree exactly.","tokens_in":21977,"feed_emoji":"🧬","tokens_out":5643,"duration_ms":49792,"temperature":0.7,"pith_summary":"SparkleDock is a GPU rewrite of the LightDock flexible docking algorithm. The paper claims that by exposing parallelism at individual glowworm agents, reformulating the dominant DFIRE energy scoring as a Tensor-Core matrix product, and using a performance model to divide work across GPUs, it preserves the same search and the same docking success rate while accelerating runtime by 9.7x on an A100, 18.9x on an H100, and by more than two orders of magnitude at 512-GPU scale. The upshot is that flexible docking, which normally takes hours per complex, becomes a seconds-scale screening tool on large GPU clusters. The accuracy claim is demonstrated on nine of the 55 BM5.2 complexes, inheriting LightDock's published 51/55 success rate.","feed_headline":"Docking time drops from hours to seconds with GPU redesign","feed_subtitle":"SparkleDock keeps LightDock's 51/55 success rate while turning swarm docking into a Tensor-Core workload.","key_machinery":"The load-bearing mechanism is the Gram-matrix reformulation of the DFIRE pairwise distance computation: Eq. (2) turns the quadratic all-pairs distance grid into one matrix multiplication plus row and column squared norms. Around it, the paper builds agent-level loop reordering that maps the swarm and agent loops onto a 3D CUDA grid; an mma.m8n8k4 FP64 tensor-core kernel with warp-shuffle register remapping to compute the norms inside the fragment registers; a cp.async multi-stage pipeline; and a performance model, $T_{total}$ and $M_{em total}$, that drives static MPI load balancing and automatic out-of-core chunk division.","core_discovery":"The central discovery is that the performance bottleneck of glowworm-swarm docking is algorithmically removable without changing what the swarm computes. SparkleDock unrolls the swarm and agent loops into fine-grained agent-level tasks, then rewrites the pairwise distance and DFIRE energy evaluation using the identity $D_{x,y}^2 = \\sum_k A_{x,k}^2 + \\sum_k B_{y,k}^2 - 2\\sum_k A_{x,k}B_{y,k}$, so the expensive cross term becomes a tall-skinny matrix multiply $A B^T$ that FP64 tensor cores can execute while CUDA cores compute the squared norms. Register remapping via warp shuffles and cp.async pipelining keep the operation on-chip. The paper argues that because all arithmetic remains in FP64 and the pose update rules are unchanged, the glowworm trajectories are identical to LightDock's, so SparkleDock reproduces LightDock's docking accuracy; its experiments on nine complexes show identical success rates.","pith_inferences":["If the trajectory-equivalence assumption is confirmed across all 55 benchmark complexes, the speedups can be read as a pure implementation gain: LightDock's known accuracy is preserved rather than traded off for speed.","The same Gram-matrix distance reformulation could be applied to other distance-based scoring functions beyond DFIRE, potentially extending the tensor-core speedup to molecular dynamics contact maps and pairwise-kernel machine learning workloads.","A risk the paper leaves implicit is that FP64 tensor-core rounding, while nominally the same precision, could change last-bit distances and therefore binning boundaries, occasionally rerouting an agent; this is testable by comparing the final pose sets at high rank thresholds.","The strong-scaling results show saturation on small workloads like 2VXT, so the practical sweet spot is large complexes or large screening batches rather than single small docking jobs."],"forward_implications":["If the equivalence claim holds, any docking job run on LightDock can be run on SparkleDock with the same expected accuracy but at 9.7x and 18.9x single-GPU speedups on A100 and H100.","At 512 GPUs, the roughly two-orders-of-magnitude additional scaling means a workload that took hours finishes in seconds, making flexible docking a practical pre-filter for large-scale virtual screening.","The TCU reformulation of pairwise distance computation gives a template for turning other irregular all-pairs distance workloads into structured matrix multiplies.","The performance-model-driven chunk division lets one large complex, such as 4GAM with hundreds of gigabytes of pose data, run within a limited GPU memory instead of failing with out-of-memory errors."],"supporting_citations":[{"why":"Defines the LightDock algorithm whose glowworm swarm simulation SparkleDock reimplements, providing the reference agent-state update rules and search logic.","marker":"[9]"},{"why":"Describes the information-driven LightDock version whose published 51/55 BM5.2 success rate serves as the accuracy baseline in Table I and Figure 10.","marker":"[10]"},{"why":"Introduces LightDock-Rust, the optimized CPU implementation used as the speedup baseline for the reported 9.7x, 18.9x, and multi-GPU speedups.","marker":"[6]"},{"why":"Defines the DFIRE distance-scaled energy function whose pairwise lookup-table scoring is the hotspot that SparkleDock reformulates for tensor cores.","marker":"[33]"},{"why":"Introduces glowworm swarm optimization and the local-neighborhood agent update model that the agent-level parallelization must preserve.","marker":"[13]"},{"why":"Publishes the BM5.2 benchmark of 55 protein-protein complexes that supplies the test set and the 51/55 success-rate reference.","marker":"[60]"},{"why":"Provides the CuTe tensor-layout and MMA abstractions on which the TCU-accelerated calc_dfire kernel is implemented.","marker":"[47]"},{"why":"Defines the DockQ metric used to measure the Top-1 through Top-100 success rates reported in Figure 10.","marker":"[61]"}],"fun_headline_variants":["SparkleDock turns hours of docking into seconds on 512 GPUs","GPU tensor cores speed up flexible docking by 100x at scale","From hours to seconds with GPU swarm docking","Tensor-core swarm docking scales to 512 GPUs","SparkleDock: hours to seconds on 512 GPUs, same accuracy"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"SparkleDock's accuracy claim depends on the assumption that its loop reordering and energy reformulation leave the glowworm agents' search trajectories identical to LightDock's, so that success rates measured on LightDock transfer to SparkleDock; the paper tests accuracy on only 9 of the 55 benchmark complexes.","fun_headline_variants_meta":{"raw":{"variants":["SparkleDock turns hours of docking into seconds on 512 GPUs","GPU tensor cores speed up flexible docking by 100x at scale","From hours to seconds with GPU swarm docking","Tensor-core swarm docking scales to 512 GPUs","SparkleDock: hours to seconds on 512 GPUs, same accuracy"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.001698,"raw_usage":{"total_tokens":6732,"prompt_tokens":957,"completion_tokens":5775,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":573,"completion_tokens_details":{"reasoning_tokens":5687}},"tokens_in":573,"tokens_out":5775,"duration_ms":38109,"temperature":1.0,"reasoning_tokens":5687,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T15:14:20.593466+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run SparkleDock on all 55 BM5.2 complexes with the same settings and compare the Top-10 success rate against LightDock's reported 51/55; a success rate materially below 51/55, or a divergence in the final pose distributions on the untested 46 complexes, would falsify the high-fidelity claim even if the speedups hold. A cheaper check would compare the per-step glowworm agent states after a fixed random seed between LightDock and SparkleDock to see whether the trajectories agree exactly.","supporting_citations":[{"cited_title":"Lightdock: a new multi-scale approach to protein–protein docking,","cited_arxiv_id":null,"evidence_quote":"Defines the LightDock algorithm whose glowworm swarm simulation SparkleDock reimplements, providing the reference agent-state update rules and search logic."},{"cited_title":"Lightdock goes information-driven,","cited_arxiv_id":null,"evidence_quote":"Describes the information-driven LightDock version whose published 51/55 BM5.2 success rate serves as the accuracy baseline in Table I and Figure 10."},{"cited_title":"Integrative modeling of membrane-associated protein assemblies,","cited_arxiv_id":null,"evidence_quote":"Introduces LightDock-Rust, the optimized CPU implementation used as the speedup baseline for the reported 9.7x, 18.9x, and multi-GPU speedups."},{"cited_title":"Ab initio folding of terminal segments with secondary structures reveals the fine difference between two closely related all-atom statistical energy functions,","cited_arxiv_id":null,"evidence_quote":"Defines the DFIRE distance-scaled energy function whose pairwise lookup-table scoring is the hotspot that SparkleDock reformulates for tensor cores."},{"cited_title":"Glowworm swarm optimization for simultaneous capture of multiple local optima of multimodal functions,","cited_arxiv_id":null,"evidence_quote":"Introduces glowworm swarm optimization and the local-neighborhood agent update model that the agent-level parallelization must preserve."},{"cited_title":"Updates to the integrated protein–protein interaction benchmarks: docking benchmark version 5 and affinity benchmark version 2,","cited_arxiv_id":null,"evidence_quote":"Publishes the BM5.2 benchmark of 55 protein-protein complexes that supplies the test set and the 51/55 success-rate reference."},{"cited_title":"Dockq v2: Improved automatic quality measure for protein multimers, nucleic acids, and small molecules,","cited_arxiv_id":null,"evidence_quote":"Defines the DockQ metric used to measure the Top-1 through Top-100 success rates reported in Figure 10."}],"review_version":1}