FP16 Hardware Feature Detection

未关闭
#11 1 条评论 1 个 reaction 已指派 0 人 在 GitHub 查看

还没有人认领这个 Issue。

评估

难度
5/5
预计耗时
一周以上
新手友好度
25/100
Issue 类型
功能
描述清晰度
基本清楚
活跃度
活跃
技术栈
wasm

调研方向

Start with the linked Lowering.md and compare the three host-detection options and open questions in this issue. The issue does not identify proposal files, tests, or a settled design; first determine the intended interface and how it fits WebAssembly semantics. Done means an agreed, specified way to report FP16 support tiers, including forward compatibility and the stated stability and privacy constraints.

由索引模型根据 Issue 内容生成。

描述

Motivation

Host CPUs fall into three tiers of FP16 hardware support (see Lowering.md):

Tier Hardware support Examples
0 None. All FP16 ops are emulated in software x86 without F16C (e.g. Jasper Lake), RISC-V without Zfhmin/Zvfhmin, interpreters
1 f16 <-> f32 conversions only. Other f16x8 ops lower via wider floats or software Client x86-64 with F16C (AMD Zen 1–5, Intel Core through Arrow/Lunar Lake), AArch64 (ARMv8.0-A), RISC-V Zfhmin+Zvfhmin
2 Native f16x8 SIMD ARMv8.2+ FEAT_FP16, server x86 AVX512-FP16+VL / AVX10, RISC-V Zvfh

"Conversions" means f32.load_f16, f32.store_f16, f32x4.promote_low_f16x8, f16x8.demote_f32x4_zero, and f16x8.{splat,extract_lane,replace_lane} (which convert lanes to/from f32).

Every engine supporting FP16 validates all instructions on all three tiers, so a single .wasm binary runs everywhere and can bundle both f16x8 and f32x4 code paths. Because everything validates, WebAssembly.validate only reports engine support, not whether the host CPU accelerates FP16.

Libraries such as XNNPACK need the hardware tier to pick the right kernel:

  • Tier 2: compute directly in f16x8.
  • Tier 1: store weights in f16 (halving memory bandwidth), promote on load, and compute in f32x4. Running a pure f16x8 kernel on tier 1 (nearly all consumer x86-64 CPUs) is slower than f32x4 because each arithmetic op unpacks to wider floats, computes, and repacks (f16x8.madd/nmadd cannot even use f32 FMA without double rounding).
  • Tier 0: compute in f32x4 (unpacking any f16 weights once up front rather than in inner loops).

Without feature detection, the only way to choose at runtime is a microbenchmark at startup, which is slow, noisy, and adds to startup time.

Requirements

All options below share these properties:

  • Hint only: the result does not affect validation or instruction semantics. Engines may conservatively return 0 (e.g. in anti-fingerprinting/jitless modes or the deterministic profile).
  • Stable: the value is constant for at least a compiled module or instance lifetime.
  • Low fingerprinting surface: at most a couple of coarse bits, which are already observable via timing.

Options

Option 1: Dedicated instruction (f16.feat)

f16.feat : [] -> [i32] returns the tier from the table above.

  • Pros: Self-contained and works in any embedding (Web, WASI) without glue code. Engines can constant-fold it at compile time and eliminate dead inline branches. JS loaders (e.g. wasm-feature-detect) can still probe it before fetching large bundles via a tiny module.
  • Cons: Adds a host-dependent instruction to the core spec (though relaxed-simd sets precedent for embedder-chosen hardware behavior). Specific to FP16, so other proposals would need their own.
Option 2: Opcode-parameterized query (instr.support <opcode>)

instr.support <opcode> : [] -> [i32] returns 1 if the given opcode is natively accelerated on the host, 0 otherwise.

  • Pros: General. Also covers relaxed SIMD (e.g. FMA, dot product) and future proposals without new opcodes. Can be constant-folded like Option 1.
  • Cons: "Accelerated" is ill-defined per opcode. For example, f16x8.abs/neg are a single bitwise op (sign-bit mask) on any SIMD hardware, yet say nothing about whether f16x8.add is fast. Larger fingerprinting surface. Broadens the scope of the FP16 proposal. Encoding an opcode as an immediate will be awkward.
Option 3: JS API (WebAssembly.getHardwareSupport(name))
const tier = WebAssembly.getHardwareSupport("fp16"); // 0, 1, 2, or undefined if unsupported
  • Pros: Keeps host introspection out of the core spec. Extensible to other features via new names.
  • Cons: Web-only unless mirrored in WASI/C APIs. Pure-Wasm libraries can't self-detect, so the embedder must plumb the result in. Constant folding requires pairing with a compile-time import (e.g. via Wasm 3.0 builtins).

Open questions

  • Single bit vs. 3 tiers? A single bit ("is native f16x8 available?") merges tiers 0 and 1, even though tier 0 still occurs on recent low-power x86 (e.g. Jasper Lake Chromebooks), non-Zfhmin RISC-V, VMs, interpreters, and privacy modes. Without distinguishing them, libraries can't choose between the tier 1 promote-on-load path and the tier 0 unpack-up-front path above.
  • Ordered tier (0, 1, 2) vs. bitmask? An ordered tier requires callers to check tier >= 2 to stay forward-compatible, whereas a bitmask (1 << 0 = conversions, 1 << 1 = f16x8 SIMD, upper bits 0) also handles non-linear extensions (e.g. follow-on widening FP16->FP32 FMA such as ARM FEAT_FHM).
主要语言
WebAssembly
星标
14
派生
0
PR 合并指标
30 天内没有已合并 PR

环境准备

  • 没有 Dockerfile 或 Docker Compose 文件
  • 没有 Pull Request 模板
  • 阅读贡献指南

从这里开始

  1. 先读完整个 Issue,再读项目的贡献指南。
  2. 在 Issue 下留言说明你要接手 —— 这能避免两个人做同样的事。
  3. Fork 仓库,在一个分支上完成修改。
  4. 提交 Pull Request,并在描述里引用这个 Issue 编号。

WebAssembly/fp16 的其他 Issue

查看 WebAssembly/fp16 的全部 Issue

相似的 Issue

更多 Operating Systems Issue

把新 issue 发到你的邮箱

精选适合新手参与的 GitHub issue 摘要。