acceptodds
Under review as a conference paper at ICLR 2027

RONDO: Interleaved Datapaths for Division-Bearing Neural Recurrences

Abstract

Regulated domains such as finance and healthcare, where law requires automated decisions affecting individuals to be explainable, need machine learning models with auditable predictions. This requirement motivates interpretable architectures such as continued-fraction networks (CoFrNets) and Chebyshev Kolmogorov-Arnold networks. Each architecture’s functional form exposes the reasoning behind every prediction. Internally, both architectures evaluate a second-order recurrence where each step depends on the two before it. However, this recurrence creates a bottleneck that limits existing hardware (GPUs and vector processors) to as little as 29% of its matrix-multiply rate and 44.5% of ideal parallel speedup. The bottleneck stems from serial dependence, as each step must wait for the previous result. On a five-stage pipeline, fast floating-point hardware therefore idles four fifths of the time, reducing throughput fivefold. This loss limits how quickly these regulated domains can deliver auditable decisions. To address this bottleneck, we propose RONDO, a hardware datapath that evaluates second-order recurrences with input-dependent coefficients, enabling interpretable models to deliver auditable decisions at low latency, high throughput, and low power and area. RONDO computes each recurrence with multiply-adds and at most one division. To keep that divider busy despite the recurrence’s serial dependence, RONDO time-multiplexes independent evaluations onto it, advancing each in turn. We evaluate RONDO on a Kintex-7 FPGA against existing hardware, including an RTX 5090 GPU, the Ara vector processor, and PolyKAN accelerator that divides at every recurrence step. When scaled to a common process node using published scaling factors, RONDO offers 43× lower latency and 9.5× lower energy per evaluation than the best-performing baseline (RTX 5090 GPU). RONDO also achieves 102 × and 105× the throughput of Ara and PolyKAN accelerator, respectively.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Hardware accelerator, Interpretable machine learning, Second-order recurrence computation, Low-latency inference

Reviews

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

The work presents a specialized hardware accelerator for second-order recurrences arising in Continued-Fraction Networks (CoFrNets) and Chebyshev Kolmogorov-Arnold Networks (KANs). However, the novelty of the architectural techniques and the interpretation of cross-platform performance comparisons require further clarification.

Critical strengths
  1. Systematic hardware optimization. The paper identifies several practical bottlenecks. The proposed optimizations address these issues at different stages of the datapath rather than focusing on a single arithmetic operator.
  2. Substantial implementation and evaluation effort. The implementation results demonstrate considerable engineering effort and support the feasibility of the proposed design.
Critical weaknesses
  1. Insufficient justification of the specialized datapath. RONDO primarily combines general optimization techniques, including pipelined FMA units, interleaved execution, and parallel accumulation. While the implementation is effective, the paper does not sufficiently demonstrate what architectural advantages arise specifically from its fixed hardware scheduling. For eaxmple, Sections 2.3 and 5.2 emphasize RONDO's superior scaling efficiency over Ara, but it remains unclear whether the Ara implementation has been sufficiently optimized to exploit independent ladder computations through software scheduling and vectorization. Consequently, the comparison does not fully establish the benefits of the proposed specialized architecture over a programmable implementation of the same recurrence.
Questions for authors
  1. How was the Ara RVV baseline programmed to exploit independent ladder computations? Were vectorization across ladders, loop unrolling, and instruction scheduling considered to reduce pipeline stalls? Could the authors clarify which limitations of the programmable architecture cannot be addressed through software optimization and therefore motivate RONDO's fixed scheduling approach?

  2. Section 4.3 requires at least six independent ladder contexts per lane for stall-free execution, while the main experiments use 64 ladders distributed across up to eight lanes. How does RONDO perform when the number of independent ladders per lane falls below this requirement? Does the architecture introduce pipeline stalls, redistribute workloads across lanes, or interleave multiple inputs? How would these choices affect batch-1 latency and hardware utilization?

  3. Inconsistent hardware specifications and presentation errors. Section 4.4 reports 16 MB of BRAM for the XC7K325T, whereas Section 5.3 reports approximately 2 MB. The former appears to be a unit error, as the device provides approximately 16 Mb of BRAM. Additionally, the Abstract identifies the CPU baseline as Ryzen 9960X, while Appendix A.5 specifies Ryzen 9 9950X, which are different processors. Section 3 also contains substantially duplicated descriptions in Steps 1 and 2. These inconsistencies should be corrected to improve the accuracy and reproducibility of the evaluation.

4 comments

We thank the reviewer for the constructive questions, which we address below.

W1 / Q1 (Ara baseline). We thank the reviewer for this question. We have implemented and optimized the complete layer on Ara, which still needs 5.2× more cycles per ladder than RONDO.

  • How was Ara programmed? The revision implements the complete CoFrNet layer on Ara, not only the recurrence, and every variant is bit-identical to a scalar reference (Section 5.2, "Ara"; Appendix A.7, Table 8, Figure 6). The submission compared Ara's recurrence alone with RONDO's complete layer, and Section 2.2 ("Motivation") now reports the full-layer comparison.
  • Vectorization across ladders? Yes. Coefficient generation is vectorized across the 448 coefficients of an input (64 ladders × 7), and the recurrence across ladders.
  • Loop unrolling? Yes. The coefficient loop is unrolled across two to eight inputs per weight load, and register grouping (LMUL 2 to 8) widens each instruction.
  • Instruction scheduling? Yes. Weight loads are software-pipelined behind the multiply-adds, and we removed the two compiler-generated register moves per multiply-add in the submitted recurrence kernel (7.88 to 2.27 cycles per ladder).
  • Result: At eight lanes, the best of seven Ara variants needs 30.0 cycles per ladder, 5.2× more than RONDO's 5.81. Even at its peak floating-point rate, Ara would need 17.5 cycles per ladder. With four inputs per weight load, Ara reaches 82%, 71% and 58% of this peak at two, four and eight lanes. Its scaling efficiency from two to eight lanes is 71%, compared with 99.6% for RONDO. Ara's simulated memory responds in one cycle, which favors Ara.
  • Limits software cannot remove: Even after optimization, Ara's speed is limited by two features of its hardware. First, Ara executes every multiply-add as a vector instruction on the same functional units. The coefficients produced by the dot products must therefore be written to the vector register file and read back by the recurrence, and both stages compete for two fp32 multiply-adds per lane. Software can reorder these instructions, but it cannot add functional units or bypass the register file. For this reason, even full use of the floating-point units would leave Ara at 17.5 cycles per ladder, 3.0× more than RONDO. Second, Ara has no local weight store. Each input requires 72 KB of weights, which stream from memory through a port of one fp32 word per lane per cycle. Sharing each weight load across several inputs hides this cost, but a single input cannot share loads, and Ara is then limited by memory bandwidth to 53.5 cycles per ladder, 9.2× more than RONDO. RONDO avoids both limitations by design. Each lane stores its weights on chip and generates every coefficient next to the recurrence that consumes it, and its fixed rotation issues one operation per cycle without hazard checks (Sections 4.3 to 4.5).

Q2 (fewer ladders than slots). We thank the reviewer for this question. The slot count N is fixed at build time and must satisfy N ≥ L_fma + 1 = 6, and each lane of the evaluated layer holds eight ladders. When a lane holds n < N ladders (Section 4.3):

  • Performance: Results remain correct, with the same schedule. The N − n empty slots carry zero coefficients, which leaves the rotation and its hazard-free timing unchanged. Six slots, the minimum, run at 6.63 cycles per ladder (eight lanes, L = 96; Appendix A.12, Table 17).
  • Pipeline stalls? None.
  • Redistribution across lanes? Not needed, as lanes share no state.
  • Interleaving multiple inputs? Yes, optionally. Empty slots can hold ladders of other inputs, which restores full utilization.
  • Batch-1 latency: Unchanged, since a recurrence step still takes one rotation of N cycles.
  • Utilization: Only the recurrence multiply-add idles, in a fraction 1 − n/N of its cycles, while the coefficient stage, 98% of the work, is not padded.

Q3 (inconsistencies). We thank the reviewer for the careful reading. All three are errors, and we have corrected each of them.

  • BRAM: The XC7K325T provides 16 Mb (about 2 MB); Section 4.4 now states this.
  • CPU: The baseline is one core of an AMD Ryzen 9 9950X (Section 5.1; Appendix A.5). "9960X" was incorrect, and the abstract no longer names the model.
  • Section 3: In the submission, Step 2 repeated the text of Step 1 through an editing error. The steps are distinct: Step 1 counts the operations each stage requires and performs, and Step 2 measures the area, delay and power of each routed module. Step 2 thereby exposes costs that are not arithmetic, such as the coefficient multiplexer (63% of the area, 2% of the dynamic power) and the reciprocal stage (54% of the scan and reciprocal power). The revision restores Step 2, and Table 1 lists the bottlenecks each step exposes.

Thank you to the authors for their response. I appreciate their efforts in revising the manuscript and conducting additional experiments. The authors have addressed most of my concerns. However, although the implementation is effective, RONDO primarily combines existing general-purpose optimisation techniques without introducing substantial methodological novelty or offering new insights into the challenges being addressed. Therefore, I still consider this work to be borderline, with neither a sufficiently strong reason to accept it nor a critical weakness that would clearly justify rejection.

Dear Reviewer,

As the discussion period ends today, we would appreciate your consideration of our rebuttal and additional results. We hope they address your concerns and would welcome any remaining questions. Thank you for your time and consideration.

We thank the reviewer for their comments and are grateful for the soundness score increase. However, we would argue that our work is not just an implementation of existing methods.

RONDO is more than a combination of existing methods. Our key insight concerns where the cost lies. CoFrNet ladders and Chebyshev KAN edges compute the same input-dependent second-order recurrence, yet the recurrence performs only 2% of the arithmetic. The dot products that generate its coefficients perform 98%, and moving their results took 63% of the FPGA lookup tables. Our interleaving is therefore not an implementation of C-slow retiming or barrel processing. Those methods rotate streams or threads that are already independent through one loop. RONDO instead decomposes each layer into independent accumulations and schedules them, together with the recurrence, under one rotation bound, Nd/NPAR ≥ L_fma + 1. Both stages then run without stalls or forwarding, and each coefficient keeps its accumulation order and is computed where it is used. One datapath serves both models, and an optimized vector processor still needs 5.2× more cycles.

We thank the reviewer again for their time and effort.

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

The paper presents RONDO, a hardware accelerator for recurrence computations in continued-fraction networks and Chebyshev KANs. It reduces repeated divisions and interleaves independent computations to improve pipeline utilization. The authors evaluate the design through an FPGA implementation and ASIC synthesis, with comparisons against CPUs, GPUs, and existing KAN accelerators. For CoFrNet evaluation, the ASIC synthesis results indicate a 2.0–3.3× speedup over an RTX 5090 GPU with 6.2–10× lower energy per ladder. The paper also reports near-linear scaling from two to eight lanes and preservation of all reference classification decisions on the three evaluated datasets in fp32.

Critical strengths
  1. The paper clearly explains the challenges of accelerating recurrence computations in CoFrNets and Chebyshev KANs. The connection between these challenges and the proposed design choices makes the approach reasonably easy to follow.
  2. The work includes an FPGA implementation, ASIC synthesis estimates, and comparisons with several baselines. The experiments comparing individual design choices help readers understand where the improvements come from.
  3. The reported lane-scaling results and the preservation of reference classification decisions in fp32 provide encouraging evidence for the tested workloads. Supporting both CoFrNets and Chebyshev KANs also makes the design potentially useful across two model families.
Critical weaknesses
  1. The main trained-model experiments focus on three relatively small tabular datasets. Additional experiments with different model sizes and recurrence depths would help clarify the range of workloads that benefit from the design.

  2. Some components of a complete deployment, including output projection, production weight loading, and host data transfer, are outside the current evaluation. A simple end-to-end example or estimate would make the practical benefits clearer.

Questions for authors
  1. Could the authors explain how the evaluated model sizes and recurrence depths were chosen? A brief discussion of whether similar benefits are expected for larger models or different depths would help clarify the applicability of the approach.

  2. Could the authors provide a simple estimate or illustrative example of the end-to-end inference benefits when output projection, weight loading, and host data transfer are included? This would help readers understand the practical impact of the reported improvements.

3 comments

We thank the reviewer for the constructive questions. We have clarified the choice of model sizes and depths, reported other configurations and added an end-to-end estimate in the revised manuscript.

Q1 / W1 (model sizes and depths). We thank the reviewer for this question. The configuration follows the original CoFrNet work, and utilization is maintained or improved for deeper and larger layers.

  • How were they chosen? The datasets and the depth d = 7 follow the original CoFrNet work, and L = 64 fills eight lanes of eight slots (Section 5.1, "Workloads").
  • Similar benefits at other depths? Yes. From d = 3 to 24, utilization remains at 75–81% in the coefficient stage and 65–73% across all multiply-adds (Section 5.3, Table 4).
  • Similar benefits for larger models? Yes, up to p = 768 inputs and 256 ladders on 32 lanes. Utilization rises from 43% at p = 10 to 98% at p = 768 in the coefficient stage (42% to 87% across all multiply-adds). Throughput also scales almost linearly: 32 lanes deliver 31.9× the throughput of one, a scaling efficiency of 99.5%, and throughput per unit area stays within 1.4% of the eight-lane value. Every configuration in Table 4 preserves all reference decisions, although we measured energy only at the evaluated configuration.
  • Limits for larger models: The paper states two limits at language-model scale. First, a CoFrGeNet-size layer must stream its 8.3 MB of bf16 weights from off-chip memory (Section 5.3). Second, bf16 is not accurate enough at that size, and even an fp32 coefficient accumulator agrees on only 85.9% of decisions (Section 5.4; Appendix A.10, Table 14).

Q2 / W2 (end-to-end estimate). We thank the reviewer for this suggestion. With output projection, weight loading and host transfer, one Waveform inference takes an estimated 0.363 µs and 33.0 nJ, against 6.27 µs and 640,000 nJ for the GPU at batch 1 with launch (Section 5.3; Appendix A.15, Table 20).

  • Output projection: 192 multiply-adds for three classes, 1.1% of the layer's 17,920, which take at most 0.004 µs and 0.4 nJ.
  • Weight loading: 36 KB of bf16 weights, which are loaded once and reused for every input.
  • Host transfer: 86 bytes per inference, which take 0.006 µs on a 128-bit on-chip bus at the layer's clock.
  • Accuracy: Decision agreement is unchanged. The projection and transfer costs are estimates, as Section 5.4 states.

Dear Reviewer,

As the discussion period ends today, we would appreciate your consideration of our rebuttal and additional results. We hope they address your concerns and would welcome any remaining questions. Thank you for your time and consideration.

I thank the authors for their detailed response. The rebuttal has adequately addressed my concerns, and I have no further questions. I will maintain my original rating. I encourage the authors to incorporate the clarifications and additional results into the final version.

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

This paper proposes a hardware accelerator, RONDO, for second-order computation in CoFrNet and Kolmogorov Arnold networks. RONDO uses multiplication, addition, and division at most once to calculate the original multiple loop operations, and improves pipeline utilization through interleaved execution. The author implemented RONDO through FPGA and comprehensively evaluated it with ASAP7, and compared its speed and energy consumption with RTX 5090 GPU and CPU, achieving a significant improvement.

Critical strengths
  1. This paper provides concrete hardware implementations and experimental analysis. The authors consider recurrence computation, coefficient generation, and data routing, and demonstrate the effects of individual optimizations through design ablation experiments. The FPGA results support the feasibility of the proposed architecture in practical applications.

  2. Through a mathematically equivalent transformation, the method replaces multiple sequential divisions in continued-fraction evaluation with multiply–add operations and at most one final division, mapping this computation and the second-order recurrence in Chebyshev KANs to the same type of datapath, thereby reducing the overhead of sequential divisions.

Critical weaknesses
  1. The core design mainly combines an existing equivalent transformation of continued fractions, interleaved execution of independent recurrences, and relatively standard hardware optimizations. The paper lacks sufficient discussion of related pipeline interleaving methods and does not clearly explain the substantive novelty of this combination beyond a direct application of existing techniques. Therefore, although the implementation has some engineering value, the distinctiveness of its research contribution remains unclear.

  2. The forward computation clamps the denominator, but the closed-form gradient in the appendix is derived from the unclamped quotient function. Simply substituting the clamped reciprocal does not yield the true gradient in the region where clamping is active. The gradient tests in the supplementary code also explicitly avoid this region. The authors should clarify whether this backward path intentionally uses a surrogate gradient and provide supporting justification and validation, or correct the gradient formula and implementation.

  3. The paper’s main performance and energy advantages over CPU/GPU baselines rely on pre-layout ASIC estimates. Its multi-lane results are extrapolated from a single lane and exclude clock-tree and interconnect parasitic overheads. Furthermore, the energy accounting boundaries differ across platforms, and the evaluation does not cover complete model execution and data transfers. Therefore, the current results demonstrate the potential of the compute core but do not sufficiently substantiate its latency and energy advantages in practical deployment.

Questions for authors
  1. The main experiments currently use a fixed configuration of (L=64,d=7) and evaluate at most eight lanes. How do pipeline utilization, actual throughput, and area efficiency change with recurrence depth, input dimensionality, and lane count?

  2. The current eight-lane ASIC results are extrapolated from single-lane synthesis results and exclude clock-tree and interconnect parasitic overheads. Could the authors provide post-place-and-route results for a multi-lane implementation, or at least a sensitivity analysis of these overheads? How much of the reported advantage remains when energy accounting boundaries are aligned across platforms?

  3. Table 9 shows that direct recurrence evaluation is faster than PolyKAN’s lookup-table implementation within the same GPU kernel. Could the authors include this recurrence-based version and the existing fused GPU implementations in the main comparison, reporting latency, throughput, and energy consumption across different batch sizes under matched computational scope and precision requirements? Do RONDO’s advantages over these baselines still hold?

  4. The gradient derivation in Appendix A.3 is based on the unclamped K1/K0K1/K0, whereas the actual forward computation clamps the denominator. Do the authors intentionally use a surrogate gradient in the clamped region? For example, when d=2d=2, a0=−0.995a0=-0.995, a1=1a1=1, and epsilon=0.01epsilon=0.01, the forward output remains constant at 100 in a local neighborhood of a0a0, so its true derivative with respect to a0a0 is 0, but the implemented gradient formula gives −10000-10000. Could the authors explain this discrepancy and provide gradient validation in the region where clamping is active? If a surrogate gradient is used, could they explain its impact on training stability and outcomes?

  5. Could the authors provide end-to-end inference experiments on representative complete models, including necessary preprocessing and output projection, and report task accuracy, latency, and energy consumption? This would help determine whether the computational advantages translate into deployment benefits for complete models.

2 comments

W1 (novelty). We thank the reviewer for recognizing the engineering value of RONDO. We agree that its distinction from existing interleaving should be explicit, and summarize it below.

  • Related methods: Section 2.2 now covers C-slow retiming and barrel processors; RONDO's slot rotation is C-slow interleaving of one multiply-add (Section 4.3).
  • Novelty: These methods interleave only the recurrence. Our novelty is threefold. First, our bottleneck analysis shows that the dot products generating the coefficients account for 98% of the arithmetic (Section 3). Second, we extend interleaving to these dot products, allowing both stages to share one hazard-free rotation without forwarding logic (Section 4.5). Third, we eliminate coefficient movement, which otherwise requires a multiplexer occupying 63% of the FPGA lookup tables. Each lane instead stores its weights on chip and generates every coefficient at its point of use, and only x crosses lane boundaries (Section 4.4).

Q1 (d, p, lanes; Section 5.3, Table 4). We thank the reviewer for this question. Utilization remains high, throughput scales with lanes (99.5% efficiency at 32 lanes), and area efficiency peaks at the evaluated point.

variedutilization: coefficient stage / all multiply-addscycles per ladderarea efficiency
d = 3 → 2475–81% / 65–73%4.67 → 18.830.91, 0.85, 1.00, 0.77, 0.49
p = 10 → 76843 → 98% / 42 → 87%2.53 → 85.40.74, 0.95, 1.00, 0.86, 0.55, 0.25
lanes 1 → 32constant per lane46.28 → 1.45within 1.4% (8 → 32)
  • Area efficiency: This is useful work per lane area, including weights, relative to d = 7, p = 40. It falls at large d and p, as weight memory grows while the arithmetic does not. At p = 768, weights occupy 65% of the lane, whereas the datapath alone stays at 0.88–1.06 up to p = 256. Any design keeping all weights on chip pays this cost, while streaming them, as Ara does, is bandwidth-limited (Section 5.4).

Q2 / W3 (routed layout, aligned energy). We thank the reviewer for this suggestion. We have routed the complete eight-lane layers in ASAP7 with parasitics, clock tree and clock gating (Tables 2, 9).

eight lanes, bf16CoFrNet: extrapolated → routedKAN: extrapolated → routed
clock (MHz)1,194 → 1,054 (−12%)1,193 → 1,027 (−14%)
area (mm²)0.067 → 0.063 (−6%)0.096 → 0.091 (−5%)
energy per output (nJ)0.72 → 0.509 (−29%)1.03 → 0.680 (−34%)
of which clock tree (nJ)— → 0.101— → 0.184
GPU advantage, aligned6.2× → 8.9×— → 2.5×

With aligned boundaries (Section 5.1), the GPU advantage is fully retained.

Q3 (GPU kernels across batch sizes). We thank the reviewer for this suggestion. RONDO keeps its energy and latency advantages at every batch size.

  • Included in the main comparison? Yes. Section 5.2 (Table 3, Figure 4) uses the best fused or recurrence-based PolyKAN kernel at each batch size, at matched scope and precision.
  • Energy: The advantage holds at both precisions. In bf16, it falls from 19,600× at batch 1 to 8.9× at batch 262,144 for CoFrNet, and from 7,800× to 2.5× at batch 65,536 for KAN (Figure 4; Table 7).
  • Latency: RONDO answers one input in 0.353 µs, 2.9× faster than the fastest batch-1 GPU kernel.
  • Throughput: A RONDO layer delivers 181 M outputs/s, while the GPU reaches 104 G outputs/s only at batch 262,144.

Q4 / W2 (gradient in the clamped region). We thank the reviewer for the careful analysis. The surrogate is intentional, as in the reference CoFrNet implementation. Appendix A.3 now states this and adds the exact gradient.

  • The discrepancy: The closed form differentiates the unclamped K₁/K₀. Where |K₀| < ε, the output is K₁/(±ε), and the true derivative is zero with respect to a₀ and (∂K₁/∂aⱼ)/(±ε) otherwise (Equation 7). In the reviewer's example, the surrogate gives (−10,000, 10,000) and the exact gradient (0, 100).
  • Validation: Finite differences match the exact gradient within 3×10⁻⁷ at seven clamped points, including this example.
  • Stability and outcomes: Neither is affected. Across 180 runs under four rules, including the exact one, test accuracy agrees within 0.49 points (Table 5), and none of 2.5 million steps produced a non-finite value.

Q5 (end-to-end). We thank the reviewer for this suggestion. We provide an estimate for the full Waveform model, not a measurement (Section 5.3; Appendix A.15).

  • Output projection: Included, 1.1% of the layer's multiply-adds.
  • Preprocessing: Not needed at run time. The models standardize each feature with a fixed mean μ and deviation σ, and this affine map folds into the first layer's weights and biases (Appendix A.15).
  • Latency and energy: 0.363 µs and 33.0 nJ, with weight loading and host transfer, against 6.27 µs and 640,000 nJ for the GPU at batch 1 with launch.
  • Task accuracy: 85.20% (bf16) and 85.47% (fp32), with every fp32 decision preserved (Table 12; Appendix A.18).

Dear Reviewer,

As the discussion period ends today, we would appreciate your consideration of our rebuttal and additional results. We hope they address your concerns and would welcome any remaining questions. Thank you for your time and consideration.

Comments on the paper

1 comment

We thank the reviewers for their time and careful reading of our submission. Taking their comments into account, we have made the following modifications to our manuscript:

Reviewer g714: We have added a discussion of related pipeline-interleaving methods, C-slow retiming and barrel processors, to Section 2.2, and restated our contributions in Section 1. Section 5.3 and Table 4 now report utilization and cycles per ladder across depth, input dimension and lane count. Section 5.2 and Table 2 report the complete eight-lane layers after placement and routing, and Appendix A.8 (Table 9) compares them with the pre-layout estimates of the submission. Section 5.1 defines aligned energy boundaries, and Section 5.2 (Table 3, Figure 4) and Appendix A.6 (Table 7) compare RONDO with fused and recurrence-based GPU kernels across batch sizes. Appendix A.3 adds the exact gradient in the clamped region and a training comparison of four gradient rules (Table 5). Section 5.3 and Appendix A.15 (Table 20) add an end-to-end estimate.

Reviewer DuhW: Section 5.1 now explains the choice of datasets, depth and layer width, and Section 5.3 (Table 4) reports the behavior at other depths and input dimensions. Section 5.3 and Appendix A.15 (Table 20) add an end-to-end estimate that includes the output projection, weight loading and host transfer.

Reviewer ZP9y: We have replaced the Ara comparison with an optimized implementation of the complete layer (Section 5.2; Appendix A.7, Table 8, Figure 6). Section 4.3 and Appendix A.12 (Table 17) discuss lanes that hold fewer ladders than slots. We have corrected the BRAM capacity (Section 4.4) and the CPU model (Section 5.1; Appendix A.5), and restored the intended content of Step 2 in Section 3 (Table 1).

We have accordingly updated the abstract, contributions and conclusion with the placed-and-routed results.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.