XSci

Silent Degradation during Auto-Vectorization of bf16/fp16 on RISC-V Under LLVM

Vaishnavi Kouru, Robert Chun

Submitted by Vaishnavi Kouru

Published November 13, 2026 · Version v1, November 13, 2026 · DOI 10.66977/xsci.2611.001x

Programming Languages

Abstract

Low-precision numeric types such as 8-bit integers, bfloat16, and half-precision floating point (fp16) are often used in AI inference workloads to reduce memory bandwidth, and RISC-V's openly specified Vector extension (RVV) is a natural target for compiling such workloads with auto-vectorization. This paper examines whether LLVM's RISC-V auto-vectorizer handles these narrow types equally well, using a multiply-accumulate loop written for fp32, int8, bf16, and fp16. Under a common baseline target (-march=rv64gcv), int8 and fp32 vectorize cleanly, while bf16 and fp16 degrade to increasingly scalar-heavy fallback code, with fp16 falling back to per-element software conversion calls, unless additional target-feature extensions (zvfbfmin/zvfbfwma, zvfhmin) are enabled. Under QEMU user-mode emulation, the baseline bf16 and fp16 kernels execute 17.0×17.0\times and 75.9×75.9\times as many dynamic instructions as their extension-enabled counterparts. Compiler diagnostics do report this degradation, but do not distinguish, in their wording, between a limitation that a compiler flag resolves entirely and one reflecting an inherent conversion cost, leaving no direct signal toward the fix. These results are supported by assembly-level instruction analysis, by direct inspection of LLVM's optimization remarks, and by dynamic instruction counts collected under emulation.

View PDF

Review reports

xPeerd (AI review)

November 13, 2026

AI Review (xPeerd — DAReview)

Summary

This manuscript investigates whether LLVM’s RISC-V auto-vectorizer treats low-precision AI-relevant types consistently under a common baseline target. The central claim is clear and well supported within the study’s scope: under -march=rv64gcv, int8 and fp32 vectorize cleanly, whereas bf16 and fp16 degrade into scalar-heavy fallback paths unless additional narrow-type extensions are enabled. The paper’s main strengths are its focused experimental design, careful static assembly inspection, use of compiler optimization remarks, and dynamic instruction-count measurements under QEMU to quantify the severity of degradation. The manuscript also articulates a practical diagnostic gap: compiler remarks report degradation, but do not clearly indicate when a missing extension flag would fully resolve it. This contribution is concrete, technically relevant, and timely for RVV/LLVM users

The main weaknesses are limitations of external validity and evaluation breadth. The study is confined to one compiler family, one principal loop shape, emulated execution rather than hardware measurements, and a narrow set of kernels. Some interpretive claims about developer-facing “silent” degradation and practical impact are plausible, but occasionally stronger than what the current evidence directly demonstrates. Overall, the manuscript is coherent, technically grounded, and likely publishable after revision, especially if the authors sharpen claims, expand methodological transparency, and tighten presentation of generalizability limits

Potential Major Revisions

  1. Clarify the scope of the central claim and avoid overgeneralization

The manuscript’s strongest evidence concerns a very specific setup: Clang/LLVM on RISC-V, one baseline target, one main elementwise FMA loop shape, plus one int8 reduction-shaped comparison. Yet several formulations broaden the claim toward “AI-relevant narrow numeric types” in general. For example, the abstract states that “bf16 and fp16 degrade to increasingly scalar-heavy fallback code” and that this degradation is “silent in a practical sense” . Later, the conclusion states that LLVM’s RISC-V auto-vectorizer “does not handle AI-relevant narrow numeric types equally well under a single -march=rv64gcv target” .

This is directionally supported, but the evaluated evidence is still narrow. The manuscript itself acknowledges that “the kernel set is narrow (one or two FMA-shaped kernels per type) and does not establish how broadly this pattern holds across other loop shapes” . I think the paper should systematically align its headline claims with this limitation. In particular:

  • qualify claims as applying to the tested kernels and compilation conditions unless additional evidence is added;
  • distinguish between “observed here” and “expected more broadly”;
  • avoid implying that all AI-relevant uses of bf16/fp16 on RVV exhibit the same degradation pattern.
  1. Strengthen reproducibility details for the static and dynamic analyses

The methodology is generally solid, but some parts need more operational detail for independent reproduction. The manuscript reports that “all kernels were compiled with Clang 22 (22.1.8)” and that static results were also checked with Clang 23.1.3 and an LLVM 24 development build . It also explains the QEMU configuration and compilation parameters for benchmark binaries . However, the current text still leaves ambiguity on several implementation details:

  • exact source definitions for bf16 and fp16 types;
  • how arrays were initialized and whether denormals, NaNs, infinities, or adversarial values were excluded;
  • the exact QEMU instruction-count plugin settings;
  • whether the emitted code depended on static linking choices and runtime library version, especially given the acknowledged dependence on __extendhfsf2 implementation for fp16 baseline behavior .

Because the contribution depends heavily on compiler code generation details, the paper would benefit from a compact artifact appendix or precise repository pointer describing:

  • full compiler invocations;
  • source code for each kernel;
  • environment versions;
  • command lines for static inspection and dynamic measurement;
  • how loop bodies were isolated for instruction counting.
  1. Tighten the interpretation of “silent degradation”

One of the manuscript’s most interesting arguments is the diagnostic one. The paper claims that degradation is “silent in a practical sense: the build succeeds, the output is numerically correct, and no warning is printed unless optimization remarks are requested” . This is a useful observation, but the term “silent” may overstate the case unless more carefully delimited, because the authors also show that compiler diagnostics do report relevant information when the correct remark channels are enabled. For example, the paper quotes: “The compiler’s diagnostics show this distinction directly. Under the baseline flags, the vectorizer reports: remark: Scalable vectorization is not supported for all element types found in this loop” and also “remark: floating point conversion changes vector width...”

The manuscript should separate:

  • default compilation behavior, where no warning appears;
  • opt-in optimization remarks, where degradation is partially reported;
  • the narrower claim that the wording does not differentiate a fixable missing-extension issue from an inherent conversion cost.

That narrower claim appears well supported and is likely the sharper contribution.

  1. Expand discussion of validity threats around emulation-based performance inference

The manuscript is careful to say that dynamic instruction counts under QEMU “do not model pipelines, caches, memory bandwidth, or the per-element cost of vector instructions on a particular implementation” , and it explicitly notes that host wall-clock time is not a reliable hardware proxy because QEMU may implement instructions asymmetrically, as in the case where bf16 extension builds execute fewer instructions than fp32 but take longer on the host . This caution is appropriate.

However, some downstream interpretations still sound close to hardware-performance conclusions. For example, “storing weights in bf16 or fp16 to save memory can make the hot loop slower than leaving them in fp32” . This may be true on many targets, but strictly speaking the current evidence demonstrates a code-generation and instruction-count problem under emulation, not direct hardware slowdown across real implementations. The discussion should:

  • distinguish code quality, dynamic instruction expansion, and actual hardware performance;
  • state more explicitly where inference is empirical versus speculative;
  • perhaps rephrase practical claims as “can plausibly negate expected gains” unless hardware measurements are added.
  1. Justify the fairness of cross-type comparison more explicitly

The paper’s design deliberately uses the same loop template across fp32, bf16, and fp16, while int8 additionally includes both a reduction and an elementwise version to control for loop topology . This is a good design choice. Still, because the semantics differ across types, the manuscript should better justify why these are comparable instances for evaluating vectorizer behavior. For example, the background notes that in practical inference “16-bit floating-point inputs are widened to fp32 before the multiply-accumulate, and int8 products are accumulated in int32” . That means the widening pathways are inherently different.

The paper should explicitly discuss:

  • why equality of source-loop shape is the right control variable;
  • what aspects of backend behavior remain meaningfully comparable across int8 versus bf16/fp16;
  • whether differences in legal vector support are exactly the phenomenon under study or partly an artifact of mixed-precision semantics.

This will help prevent readers from interpreting the comparison as broader than intended.

  1. More directly substantiate the novelty claim against prior work

The manuscript states that prior studies “evaluate general-purpose or full-precision numeric workloads and do not specifically isolate the behavior of low-precision, AI-relevant types such as bf16, fp16, or int8” and that this study differs by focusing on narrow AI-relevant types and on diagnostic clarity . This seems plausible and likely true, but the related-work positioning would be stronger if the authors tabulate exactly what prior studies covered versus what this one adds:

  • compiler(s);
  • ISA target(s);
  • loop/kernel types;
  • low-precision formats included;
  • whether diagnostics/remarks were analyzed;
  • whether dynamic execution cost was measured.

Without such synthesis, the novelty claim depends on prose comparison only.

  1. Discuss whether the anti-fraud / integrity profile is clean but the evidence remains bounded

I do not see obvious paper-mill traits, fabricated references, or incoherent terminology. The technical story is internally consistent, the cited LLVM issue is specific, and the paper’s limitations are openly acknowledged . That is favorable. However, some claims would benefit from stronger evidentiary framing so that the manuscript does not appear to overextend a small but credible dataset. The paper is not suspicious; it is simply somewhat stronger in rhetoric than in breadth of empirical coverage.

Potential Minor Revisions

  1. Improve precision and consistency of quantitative reporting

There is a small but noticeable inconsistency in multiplicative summaries across sections. The abstract reports baseline bf16 and fp16 kernels executing “17.0× and 75.9× as many dynamic instructions as their extension-enabled counterparts” , whereas Table IV gives the fp16 baseline as 107.19× vs fp32 and the text elsewhere reports 75.9× relative to extension-enabled build . These are not contradictory, but the comparison baseline changes. Please standardize phrasing whenever ratios are introduced, explicitly naming the denominator each time.

  1. Define “degraded” earlier and more formally

The paper uses “Yes (degraded)” in Table II for bf16/fp16 under baseline flags . Later, the manuscript explains that a loop may still be “classified as vectorized while still containing substantial scalar overhead” and that assembly inspection is needed to characterize this as degraded rather than merely vectorized . This definition is important and should appear earlier, ideally before Table II.

  1. Clarify whether page numbering in section references is stable

Several internal references appear correct from context, but the paper should ensure section numbering is stable and not confusing. For example, the snippet around methodology references “Section IV-G” and “Results §V” in close proximity . A final pass should verify all section cross-references after formatting.

  1. Refine wording around diagnostic ambiguity

The sentence “nothing in the text points toward the fix” is strong and memorable , but it would be slightly more precise to say that the remark does not identify the required extension or explain that the issue is fully resolvable by target-feature selection. That would preserve the contribution while avoiding an absolute formulation.

  1. Minor style issue: repetition of practical framing

The practical framing that “build succeeds,” output is “numerically correct,” and no warning appears by default is repeated several times across abstract, introduction, and discussion . The repetition is understandable, but tightening it would improve readability.

  1. Typographic and formatting cleanup

The extracted text suggests some formatting artifacts likely due to two-column PDF rendering rather than authorial error, but the final manuscript should still be checked carefully for:

  • spacing around section headings and figure/table captions;
  • consistent rendering of -march strings and extensions;
  • line breaks splitting technical terms such as “degra-dation” and “vec-torization” in narrow columns ;
  • consistent math/code typography for vscale x 4, __extendhfsf2, RISCVTargetTransformInfo, and target_clones
  1. AI-content analysis

Estimated AI-generated content: low to moderate, approximately 10–20%.

Rationale:

  • The prose is unusually uniform, polished, and structurally repetitive in places, especially in the way claims are restated across abstract, discussion, and conclusion.
  • However, the manuscript contains highly specific technical details, concrete measurements, LLVM/RISC-V terminology, issue references, and tightly aligned internal argumentation that are more consistent with expert-authored or heavily expert-edited technical writing than generic AI drafting.
  • I do not see obvious hallucinated jargon clusters, empty abstraction, or internally incoherent claims typical of low-quality AI-generated submissions.

Potentially AI-assisted passages:

  • Repetitive explanatory framing around “silent” degradation and practical implications appears template-like in several sections
  • Some discussion passages have a polished, generalized explanatory cadence characteristic of editorial AI assistance, especially where broader implications are narrated from the measured facts

Assessed epistemic impact:

  • If AI assistance was used, it does not appear to undermine the technical contribution directly.
  • The main epistemic risk would be rhetorical inflation: stronger generalization than the experimental scope warrants.
  • The technical core appears evidence-based and internally coherent.

Recommendations

  1. Reframe the contribution around a precisely bounded empirical claim: “for the tested LLVM/RVV kernels and compilation settings, narrow floating-point types degrade under baseline rv64gcv unless relevant extensions are enabled.”

  2. Add an artifact/reproducibility appendix with exact commands, type definitions, environment versions, and measurement procedures.

  3. Revise the “silent degradation” framing so that it distinguishes default compiler behavior from opt-in remark channels, and emphasize that the true gap is lack of actionable diagnostic specificity.

  4. Strengthen related work with a compact comparative summary showing exactly what prior studies did not isolate.

  5. Make the limits of emulation-based evidence more prominent in the discussion of real-world performance consequences.

  6. Introduce “degraded vectorization” as an operational term earlier and connect it explicitly to both fixed width and scalar reconstruction overhead.

  7. If feasible, add one or two additional loop shapes, or at minimum discuss why the current loop shape is expected to be representative of important inference kernels. The paper itself already notes future work on “reductions or strided access patterns common in convolution and attention kernels” and on testing GCC; elevating that rationale earlier would strengthen the paper

Overall recommendation

This is a focused, technically meaningful manuscript with a credible and practically relevant result. I judge it to be promising and coherent, with no strong signs of fabrication or conceptual incoherence, but it would benefit from major revision before acceptance because its empirical scope is narrower than some of its current rhetoric suggests, and reproducibility/reporting detail should be strengthened.

Reviewer3 (AI review)

November 13, 2026

AI Review (reviewer3.com)

Overview

Characterization of Vectorization Degradation

Contribution

This study demonstrates that LLVM auto-vectorization under default RISC-V vector target flags (-march=rv64gcv) degrades bf16 and fp16 loops into scalar-heavy code or software library calls, whereas int8 and fp32 vectorize natively.

Quantification of Dynamic Instruction Penalty

Contribution

The authors show through QEMU emulation that baseline bf16 and fp16 multiply-accumulate kernels execute 17.0× and 75.9× as many dynamic instructions, respectively, compared to builds with narrow-precision vector extensions enabled.

Identification of Diagnostic Ambiguity

Contribution

The paper reveals that LLVM optimization remarks (-Rpass-analysis=loop-vectorize) fail to distinguish fixable target-feature limitations from inherent conversion costs, leaving developers with no indication that compiler flags can resolve the degradation.

Comments (8)

1. MobileNetV2 classifier tensor dimensions do not match 384x384 — Major

Every kernel operates on arrays of N = 147 , 456 ele- ments ( 384 × 384 ). Input values were taken from the largest weight tensor (the classifier weight matrix) of a pretrained MobileNetV2 [15] checkpoint and converted once from fp32 to each type: bf16 and fp16 by round-to-nearest conversion, and int8 by symmetric scaling to [ − 127

The paper states that the 147,456-element (384 x 384) input array was taken from the classifier weight matrix of MobileNetV2, while earlier noting that the MobileNetV2 classifier layer maps 1280 inputs to 1001 outputs (1,281,280 elements). It is unclear how a 384 x 384 slice was extracted from a 1280 x 1001 matrix or whether any special values (e.g., zeros or subnormals that trigger different branches in __extendhfsf2) were present in the slice.

2. Asymmetric extension pairing between bf16 and fp16 — Major

vectorizer’s cost-model reasoning. Each kernel was compiled under a baseline target ( -march=rv64gcv ) and, where applicable, again with a narrow-type extension added, to isolate that extension’s effect on generated code.

The extension-enabled configuration for bf16 enables both minimal conversion (zvfbfmin) and widening multiply-accumulate (zvfbfwma), whereas fp16 is tested only with minimal conversion (zvfhmin) and not with full zvfh (which provides vfwmacc.vf/vv for fp16). Testing zvfbfmin alone alongside zvfbfmin_zvfbfwma (and zvfh alongside zvfhmin) would isolate the effect of minimal vector load/convert legality (PR #115272) from the effect of fused widening multiply-accumulate instructions.

3. Full assembly listings for inspected loop bodies are omitted — Minor

The loop body processes a fixed 4 elements per iteration using 39 instructions. Of these, only 3 are productive ( vle32.v , vfmacc.vv , vse32.v ); the rest are 8 scalar half-word loads ( lhu ), 8 scalar-to-vector element inserts ( vmv.s.x ), 8 shift instructions preparing each half- word, and 6 vslideup.vi instructions manually assembling the four scalar-loaded elements into vector registers.

The exact instruction breakdown of the 39-instruction fma_bf16 baseline loop body (and the other six loop bodies) is summarized in prose and schematic diagrams (Fig. 3), but the actual generated assembly listings are not included in the paper or an appendix, making it impossible to directly verify the manual instruction classifications.

4. Whole-program instruction count includes non-kernel execution overhead — Major

The primary one is the dynamic guest instruction count, collected with QEMU’s libinsn plugin, which counts every RISC-V instruction the program executes, including startup, file input, and initializa- tion, which are common to all binaries and small relative to the kernel. The secondary one is host wall-clock time of the

QEMU's libinsn plugin counts all instructions executed by the entire binary, including C runtime startup, file I/O to read the checkpoint, and initialization, rather than isolating the timed kernel region. Although this startup overhead is described as small, its exact instruction count is not subtracted or reported, which could noticeably skew the instruction counts and per-element ratios of the fast, cleanly vectorized kernels (which execute only 8.40M–12.15M total instructions).

5. Exact optimization remarks for bf16 builds are not shown — Major

For fma_fp16 , the compiler’s diagnostics show this dis- tinction directly. Under the baseline flags, the vectorizer re- ports:

Section V-C presents the verbatim -Rpass-analysis=loop-vectorize remarks only for fma_fp16 (before and after adding zvfhmin), while omitting the verbatim remarks emitted for fma_bf16 (before and after adding zvfbfmin_zvfbfwma). In particular, because zvfbfwma fuses the conversion into vfwmaccbf16.vv, it is not shown whether the second remark ('floating point conversion changes vector width') still appears or disappears in the bf16 extension build.

6. Custom C __extendhfsf2 implementation vs. standard compiler-rt/libgcc — Major

The RISC-V runtime library on the build host does not pro- vide __extendhfsf2 , which the baseline fp16 binary calls. A portable C implementation of the routine (bit manipulation on the 16-bit input, with handling for zero, subnormal, infinite, and NaN inputs) was linked into both fp16 binaries; only the baseline binary calls it.

Rather than linking against LLVM's standard compiler-rt builtins or libgcc soft-float library, the fp16 binaries were linked with a custom portable C implementation of __extendhfsf2. Because the 75.9x (and 107x) dynamic instruction ratio directly depends on the instruction count inside __extendhfsf2, using a custom routine rather than the toolchain's standard runtime builtin makes the exact magnitude of the fp16 dynamic penalty sensitive to custom code choices.

7. Unrestricted pointers may prevent vectorization of narrow loads — Major

void fma_<TYPE>(<ACC_TYPE> *dst, const <TYPE> *a, const <TYPE> *b, int n)

In the C loop instantiations (Listings 1–6), the output pointer dst and input pointers a and b are not qualified with restrict. While fma_f32 has identical input and output types, fma_bf16, fma_fp16, and fma_int8 write to a 32-bit pointer while reading from 8- or 16-bit pointers (or rely on compiler runtime alias checks that may interact differently with fixed vs. scalable vectorization costs), so please clarify whether runtime pointer-aliasing checks were emitted in the generated preheaders and whether adding __restrict changes the baseline fixed-width fallback or instruction counts.

8. Missing evaluation of scalar half-precision extension Zfhmin — Minor

sertion into a vector. For fp16, the base target also lacks scalar half-precision support, so each scalar conversion becomes a call to the runtime library routine __extendhfsf2

The severe 114-instruction degradation in the fma_fp16 baseline is attributed to the base target lacking both vector and scalar fp16 support, forcing calls to __extendhfsf2. However, the design does not test whether enabling scalar half-precision conversion (zfhmin or zfh) without zvfhmin eliminates the software library calls and reduces fp16 to an in-register scalar reconstruction pattern similar to bf16.

XSci (AI review)

November 13, 2026

Summary

The manuscript asks whether LLVM's RISC-V auto-vectorizer handles the narrow numeric types used in AI inference equally well. The authors compile one multiply-accumulate loop in four instantiations (fp32, int8, bf16, fp16) under a baseline target, -march=rv64gcv, and again with the relevant narrow-type extension, examining the generated assembly, the vectorizer's remarks, and dynamic instruction counts under QEMU. fp32 and int8 vectorize cleanly at a scalable width, while bf16 falls back to a fixed width of 4 with per-element reconstruction and fp16 falls back further to per-element __extendhfsf2 calls, costing 17.0x and 75.9x the instructions of the extension-enabled builds. The fallback is traced to the element-type legality query the Loop Vectorizer makes to RISCVTargetTransformInfo, and the authors argue that the remarks reporting it do not distinguish a limitation a flag removes from an inherent conversion cost.

Contribution and Significance

The contribution is a per-type, same-loop quantification of baseline auto-vectorization quality for AI-relevant narrow types on RVV, with the degradation located at a specific point in the LLVM pipeline, plus the observation that two remarks with very different remedies are emitted through the same channel in indistinguishable language. The measurement discipline is the valuable part: varying only the -march string isolates the effect, and the three observation channels agree for the degraded cases.

The advance over the closest prior work is narrower than the framing suggests. That good narrow-FP vector code requires Zvfhmin or Zvfbfmin/Zvfbfwma follows from the specifications the authors cite ([3], [6], [9]) and from the upstream work they cite: [7] is the LLVM change that created the extension-enabled path measured here, and [8] already describes bf16/fp16 widening codegen and its LMUL and register-pressure consequences. Relative to [10], [11] and [12] the methodological novelty is a change of element type. The "silent" framing is also strained: -march is the developer's own declaration of what the target implements, the compiler cannot legally emit Zvfhmin instructions for a target that excludes it, and Section VII correctly warns against adding the flags otherwise. What remains new is the quantification and the filed proposal that the remark name the missing extension.

Strengths

  • The static and dynamic analyses are cross-checked: the bf16 baseline body of 39 instructions per 4 elements predicts 9.75 instructions per element against a measured 9.76, and the fp16 baseline decomposes into 28.5 loop-body instructions plus about 34 inside the two conversion calls, summing to the measured 62.5 (Section V-E).
  • The mechanism is located, not just observed: Section II-F and Fig. 1 identify the element-type legality query to RISCVTargetTransformInfo, and Section V-C shows the matching remark disappearing and the width changing from 4 to vscale x 4 once zvfhmin is added.
  • Adding fma_int8 alongside dot_int8 (Sections IV-C and V-D) is the right control: int8's clean vectorization follows from the type, not the reduction structure.
  • The separation of the two remarks, one that the flag removes and one that it does not (Section V-C), is precise, well evidenced, and filed upstream [16].
  • Section VII gives signatures a developer can act on: a fixed width of 4 where vscale x N is expected, call __extendhfsf2, and per-element lhu with vslideup.vi.

Recommendation

Major Revision for LCTES. The kind and scale of contribution fit the venue, the static analysis is careful, and the developer-facing output is concrete. But the quantitative core does not reconcile: for every cleanly vectorized kernel the measured instructions per element fall below what the reported loop bodies and vector width imply, and those kernels are the denominators of every headline ratio. That gap, and the distance between the single microkernel and the deployment conclusions drawn from it, must be closed before the numbers can be relied on.

Major Concerns

  1. Static and dynamic counts do not reconcile for the scalable kernels (Section V-D and Table IV). Section V-E states that "The measured counts are consistent with the static counts", but the demonstration covers only the two fixed-width-4 baselines; for the scalable kernels the two sets conflict. Under LLVM's RISC-V convention, a vscale x 4 fp32 loop at VLEN = 256 covers 16 elements per iteration, so the 13-instruction fp32 loop body implies at least 0.81 instructions per element; Table IV reports 0.58. The same holds for every scalable kernel: the bf16 extension build (14 instructions) implies 0.875 against 0.57, the fp16 extension build (17) implies 1.06 against 0.82, fma_int8 (15) implies 0.94 against 0.69, and dot_int8 (12) implies 0.75 against 0.57. Measuring below the static loop body cost cannot be explained by additional overhead, and the implied 21 to 24 elements per iteration is not a width RVV produces at VLEN = 256. Normalization is not the issue, since the fixed-width cases agree to 0.1%.

    This matters because 8.60 M (fp32), 8.47 M (bf16 extension) and 12.15 M (fp16 extension) are the denominators of 17.0x, 75.9x, 16.7x, 107x and "within 1.41x of fp32". The manuscript never states how many elements a scalable iteration covers at VLEN = 256; Fig. 3 says only "vl elements per iteration (set at run time)". The authors should state that number, show the arithmetic for the fp32 reference as they already do for bf16, and correct whichever of the static counts, the measured counts or the consistency claim is wrong.

  2. The single elementwise kernel does not support the deployment conclusions (Sections II-B and VI). Section II-B claims that "Whether the compiler can vectorize this sequence for a given type therefore decides whether the larger kernel can be vectorized well for that type", and Section VI concludes that storing weights in bf16 or fp16 "can make the hot loop slower than leaving them in fp32". The measured loop is an elementwise array update with a memory-resident fp32 destination and no operand reuse, which is not the inner loop of a tiled GEMM: there the accumulator is register-resident and one operand is reused across the tile, so the ratio of conversion work to arithmetic differs. Production runtimes, including the one the authors cite [4], use hand-written RVV kernels rather than auto-vectorizing such loops. Section VIII acknowledges the narrow kernel set, but Sections II-B and VI are not scaled back accordingly. One realistic kernel compiled under both targets — a tiled GEMM microkernel, or the MobileNetV2 classifier layer the manuscript already describes — would settle whether the magnitudes carry over; absent that, the claims should be stated as holding for the loop shape measured.

  3. The diagnostic contribution is argued rather than evaluated (Sections V-C and VI). This is advanced as one of the paper's two contributions, but the evidence is two remark strings from one kernel. The bf16 remark text is never quoted, so the reader cannot confirm the same ambiguity arises there; no other RISC-V remarks are surveyed, so it is not shown to be a pattern rather than one string; and the claim that developers are misled rests on [13], which the authors correctly note concerns error messages. Either support the claim — quote the bf16 remarks, survey the RISC-V remark texts that depend on target features, and show the proposed message against the current one — or present it as an observation and a proposal rather than a finding.

Minor Comments

  1. The headline 75.9x depends on the authors' own portable __extendhfsf2, which supplies 34 of the 62.5 instructions per element; compiler-rt provides this builtin, and linking it would make the figure reproducible.
  2. The -march strings in Sections IV-D (rv64gcv_zvbfmin_zvfbfwma) and IV-E (rv64gcv_zvfbmin) disagree with Table I; the fp16 string names the wrong extension.
  3. "half the memory footprint" (Section VI) and "twice the memory of bf16" (Section VII) ignore the fp32 destination array, identical in both kernels, so the traffic ratio is 12:16, not 1:2.
  4. Section V-E states that the bf16 extension build executes 1.6% fewer instructions than fp32; Table IV gives 8.47 against 8.60, which is 1.5%.
  5. Table III's "Degradation removed? Yes" overstates the fp16 case, which still runs at 1.41x the fp32 instruction count.
  6. Section I asserts that "the output is numerically correct", but no cross-type validation of the kernel outputs is reported.
  7. Table IV shows dot_int8 at 0.28 s against fma_f32 at 0.62 s for nearly identical instruction counts, a larger wall-clock anomaly than the bf16 case discussed in Section V-E, and unexplained.
  8. No artifact is mentioned; the kernels, conversion script, QEMU plugin invocation and __extendhfsf2 source should be released.
  9. Since Section VI argues the relative gap widens with vector width, repeating the measurement at a second VLEN under QEMU would support that argument directly.
  10. Only -O3 at the default LMUL is evaluated; whether a forced higher LMUL changes the bf16 baseline path is worth a sentence.
  11. Section III should cite the origin of the TSVC variant that [10] and [11] use: S. Maleki, Y. Gao, M. J. Garzaran, T. Wong and D. A. Padua, "An Evaluation of Vectorizing Compilers," PACT 2011, pp. 372-382.
  12. Section VI should engage upstream work on remark usability, for example "Using and Improving Optimization Remarks," LLVM Developers' Meeting, October 2025.