acceptodds
Under review as a conference paper at ICLR 2027

Certified Nonlinear Computing for Scaled FP8 Datapaths

Abstract

Large Language Models (LLMs) demand substantial computation for inference, motivating the adoption of efficient FP8 matrix engines. However, nonlinear operations such as SwiGLU, RMSNorm, and softmax-based attention still commonly rely on wider intermediate arithmetic before FP8 quantization. Premature rounding of these intermediates can alter the final output codes after downstream composition and shared-scale selection. In this paper, we propose a sufficient-state framework for efficient nonlinear computation in scaled-FP8 pipelines. The framework constructs intermediate states that preserve the information needed to determine final element codes and shared scale bytes. We instantiate this principle through directed states for SwiGLU, exact boundary predicates over whole-row statistics for RMSNorm, and interval aggregates with adaptive refinement for softmax attention. These constructions resolve final quantization decisions through consumer composition and shared reductions. For SwiGLU, mathematical verification and exhaustive finite-state replay establish exact outputs under the declared numerical contract; for attention, interval bounds certify output cells when they are uniquely determined. Based on this framework, we design and implement complete hardware endpoints for SwiGLU, RMSNorm, and softmax attention. Hardware experiments in Nangate45 demonstrate that the SwiGLU semantic ROM reduces area by 54–61% and gate energy by 41–53% relative to polynomial controls. Under matched complete-row configurations, RMSNorm reduces area by 4.1% and gate energy by 23.0%, while attention achieves reductions of 58.8% and 79.6%, respectively, relative to their corresponding controls. Joint replacement experiments across three language models on GSM8K, HumanEval, and GPQA-Diamond demonstrate task performance comparable to native execution.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Low-precision inference, FP8 quantization, Nonlinear operators, Rounding semantics, Sufficient state representations, Hardware–software co-design

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_QiiuOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The paper proposes a sufficient-state framework for efficient nonlinear computing in scaled FP8 pipelines. It develops methods for SwiGLU, RMSNorm, and softmax attention to preserve final FP8 quantization decisions. The methods are evaluated through numerical verification, hardware implementation estimates, and LLM task accuracy experiments.

Critical strengths
  1. Preserving final FP8 quantization results while reducing intermediate computation costs is an interesting idea.
  2. The mathematical arguments appear sound.
Critical weaknesses
  1. The paper is difficult to follow. The introduction is too long, and there is no dedicated related work section. The presentation is overly technical and lacks sufficient intuition. Some figure text is too small, and some table captions appear to lack the required spacing below them.
  2. The contributions mainly concern numerical computing and hardware architecture, and their significance for machine learning is not sufficiently demonstrated. There are no model accuracy comparisons against conventional FP8 inference baselines or end-to-end inference latency or throughput measurements.
  3. The supplementary artifact referenced in the Reproducibility Statement does not appear to be available with the submission, limiting reproducibility.
Questions for authors
  1. Some GPQA-Diamond accuracies in Table 4 (e.g., 81.43% and 91.43%) are inconsistent with the stated evaluation set of 198 questions. These percentages cannot be obtained from an integer number of correct answers. Could the authors clarify the evaluation denominators and provide the raw numbers?
4 comments

Dear Reviewer Qiiu,

Thank you for your feedback. We expanded model and hardware evaluations, verified cross-format portability, and corrected GPQA-Diamond reporting errors.


W1: Presentation, Technical Intuition, and Related Work

We will organize the manuscript around one question: What information must nonlinear computation preserve to guarantee final FP8 codes and shared scales?

The revised presentation will cover:

  1. Motivation: SwiGLU midpoint errors caused by intermediate rounding.
  2. Construction: Directed states, consumer binding, compact encoding, and scale replay.
  3. Certification: Decision cells, producer verification, and exhaustive record replay.
  4. Extensions: Exact RMSNorm and interval-certified attention.

We will add a dedicated Related Work section, improve intuitive examples, enlarge figure labels, and fix table-caption spacing.


W2: Machine-Learning Relevance and Conventional Inference Baselines

(1) Model-Level Evaluation with Matched Quantization Interfaces

We evaluated Matched-native, which retains framework arithmetic under the same quantization interfaces as Replacement.

Table R1: Model evaluation under matched quantization interfaces (%).

ModelMethodGSM8KHumanEvalGPQA-Diamond
DeepSeek-V4-Flash-0731Native95.6892.6889.90
Matched-native95.4590.8589.90
Replacement95.6891.4690.91
Qwen3.5-9BNative93.0387.8081.31
Matched-native92.8087.2079.29
Replacement93.6389.6380.30
Qwen3.8-27BNative95.9196.9590.91
Matched-native95.9196.9590.40
Replacement95.9897.5691.41

Replacement achieves higher scores in all nine matched-interface comparisons, demonstrating model-level effectiveness in quantized LLM inference.

(2) Conventional Hardware Baselines

We implemented a matched BF16 LUT baseline for SwiGLU and conventional FP32 endpoints for RMSNorm and attention.

Table R2: Hardware efficiency against conventional implementations.

OperatorBaselineProposed implementationMain result
SwiGLUSame-ROM BF16 LUTG11 ROM + Compact1625.71% less area; 24.33% less energy
RMSNormFP32-32 + Clock GatingExact Boundary Decision33.20% fewer cycles; 13.83% less energy; 24.48% lower area–delay product
AttentionConventional FP32Interval Certification42.51% fewer cycles; 63.22% less row energy

Table R3: Complete-row hardware and numerical comparison.

MetricRMSNorm FP32RMSNorm OursAttention FP32Attention Ours
Code/scale mismatches73/00/024/0 (boundary cases)0/0 (committed)
Cell area (µm²)465,896526,711127,926254,215
Cycles/row28,42618,989123,78071,157
Energy401.84 pJ/output346.28 pJ/output14.863 µJ/row5.467 µJ/row

Across 1,024 RMSNorm rows (2,621,440 outputs), our implementation achieves zero code/scale mismatches, 33.20% fewer cycles, and 13.83% lower total energy.

For attention, all 31,744 committed FP8 codes and 992 scale bytes match the mathematical reference. Conventional FP32 produces 24 code mismatches across three constructed boundary rows. Our design reduces row energy by 63.22%, using 1.99× cell area.

These results establish final-quantization accuracy and hardware efficiency against conventional finite-precision implementations.

(3) Cross-Format Validation and Practical GPU Implementation

We extended SwiGLU to E5M2, multiple group sizes, and NVFP4.

Table R4: Cross-format numerical validation.

ConfigurationCoverageResult
E5M2 SwiGLU1,978,443 active gate×positive-up combinationsComplete numerical certification
E5M2 signed input–scale contexts620,637,262 contextsFully covered
Group sizes 16–25620 configurations; 63,488 complete blocks; 2,621,440 element evaluations0 proposal/code/scale mismatches
NVFP413,049,856 real activation outputs1 code mismatch; 0 scale mismatches

For NVFP4, the optimized Wide-State path reduces code mismatches from 8,296 to 1 and scale mismatches from 1,862 to 0.

Table R5: NVFP4 CUDA endpoint latency on RTX 6000D, N=9,216.

MOriginal FP16 CUDA (µs)Optimized Wide-State (µs)Speedup
112.6361.7357.28×
1612.8682.2135.82×
12816.1646.1572.62×
17719.9817.9382.52×

Cooperative data layout and optimized division processing deliver 2.52–7.28× CUDA endpoint speedup.

Together, these experiments demonstrate model-level compatibility, numerical portability, and hardware efficiency. We will incorporate the results in the revised manuscript.

W3: Reproducibility and Supplementary Artifact

We will provide an anonymized numerical verification and implementation package in the revised supplementary materials.

Table R6: Reproducibility package.

ComponentVerification material
Mathematical certificationDirected-MPFR boundary checks and decision-cell verification
State constructionCanonical inputs, G11 target mapping, producer verification
State compressionCompact16/Directed15 encoding and suffix-response replay
Format portabilityE5M2 numerical certification and group-size validation
Hardware evaluationRTL configurations, activity protocols, area/energy accounting

The package will include execution instructions, environment specifications, and expected verification outputs. We will update the Reproducibility Statement with the anonymous artifact entry point.


Q1: GPQA-Diamond Accuracy Reporting

We confirmed transcription and rounding errors during result registration and recalculated the GPQA-Diamond accuracies from integer correct-answer counts over 198 questions.

Table R7: Corrected GPQA-Diamond results.

ModelMethodOriginal (%)Correct answersCorrected (%)
DeepSeek-V4-Flash-0731Native89.89178/19889.90
Replacement90.90180/19890.91
Qwen3.5-9BNative81.43161/19881.31
Replacement80.30159/19880.30
Qwen3.8-27BNative90.91180/19890.91
Replacement91.43181/19891.41

All corrected percentages use 100k/198100k/198, rounded consistently to two decimal places.

We will update Table 4 and Appendix F.1 with the corrected percentages, raw counts, and rounding convention. The updated results preserve the overall finding of comparable task performance between joint replacement and native inference.

Thank you for the reply. Weakness 3 is not resolved because the supplementary material is still missing. The updated manuscript contains substantial edits and I recommend a resubmission to check it properly. I maintain my rating.

Thank you for pointing this out. We have now uploaded the supplementary material to OpenReview. Thank you for taking the time to review our response and the updated materials.

Reviewer_1K8aOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper proposes a “sufficient-state” framework for nonlinear operators (SwiGLU, RMSNorm, softmax attention) in scaled-FP8 pipelines: instead of committing early to wider intermediates, retain compact states that preserve exactly the information needed to determine final FP8 element codes and shared scale bytes after consumer composition and shared-scale selection. SwiGLU uses directed G11 tokens and compact records certified by MPFR checks and exhaustive replay; RMSNorm uses exact integer boundary predicates; attention uses outward intervals with refinement. Nangate45 endpoints show area/energy reductions versus polynomial/wide controls, and joint replacement on three LLMs keeps task accuracy on GSM8K / HumanEval / GPQA-Diamond.

Critical strengths

The core problem is real and under-discussed: early intermediate rounding can flip final shared-scale FP8 codes (the SiLU(240) midpoint witness is a clean example). The SwiGLU path is unusually rigorous: fully specified numerical contract, MPFR boundary checks, exhaustive producer mapping and record replay, and a suffix-label counting argument. Evaluation goes beyond an algorithmic note — matched I/O hardware endpoints plus end-to-end joint operator replacement.

Critical weaknesses

Depth is highly uneven. SwiGLU is exhaustively certified; attention relies on standard outward interval arithmetic, adaptive refinement is software-only, and fixed-Q40 hardware may simply report “unresolved”. The abstract’s “certified” claim is much weaker for attention and only partial for RMSNorm. Very narrow generality. Results hold only under a bespoke contract (E4M3FN, group-32 MX, g≤−208 tails excluded, custom proposals). No evidence of transfer to other formats (E5M2 / NVFP4 / other group sizes), other nonlinearities, or realistic quantization stacks. Hardware evidence is not a systems story. Nangate45 @ 400 MHz only; polynomial/cubic controls are weak baselines (no simple LUT/BRAM, no industrial Softmax/SwiGLU engine); attention excludes score/value storage yet still needs ~10⁵ cycles per 64-token row; RMSNorm area gain is only 4.1%. Throughput / energy-per-token implications for serving are missing. Model eval only shows “no degradation”. Three benchmarks, Matched-native not in the main table, no per-operator isolation, and no long-context / attention-stressing setting where interval certification would matter most.

Questions for authors

On long-context workloads, what fraction of attention output cells are “unresolved” / need refinement, and at what cost when that happens? How do these endpoints compare to simple LUT/BRAM baselines and to a standard quantized Softmax+QKV engine — and at a modern process node? Why is Matched-native omitted from Table 4? Please report it and isolate SwiGLU / RMSNorm / attention. Can the construction be re-derived for a different format (e.g. NVFP4 or E5M2) without redoing the full bespoke certification, or is each endpoint a one-off?

3 comments

Dear Reviewer 1K8a,

Thank you for recognizing the numerical rigor of our SwiGLU construction. We extended the evaluation to attention certification, E5M2, multiple group sizes, NVFP4, conventional hardware baselines, and Matched-native model inference.


W1: Certification Guarantees Across Operators

Our framework preserves the information needed to determine final FP8 element codes and shared scales through three operator-specific constructions.

Table R1: Certification mechanisms.

OperatorConstructionCertification
SwiGLUDirected G11 states, multiplier binding, compact recordsMathematical decision cells and exhaustive finite-domain replay
RMSNormExact integer boundary predicatesExact boundary decisions with verified arithmetic widths
AttentionOutward interval aggregationCommit when all element codes and scales are uniquely determined

For RMSNorm, the exact boundary predicate is

$\frac{|x_iw_i|}{\sqrt T}<b \iff (x_iw_i)^2<b^2T.$

For attention, fixed-Q40 hardware commits a complete row after unique code/scale determination and returns unresolved for ambiguous rows. The software evaluator implements adaptive refinement.

We will state these certification conditions explicitly in the revised abstract and methodology.


Q1: Attention Unresolved Outputs and Refinement

We evaluated 130 complete attention rows, including ordinary inputs and deliberately constructed boundary cases.

Table R2: Attention certification results.

Input categoryRowsCertifiedUnresolved
Ordinary inputs1181180
Constructed boundary inputs1266
Total1301246

All 31,744 committed FP8 element codes and 992 shared scale bytes match the independent mathematical reference. The six unresolved rows commit no output prefix.

The conventional FP32 baseline produces 24 code mismatches across three boundary rows, with zero scale-byte mismatches. All six long-row cases in Appendix D.2 also passed certification.

Our optimized fixed-Q40 implementation uses tenth-order Taylor interval enclosures, exact denominator reduction, storage/read-port sharing, buffered writeback, and clock gating. It completes a 64-token, 256-channel row in 71,157 cycles, compared with 123,780 cycles for conventional FP32.

The hardware reports an explicit certification status for each row; software refinement handles ambiguous cases. We will clarify this interface and the test categories in the revision.

W2 / Q4: Generalization to E5M2, Group Sizes, and NVFP4

We re-derived the SwiGLU numerical construction for E5M2 and validated its portability across group sizes and NVFP4.

(1) E5M2: Complete Numerical Certification

The E5M2 endpoint covers input canonicalization, SiLU states, multiplier binding, scale proposals, compact records, and final RNE.

Table R3: E5M2 numerical certification.

Verification itemCoverageResult
Active gate × positive-up combinations1,978,4430 failures
Signed input–scale contexts620,637,262Fully covered
Gate–consumer response cells6,948All certified
Independent MPFR boundary checks14,4370 failures
Maximum MPFR precision438 bitsVerified
Certified negative tails541Included
Relative-scale response checks398,3150 failures

The 620.6 million contexts are covered through semantic equivalence and sign symmetry, with directed-MPFR certification of the reduced decision-cell representation.

The E5M2 derivation also identified and resolved a Compact16 encoding-range boundary case at g=2−136g=2^{-136}, u=2−3u=2^{-3}, and q=−127q=-127. The corrected record 0x1d01 produces the expected E5M2 code 0x08.

(2) Group Sizes 16–256

We validated E4M3FN and E5M2 across five group sizes using re-quantized Qwen activation captures.

Table R4: Complete-block validation across group sizes.

Group sizeComplete blocksElement evaluationsProposal/Code/Scale mismatches
1632,768524,2880/0/0
3216,384524,2880/0/0
648,192524,2880/0/0
1284,096524,2880/0/0
2562,048524,2880/0/0
Total63,4882,621,4400/0/0

Across 20 format/model/group-size configurations, all blocks match the independent reference. Another 1,077 exceptional/boundary blocks also passed.

Each block uses a legal shared input scale. Group-32 follows standard MXFP8; the other sizes use generalized block-scaled FP8 semantics.

(3) NVFP4: Practical Quantization Contract

We adapted the method to E2M1 elements, group-16 E4M3 block scales, and a fixed FP32 global scale.

Table R5: NVFP4 numerical agreement on 13,049,856 Qwen3.5-4B outputs.

MetricOriginal FP16 CUDAOptimized Wide-State
Element-code mismatches8,2961
Scale mismatches1,8620

Table R6: NVFP4 CUDA endpoint latency on RTX 6000D, N=9,216.

MOriginal FP16 CUDA (µs)Optimized Wide-State (µs)Speedup
112.6361.7357.28×
1612.8682.2135.82×
12816.1646.1572.62×
17719.9817.9382.52×

The CUDA implementation uses cooperative data layout and optimized division processing. These experiments establish complete E5M2 numerical certification, zero-mismatch block validation across 20 configurations, and effective NVFP4 deployment under a distinct scaling contract.

We will include the format-specific derivations and results in the revision.


W3 / Q2: Hardware Baselines and Practical Efficiency

We added conventional BF16 LUT and FP32 arithmetic references with matched endpoint conditions.

Table R7: Hardware comparisons.

EndpointReferenceMain result
SwiGLUSame-ROM BF16 LUT25.71% less area; 24.33% less energy
RMSNormFP32-32 + Clock Gating33.20% fewer cycles; 13.83% less energy; 24.48% lower area–delay product
AttentionConventional FP3242.51% fewer cycles; 63.22% less row energy
SwiGLU transport (ASAP7)Directed15, matched storage7.4% less area; 3.0% less energy

Table R8: Complete-row conventional-baseline comparison.

MetricRMSNorm FP32RMSNorm OursAttention FP32Attention Ours
Cell area (µm²)465,896526,711127,926254,215
Cycles/row28,42618,989123,78071,157
Energy401.84 pJ/output346.28 pJ/output14.863 µJ/row5.467 µJ/row

For RMSNorm, exact code/scale agreement is achieved across 2,621,440 outputs, with a 24.48% lower area–delay product. For attention, the design uses 1.99× cell area to obtain the reported latency and energy improvements with certified output commitment.

Nangate45 measurements cover complete computation endpoints. The ASAP7 experiment evaluates compact state transport with matched storage, while NVFP4 provides RTX 6000D CUDA measurements. Attention hardware is evaluated from FP32 scores/BF16 values to group-32 MXFP8 outputs.

We will document the endpoint boundaries and measurement configurations in the revised manuscript.

W4 / Q3: Matched-Native Evaluation and Operator Coverage

Matched-native retains framework arithmetic under the same quantization interfaces as Replacement.

Table R9: Matched-native versus Replacement (%).

ModelMethodGSM8KHumanEvalGPQA-Diamond
DeepSeek-V4-Flash-0731Matched-native95.4590.8589.90
Replacement95.6891.4690.91
Qwen3.5-9BMatched-native92.8087.2079.29
Replacement93.6389.6380.30
Qwen3.8-27BMatched-native95.9196.9590.40
Replacement95.9897.5691.41

Replacement achieves higher scores in all nine matched-interface comparisons.

For Qwen3.5-9B, replacement covers 32 SwiGLU, 65 residual RMSNorm, and eight full-attention sites; linear-attention branches retain their framework implementation.

We will document the replacement coverage and single-operator isolation protocol in the revision.

The additional results establish numerical portability, certified output behavior, and hardware efficiency across the evaluated contracts.

Reviewer_ZFJ7OpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper presents a sufficient state framework for efficient non-linear computation for operators like SwiGLU, RMSNorm and softmax attention in scaled FP8 format. Authors present joint replacement of all three operators in DeepSeek-V4-Flash, Qwen3.5-9B and Qwen3.8-27B gives scores comparable to native on GSM8K, HumanEval and GPQA-Diamond.

Critical strengths
  • Paper is easy to follow with clear motivation. Rounding SiLU too early leads to a loss in determining which side of a rounding midpoint the true value lies on and that can flip the final FP8 code after mult and scale selection.
  • Authors present exhaustive results. Table 1 pins down scale selection, ties, saturation, signed zeros, NaN handling and empty groups, which hardware papers rarely do. Proposition 2 shows that suffix-query state needs 8,383 labels, or 14 bits.
  • Real hardware results add value to the manuscript. Designs are routed and meet timing at 400 MHz, with matched I/O boundaries, three placement seeds and useful ablations: forced direction bit, early commitment, G8–G11 precision sweep and the transport comparison.
Critical weaknesses
  • RMSNorm and attention compare exact against exact, which is fair, but no conventional reference is given to show the absolute overhead of exactness. SwiGLU lacks a same-ROM BF16 lookup-table baseline that would separate “LUT vs polynomial” from “exact vs not”.
  • Matched-native results (F.2) are missing, so the paper does not show whether exactness improves accuracy over a conventional FP8 interface.
  • Table 3 energies (15,906 and 165,392 pJ per output) are either mislabeled per-row figures or very large compared with SwiGLU’s 29 pJ per element.
Questions for authors

See above.

3 comments

Dear Reviewer ZFJ7,

Thank you for your constructive review. We conducted additional experiments with a matched BF16 LUT baseline, conventional FP32 RMSNorm and attention implementations, and Matched-native model evaluation.


W1: Conventional Baselines and Hardware Efficiency

(1) SwiGLU: Same-ROM BF16 LUT Baseline

We implemented a BF16 LUT endpoint using the same 4,318 semantic addresses and standard-cell ROM architecture as our G11 design. Both use Nangate45 typical, 400 MHz, the same activity stream, and complete datapaths including multiplication, state storage, scale reduction, and final quantization.

Table R1: SwiGLU hardware comparison.

MetricBF16 LUTG11 ROM (Ours)Improvement
Routed area (µm²)21,974.516,325.825.71%
Energy (pJ/element)38.269328.958224.33%
Clock target400 MHz400 MHzMatched

G11/Compact16 reduces area by 25.71% and energy by 24.33% relative to the BF16 LUT baseline. The original comparison between ROM and coefficient generation, with G11/Compact16 fixed, further demonstrates 18.09% area and 6.17% energy reductions. These comparisons quantify the benefits of decision-preserving state representation and ROM-based generation separately.

(2) RMSNorm: Conventional FP32 Baseline

We implemented FP32-32 + Clock Gating, using FP32 sum-of-squares accumulation, approximate rsqrt, full 32-bit intermediate products, arithmetic resource sharing, and integrated clock gating.

Both designs use BF16 inputs, FP32 weights, a complete 2,560-element row, group-32 MXFP8 output, Nangate45 typical, and 400 MHz, including all internal buffers and control logic.

Table R2: RMSNorm numerical agreement and complete-row efficiency.

MetricFP32-32 + Clock GatingCertified RMSNorm (Ours)Change
Code/scale mismatches73/00/0Exact agreement
Cycles/row28,42618,989−33.20%
Total energy (pJ/output)401.84346.28−13.83%
Dynamic energy (pJ/output)166.65169.78+1.88%
Leakage energy (pJ/output)235.19176.50−24.96%
Cell area (µm²)465,896526,711+13.05%
Area–delay product (normalized)1.0000.7552−24.48%

Across 1,024 rows and 2,621,440 outputs, our implementation achieves exact final code/scale agreement, 33.20% fewer cycles, 13.83% lower total energy, and a 24.48% lower area–delay product, with 13.05% additional area.

The optimized design uses exact boundary evaluation and 36-bit/element records plus a 9-bit group exponent header, reducing row-state storage by 9.30%. Buffer reuse, compact comparison states, and write gating shorten execution and reduce accumulated leakage energy by 24.96%.

(3) Attention: Conventional FP32 Baseline

We implemented a conventional FP32 arithmetic endpoint with approximate exponential evaluation. Both endpoints use the same 64-token, 256-channel row, group-32 MXFP8 output, Nangate45 typical, and 400 MHz.

Table R3: Attention hardware comparison.

MetricFP32 BaselineCertified Attention (Ours)
Cell area (µm²)127,926254,215
Cycles/row123,78071,157
Average power (mW)48.0330.73
Energy/row (µJ)14.8635.467

Our optimized endpoint reduces row cycles by 42.51% and energy by 63.22%, using 1.99× cell area. It combines tenth-order Taylor interval enclosures, exact denominator reduction, storage/read-port reuse, buffered writeback, and integrated clock gating.

Table R4: Attention certification results.

Test categoryRowsCertifiedUnresolved
Ordinary inputs1181180
Constructed boundary inputs1266
Total1301246

All 31,744 committed FP8 codes and 992 scale bytes match the independent mathematical reference. Ambiguous rows return unresolved without committing output prefixes. On the same boundary set, the FP32 baseline produces 24 code mismatches across three rows, with zero scale-byte mismatches.

We will incorporate these results and the baseline configurations in the revised manuscript.

W2: Matched-Native Model Evaluation

We completed Matched-native evaluation on three models and three benchmarks. Matched-native retains framework arithmetic while applying the same quantization interfaces as Replacement.

Table R5: Model accuracy under matched quantization interfaces (%).

ModelMethodGSM8KHumanEvalGPQA-Diamond
DeepSeek-V4-Flash-0731Native95.6892.6889.90
Matched-native95.4590.8589.90
Replacement95.6891.4690.91
Qwen3.5-9BNative93.0387.8081.31
Matched-native92.8087.2079.29
Replacement93.6389.6380.30
Qwen3.8-27BNative95.9196.9590.91
Matched-native95.9196.9590.40
Replacement95.9897.5691.41

Replacement achieves higher scores in all nine matched-interface comparisons. For Qwen3.5-9B, the gains are 0.83, 2.43, and 1.01 percentage points on GSM8K, HumanEval, and GPQA-Diamond, respectively.

We will add the matched-interface results and evaluation protocol to the revision.


W3: Energy Units and Normalization

The original Table 3 reports energy in pJ per final output element. The original RMSNorm and attention values, 15,906 and 165,392 pJ/output, correspond to 40.719 and 42.340 µJ per complete row, respectively.

We additionally report the optimized endpoints against conventional baselines.

Table R6: Updated energy measurements.

EndpointEnergy (pJ/output)Energy (µJ/row)
RMSNorm FP32-32 + Clock Gating401.841.0287
RMSNorm (Ours)346.280.8865
Attention FP3258,058.5914.863
Attention (Ours)21,355.475.467

Energy accounting includes routed endpoint computation, internal state, control activity, and dynamic/leakage components. We will update Table 3 with explicit units, activity windows, and implementation configurations.

Thank you for addressing my concerns. I have raised my ratings based on these results

Comments on the paper

1 comment
Area_Chair_s2s7OpenReview ↗

Action Required: Respond to Author Rebuttals Before the Discussion Period Ends

Dear Reviewers,

The authors have posted their rebuttals. As the author–reviewer discussion period is coming to a close soon, please read their responses and participate in the discussion.

All reviewers are expected to respond, at minimum with a brief acknowledgment confirming that the reviewers have read and considered the authors’ rebuttals. If your concerns have been addressed or remain unresolved, please briefly indicate this in your response.

Thank you for your time and effort.

Best,

Your AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.