{"id":"5bcdd355-10a7-4e3e-a260-a14975fe5c85","arxiv_id":"2412.12218","paper_version":2,"verdict":"REJECT","confidence":"MODERATE","novelty_score":2.0,"correctness_risk":"high","formal_verification":"none","parameter_count":2,"one_line_summary":"FTC-GNN is a TC-GNN-style framework that combines Tensor Cores and CUDA Cores for sparse GNN kernels, but its claimed AGNN speedup over DGL is contradicted by its own tables.","lead":"This paper describes FTC-GNN, a GPU framework that runs graph neural network computations on both Tensor Cores and CUDA Cores at the same time. The authors report large speedups, but one headline number contradicts the paper's own tables.","discovery_kind":"incremental","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Abstract's 5.32x AGNN-vs-DGL speedup is contradicted by Table VI; recomputed average is ~1.97x, with FTC-GNN slower on amazon0505, so the central superiority claim is unsupported.","rationale":"The most load-bearing issue is not the choice of metric but the fact that the headline number cannot be reproduced from the paper's own tables. Section VI.B.1 defines speedup as DGL average GPU kernel time divided by FTC-GNN average GPU kernel time. Applying this to Table VI for AGNN yields per-dataset speedups of 3.41x (citeseer), 3.23x (cora), 0.925x (amazon0505), 1.11x (com-amazon), and 1.20x (amazon0601). The arithmetic mean is 1.97x and the ratio of total DGL time to total FTC-GNN time is 1.14x. Neither equals the 5.32x reported in the abstract and Figure 11. This is not a matter of interpretation; it is a direct contradiction within the paper. If the 5.32x figure cannot be backed by the raw data behind Figure 11, the central claim of superiority over DGL for AGNN collapses. The secondary concern about preprocessing/accuracy (no accuracy tables; Section III.C promises accuracy preservation) reinforces the rejection but is not needed to establish that the paper as written fails to support its abstract. I therefore concur with the reader's REJECT verdict; the reader's weakest_assumption (kernel-only metric) is related but not the same as the internal inconsistency, hence 'partial' agreement.","tokens_in":17575,"tokens_out":5390,"duration_ms":41652,"concrete_test":"Recompute the AGNN-vs-DGL average speedup from Table VI using the Section VI.B.1 definition: for each dataset compute DGL time / FTC-GNN time, then average (and also compute total-time ratio). Compare the result with the 5.32x claimed in Figure 11/abstract. If the value is not 5.32x, the authors should supply the raw per-dataset measurements behind Figure 11 and a reproducible script; without that, the headline claim is contradicted by the paper's own tables.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section VI.B.1 defines the AGNN-vs-DGL speedup as DGL average GPU kernel time divided by FTC-GNN average GPU kernel time. Table VI gives the per-dataset times; computing the ratios yields citeseer 3.41x, cora 3.23x, amazon0505 0.925x, com-amazon 1.11x, amazon0601 1.20x. The arithmetic mean is about 1.97x, and the ratio of summed DGL times to summed FTC-GNN times is about 1.14x. Neither matches the abstract's and Figure 11's 5.32x. This is a direct internal contradiction: the headline evidence for FTC-GNN's superiority over DGL on AGNN is not reproducible from the paper's data. A further issue is that the reported speedups are kernel-time-only and exclude the one-time sparse graph transformation cost, and no accuracy measurements are provided despite Section III.C stating accuracy must be preserved; however, the Table VI contradiction alone invalidates the abstract's central claim.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes FTC-GNN, a GPU framework for sparse graph neural network computation that aims to use Tensor Cores and CUDA Cores in parallel. It introduces a sparse-to-dense graph transformation technique, sparse neighbor aggregation, and sparse edge feature computation kernels built on the WMMA API, and reports speedups over DGL, PyG, and TC-GNN for GCN and AGNN models on five datasets. The abstract claims average speedups of 4.90x, 7.10x, and 1.17x for GCN and 5.32x, 2.92x, and 1.02x for AGNN against DGL, PyG, and TC-GNN, respectively.","tokens_in":17788,"tokens_out":4537,"duration_ms":39898,"significance":"If the reported speedups were reproducible, FTC-GNN would be a practically useful contribution: it targets a real bottleneck, the poor utilization of Tensor Cores for irregular sparse GNN workloads, and it goes beyond existing work such as TC-GNN by attempting a more balanced partitioning between Tensor Cores and CUDA Cores. The paper deserves credit for reporting per-dataset kernel-time tables, which allow an independent reader to recompute the claimed averages, and for comparing against multiple established baselines. However, the central performance claim for half of the evaluation is directly contradicted by the paper's own data: the abstract's 5.32x AGNN-vs-DGL speedup is not reproducible from Table VI, which shows FTC-GNN slower than DGL on amazon0505 and a per-dataset average speedup of about 1.97x. In addition, the evaluation is limited to GPU kernel time, excluding the one-time sparse graph transformation cost, and no accuracy results are provided despite the stated requirement to preserve accuracy. These gaps mean the practical superiority of FTC-GNN is not currently established.","major_comments":[{"comment":"The abstract states that for AGNN, FTC-GNN achieves a 5.32x speedup over DGL, and Section VI.B.1 repeats this claim. This is not supported by the data in Table VI. Computing the ratio DGL average GPU kernel time divided by FTC-GNN average GPU kernel time for each dataset gives citeseer 5.673/1.665 = 3.41x, cora 5.630/1.744 = 3.23x, amazon0505 35.841/38.762 = 0.93x, com-amazon 21.269/19.179 = 1.11x, and amazon0601 26.754/22.358 = 1.20x. The arithmetic mean of these per-dataset ratios is about 1.97x, and the ratio of summed DGL time to summed FTC-GNN time is about 1.14x; neither equals 5.32x. The narrative in Section VI.B.1 is also inconsistent with its own table: it says FTC-GNN's average GPU kernel time is 'significantly higher' than DGL for amazon0505, com-amazon, and amazon0601, but Table VI shows FTC-GNN is faster than DGL on com-amazon (19.179 ms vs. 21.269 ms) and amazon0601 (22.358 ms vs. 26.754 ms), and slower only on amazon0505. This is a direct internal contradiction that invalidates the headline AGNN-vs-DGL result.","section":"Abstract, Section VI.B.1, Table VI, Figure 11"},{"comment":"All speedup claims are based on average GPU kernel time only, as defined in Section VI.B.1, and exclude the one-time sparse graph transformation cost described in Section V.A.1. The transformation is a required preprocessing step that converts the input CSR graph into TC blocks, so a practical performance comparison should include it or provide an amortized analysis. For small datasets such as citeseer and cora, the reported FTC-GNN kernel times are sub-millisecond (0.551 ms and 0.485 ms for GCN), so even a modest transformation overhead could dominate the kernel time and change the direction of the comparison. No end-to-end runtime or total training time is reported anywhere in Section VI. The claimed practical acceleration therefore rests on the unstated assumption that kernel time alone is a fair and complete proxy for GNN performance.","section":"Section VI.B.1 and Section V.A.1"},{"comment":"Section III.C states that the acceleration approach 'must ensure' that the accuracy of GNN models is not compromised, but the experimental section contains no accuracy measurements for any model or dataset. This is a load-bearing omission because the implementation uses TF-32 and half-precision WMMA operations (Sections V.A.1 and V.A.2), which can change numerical results compared to FP32. Without accuracy results, the reader cannot verify that the reported speedups are achieved at acceptable model quality, and the stated research goal of preserving accuracy is left unvalidated.","section":"Section III.C and Section VI"}],"minor_comments":[{"comment":"The sentence 'FTC-GNN and DGL show relatively similar performance in terms of average GPU kernel time' is misleading: per Table VI, FTC-GNN is about 3.4x and 3.2x faster than DGL on citeseer and cora, respectively, for AGNN.","section":"Section VI.B.1, Table VI"},{"comment":"The figures are referenced in the text but not reproduced in the manuscript, and the axis definitions are not described. In particular, Figure 11 is claimed to show a 5.32x average speedup that does not agree with Table VI; if the figure aggregates data differently, the aggregation rule should be stated explicitly.","section":"Figures 10-15"},{"comment":"The precision used in the experiments is ambiguous: Section V.A.1 says the TF-32 data format is adopted with TC_BLK_H = 16 and TC_BLK_W = 8, while Section V.A.2 mentions that half-precision floating-point numbers are used to reduce complexity. The relationship between these two statements and the actual precision used in the reported kernel times should be clarified.","section":"Section V.A.1 and V.A.2"},{"comment":"The hardware table lists a 'Graphics Card Cirrus Logic GD 5446' alongside the Tesla V100; this appears to be a display adapter rather than the device used for CUDA computation, and the entry should be removed or clarified.","section":"Table III"},{"comment":"Several references appear unrelated to the claims they support, for example the TechRxiv preprints on housing price prediction and Wikipedia topic modeling cited in the context of recommendation systems and social networks; the authors should verify that each citation matches its context.","section":"References"}],"recommendation":"reject","confidential_remarks":"The manuscript's central performance claim is internally contradicted by its own Table VI, and the evaluation omits both preprocessing overhead and accuracy validation, so the result cannot be accepted without substantial new experiments and reanalysis. Additionally, the reference list contains several off-topic preprint citations that should be checked for citation integrity if the authors resubmit."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The paper describes FTC-GNN, an extension of TC-GNN that splits GNN matrix work between Tensor Cores and CUDA Cores. The strongest thing about it is the prose: the kernel design, the sparse-to-dense transformation, and the WMMA/CUDA-core partitioning are described clearly enough that someone could reimplement the system. The GCN tables also show consistent, if modest, speedups over DGL and PyG (4.90x and 7.10x averages), and the 1.17x over TC-GNN is plausible for an incremental change.\n\nThe load-bearing problem is the AGNN-vs-DGL claim. The abstract says 5.32x average speedup, but Table VI gives per-dataset kernel times. Dividing DGL by FTC-GNN gives roughly 3.41x, 3.23x, 0.925x, 1.11x, and 1.20x across the five datasets, an arithmetic mean near 1.97x and a ratio of summed times near 1.14x. That is not a rounding issue; it is a direct contradiction between the headline result and the paper's own data. FTC-GNN is actually slower than DGL on amazon0505. The AGNN section of the conclusion then says FTC-GNN shows \"no significant advantage or disadvantage\" against DGL, which only deepens the inconsistency.\n\nBeyond that, the experimental protocol is weaker than it should be. There is no code or data release, no error bars, no end-to-end timing, and the speedup is kernel-time only, excluding the one-time sparse graph transformation cost that Section VI.B.1 does not mention. Section III.C promises that accuracy must be preserved, but no accuracy numbers appear anywhere. On novelty, the paper is honest about its debts: it builds on TC-GNN's sparse graph transformation and WMMA kernels, and the idea of offloading part of the GEMM to CUDA cores is already in Ho et al. and Tacker. So the contribution is a modest engineering variant, not a new mechanism.\n\nIf the numbers were corrected, this could be a reasonable workshop-level systems paper. As written, the central AGNN superiority claim is unsupported by the paper's own tables. My recommendation: send it to peer review rather than desk reject, because the GCN results and implementation detail deserve a careful look, but the authors should be asked to fix or drop the AGNN-vs-DGL claims, release code, and add accuracy measurements. A referee who just checks the arithmetic would catch the problem immediately, and the paper is fixable.","headline":"The abstract's 5.32x AGNN-vs-DGL speedup is contradicted by the paper's own Table VI, and the novelty over TC-GNN is thin, but the GCN data and implementation description give the paper enough substance to justify a corrective review round.","tokens_in":18351,"tokens_out":2579,"would_cite":false,"duration_ms":25023,"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":"FTC-GNN accelerates sparse GNNs by running Tensor Cores and CUDA Cores in parallel, reporting kernel-time speedups of up to 7.10x over established libraries.","keywords":["graph neural networks","Tensor Cores","CUDA cores","sparse matrix multiplication","kernel fusion","GPU acceleration","GCN","AGNN"],"falsifier":"Rerun the FTC-GNN, DGL, PyG, and TC-GNN comparison on the same five datasets but measure full end-to-end time including the sparse graph transformation and, for training, the accuracy after convergence. If the transformation cost is included, small graphs such as citeseer and cora should show much smaller speedups; recomputing the AGNN-versus-DGL average from Table VI will also reveal whether the abstract's 5.32x figure can be reproduced.","tokens_in":17343,"feed_emoji":"⚡","tokens_out":7453,"duration_ms":63621,"temperature":0.7,"pith_summary":"FTC-GNN is a framework for accelerating sparse graph neural networks by running Tensor Cores and CUDA Cores simultaneously instead of one after the other. Its sparse-to-dense transformation packs the irregular adjacency matrix into dense blocks that Tensor Cores multiply efficiently, while CUDA Cores handle data management and the remaining sparse edges. Using GCN and AGNN models on five graph datasets, the paper reports average GPU kernel-time speedups of 4.90x and 7.10x for GCN against DGL and PyG, 1.17x against TC-GNN, and corresponding AGNN speedups of 5.32x, 2.92x, and 1.02x. The result matters because sparse graph workloads typically leave GPUs underutilized, and the design shows a practical way to keep both compute units busy.","feed_headline":"Sparse GNNs get 7x kernel-time speedup from dual-core split","feed_subtitle":"A sparse-to-dense packing feeds Tensor Cores while CUDA cores handle edges and data movement.","key_machinery":"The load-bearing mechanism is the sparse graph transformation technique, which reads the graph in CSR form, groups rows into row windows, compresses duplicate neighbor loads, and emits dense TC blocks with block height 16 and width 8. These blocks are consumed by a single fused CUDA kernel that uses WMMA instructions to perform GEMM on Tensor Cores for most blocks and scalar multiply-add on CUDA Cores for the remainder, with shared memory acting as the buffer that both units read from. The same transformation feeds two kernels: sparse neighbor aggregation, an SpMM-style operation, and sparse edge feature computation, an SDDMM-style operation.","core_discovery":"The paper's central claim is that the usual bottleneck in sparse GNN acceleration is not the raw speed of either unit but the failure to use them concurrently. FTC-GNN therefore divides the work by data shape: dense matrix-multiply fragments are sent to Tensor Cores, while CUDA Cores execute the memory-intensive and irregular parts of the computation. The measured evidence is a set of GPU kernel-time comparisons, presented per dataset, showing that FTC-GNN is faster than DGL and PyG on all five datasets under GCN, and faster than PyG under AGNN, while remaining competitive with TC-GNN. The authors state the speedups as 4.90x, 7.10x, and 1.17x for GCN and 5.32x, 2.92x, and 1.02x for AGNN relative to DGL, PyG, and TC-GNN.","pith_inferences":["A reader redoing the arithmetic on Table VI will find that the AGNN-versus-DGL average is not the 5.32x stated in the abstract.","A testable extension would be to measure end-to-end time including the one-time sparse transformation; small graphs such as citeseer and cora would likely show smaller speedups than the kernel-only figures.","The same heterogeneous scheduling idea could generalize to other sparse deep learning workloads, such as sparse attention or recommendation models that mix irregular indexing with dense matrix multiplication.","An adaptive version that sizes the CUDA/Tensor-Core split per row window or per graph density is a natural next step for graphs where TC blocks are few."],"forward_implications":["A one-time graph transformation can be reused across many training and inference iterations, so the preprocessing cost is amortised rather than paid per layer.","The same CUDA-plus-Tensor-Core split can accelerate both SpMM-like neighbor aggregation and SDDMM-like edge feature computation, covering the two main sparse operations in GNN layers.","Because the split is done inside one kernel, FTC-GNN avoids the overhead of launching separate kernels for the dense and sparse portions of the computation.","If the kernel-time speedups hold, GNN frameworks can adopt the technique without changing model semantics, only the internal scheduling of matrix work."],"supporting_citations":[{"why":"TC-GNN is the direct baseline and the framework this work extends, supplying the sparse graph transformation and the prior collaborative CUDA/TCU kernel design.","marker":"[10]"},{"why":"Tacker contributes the static kernel fusion and scheduling idea for running Tensor Cores and CUDA Cores in parallel while preserving quality of service.","marker":"[29]"},{"why":"This work on parallel execution of Tensor Cores and CUDA Cores motivates the split-computation strategy that FTC-GNN applies to GNNs.","marker":"[25]"},{"why":"GE-SpMM is cited as an existing sparse matrix-multiplication library that uses only CUDA Cores, defining the gap FTC-GNN addresses.","marker":"[31]"},{"why":"PyTorch is the framework into which TC-GNN, and by extension FTC-GNN, is integrated, making the implementation usable.","marker":"[32]"},{"why":"DGL is one of the two primary GNN library baselines whose kernel times are compared against FTC-GNN.","marker":"[33]"},{"why":"cuSPARSE represents the sparse-library baseline that uses only CUDA cores and lacks Tensor Core support.","marker":"[22]"}],"fun_headline_variants":["Sparse GNNs get up to 7x kernel speedup from dual-core split","Dual-core split accelerates sparse GNNs up to 7x","Feeding dense ops to Tensor Cores speeds sparse GNNs 7x","CUDA and Tensor cores split duties for 7x faster GNNs"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that average GPU kernel time alone is a fair and complete measure of acceleration, so the one-time sparse graph transformation cost, end-to-end runtime, and model accuracy can be left out of the speedup comparison.","fun_headline_variants_meta":{"raw":{"variants":["Sparse GNNs get up to 7x kernel speedup from dual-core split","Dual-core split accelerates sparse GNNs up to 7x","Feeding dense ops to Tensor Cores speeds sparse GNNs 7x","CUDA and Tensor cores split duties for 7x faster GNNs"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000783,"raw_usage":{"total_tokens":3491,"prompt_tokens":1015,"completion_tokens":2476,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":631,"completion_tokens_details":{"reasoning_tokens":2390}},"tokens_in":631,"tokens_out":2476,"duration_ms":16439,"temperature":1.0,"reasoning_tokens":2390,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-11T15:00:26.272274+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Rerun the FTC-GNN, DGL, PyG, and TC-GNN comparison on the same five datasets but measure full end-to-end time including the sparse graph transformation and, for training, the accuracy after convergence. If the transformation cost is included, small graphs such as citeseer and cora should show much smaller speedups; recomputing the AGNN-versus-DGL average from Table VI will also reveal whether the abstract's 5.32x figure can be reproduced.","supporting_citations":[{"cited_title":"TC-GNN: Bridging sparse GNN computation and dense tensor cores on GPUs,","cited_arxiv_id":null,"evidence_quote":"TC-GNN is the direct baseline and the framework this work extends, supplying the sparse graph transformation and the prior collaborative CUDA/TCU kernel design."},{"cited_title":"Tacker: Tensor-CUDA core kernel fusion for improving the GPU utilization while ensuring QoS,","cited_arxiv_id":null,"evidence_quote":"Tacker contributes the static kernel fusion and scheduling idea for running Tensor Cores and CUDA Cores in parallel while preserving quality of service."},{"cited_title":"Improving GPU throughput through parallel execution using tensor cores and CUDA cores,","cited_arxiv_id":null,"evidence_quote":"This work on parallel execution of Tensor Cores and CUDA Cores motivates the split-computation strategy that FTC-GNN applies to GNNs."},{"cited_title":"Ge-spmm: General-purpose sparse matrix-matrix multiplication on GPUs for graph neural networks,","cited_arxiv_id":null,"evidence_quote":"GE-SpMM is cited as an existing sparse matrix-multiplication library that uses only CUDA Cores, defining the gap FTC-GNN addresses."},{"cited_title":"PyTorch: An imperative style, high-performance deep learning library,","cited_arxiv_id":null,"evidence_quote":"PyTorch is the framework into which TC-GNN, and by extension FTC-GNN, is integrated, making the implementation usable."},{"cited_title":"Cusparse library,","cited_arxiv_id":null,"evidence_quote":"cuSPARSE represents the sparse-library baseline that uses only CUDA cores and lacks Tensor Core support."}],"review_version":1}