wasm size optimization

Author: gfx

Cargo.toml

@@ -9,6 +9,9 @@ repository = "https://github.com/wado-lang/fpfmt"
 autotests = false
 exclude = ["tools/", "tests/"]
 
+[features]
+small = []
+
 [workspace]
 members = [".", "tools/pow10gen", "tools/bench", "tools/wasm-size"]
 

README.md

@@ -21,28 +21,46 @@ Regenerate the power-of-10 table:
 cargo run -p pow10gen
 ```
 
+## Features
+
+### `small` — compact tables for WASM
+
+Enable the `small` feature to replace the 11 KB power-of-10 lookup table with
+two smaller tables (632 bytes total) that are multiplied at runtime.
+This reduces WASM binary size from 14 KB to **4 KB** with a modest
+formatting slowdown (~1.6x), while parsing is unaffected.
+Still **2.4x faster** than ryu for formatting.
+
+```toml
+fpfmt = { version = "0.2", features = ["small"] }
+```
+
 ## Benchmarks
 
 Formatting and parsing 8 representative f64 values (`1.0`, `0.1`, `3.14`, `PI`, `E`, `1e23`, `5e-324`, `1.7976931348623157e308`).
 
 Measured on Apple M3 Pro, macOS 15.7.3 (aarch64):
 
-| Task | fpfmt | ryu | stdlib |
-|------|------:|----:|-------:|
-| **format** (f64 → string) | 63 ns | 164 ns | 535 ns |
-| **parse** (string → f64) | 738 ns | — | 702 ns |
+| Task | fpfmt | fpfmt `small` | ryu | stdlib |
+|------|------:|--------------:|----:|-------:|
+| **format** (f64 → string) | 65 ns | 102 ns | 240 ns | 528 ns |
+| **parse** (string → f64) | 697 ns | 701 ns | — | 658 ns |
 
 ```sh
 cargo bench -p bench
+cargo bench -p bench --features small
 ```
 
-## Wasm size
+## WASM size
 
-32,970 bytes for `short` + `parse` as a cdylib (`wasm32-unknown-unknown`, `-Oz`).
+| Configuration | Size |
+|---------------|-----:|
+| default | 14,428 bytes |
+| `small` | **4,224 bytes** |
 
 ```sh
-RUSTFLAGS="-C opt-level=s" cargo build --target wasm32-unknown-unknown --release -p wasm-size
-RUSTFLAGS="-C opt-level=z" cargo build --target wasm32-unknown-unknown --release -p wasm-size
+cargo build --target wasm32-unknown-unknown --release -p wasm-size
+cargo build --target wasm32-unknown-unknown --release -p wasm-size --features small
 wc -c target/wasm32-unknown-unknown/release/wasm_size.wasm
 ```
 

src/lib.rs

@@ -9,6 +9,9 @@
 
 mod pow10tab;
 
+#[cfg(feature = "small")]
+use pow10tab::{K, POW10_COARSE, POW10_FINE, Q_MIN};
+#[cfg(not(feature = "small"))]
 use pow10tab::{POW10_MIN, POW10_TAB};
 
 /// `PmHiLo` represents `hi<<64 - lo`.
@@ -152,6 +155,7 @@ fn unmin(x: u64) -> Unrounded {
 
 /// `prescale` returns the scaling constants for (e, p).
 /// `lp` must be `log2_pow10(p)`.
+#[cfg(not(feature = "small"))]
 #[inline]
 fn prescale(e: i32, p: i32, lp: i32) -> Scaler {
     Scaler {
@@ -160,6 +164,64 @@ fn prescale(e: i32, p: i32, lp: i32) -> Scaler {
     }
 }
 
+#[cfg(feature = "small")]
+#[inline]
+#[allow(clippy::many_single_char_names)]
+fn mul_pow10(p: i32) -> PmHiLo {
+    let q = p.div_euclid(K);
+    let r = p.rem_euclid(K) as usize;
+
+    let c = POW10_COARSE[(q - Q_MIN) as usize];
+    let f = POW10_FINE[r];
+
+    // Convert coarse from PmHiLo to raw u128 (hi<<64 - lo).
+    let c_raw = (u128::from(c.hi) << 64).wrapping_sub(u128::from(c.lo));
+    let c_hi = (c_raw >> 64) as u64;
+    let c_lo = c_raw as u64;
+
+    // Product = c_raw * f * 2^64 (256-bit).
+    // Split into a1*2^64 + a0 = c_raw * f, then shift left 64.
+    let a1 = u128::from(c_hi) * u128::from(f);
+    let a0 = u128::from(c_lo) * u128::from(f);
+
+    // Top 128 = a1 + (a0 >> 64); remainder = (a0 as u64).
+    let mut top = a1 + (a0 >> 64);
+    let has_remainder = a0 as u64 != 0;
+
+    // Round up if not exact (matching generator convention).
+    if has_remainder {
+        top += 1;
+    }
+
+    // Normalize: ensure bit 127 is set.
+    let norm = 1 - (top >> 127) as u32;
+    top <<= norm;
+
+    let hi = (top >> 64) as u64;
+    let lo = top as u64;
+
+    // Convert to PmHiLo (hi<<64 - lo).
+    if lo != 0 {
+        PmHiLo {
+            hi: hi + 1,
+            lo: lo.wrapping_neg(),
+        }
+    } else {
+        PmHiLo { hi, lo: 0 }
+    }
+}
+
+/// `prescale` returns the scaling constants for (e, p).
+/// `lp` must be `log2_pow10(p)`.
+#[cfg(feature = "small")]
+#[inline]
+fn prescale(e: i32, p: i32, lp: i32) -> Scaler {
+    Scaler {
+        pm: mul_pow10(p),
+        s: -(e + lp + 3),
+    }
+}
+
 /// `uscale` returns `unround(x * 2**e * 10**p)`.
 /// The caller should pass `c = prescale(e, p, log2_pow10(p))`
 /// and should have left-justified x so its high bit is set.
@@ -511,6 +573,7 @@ mod tests {
 
     /// `TestPow10`: verify power-of-10 table entries.
     /// Port of Go's `TestPow10`.
+    #[cfg(not(feature = "small"))]
     #[test]
     fn test_pow10() {
         let cases: [(i32, PmHiLo, i32); 4] = [

src/pow10tab.rs

@@ -4,11 +4,10 @@
 
 use super::PmHiLo;
 
+#[cfg(not(feature = "small"))]
 pub(crate) const POW10_MIN: i32 = -348;
-pub(crate) const POW10_MAX: i32 = 347;
 
-/// `pow10_tab` holds 128-bit mantissas of powers of 10.
-/// The values are scaled so the high bit is always set.
+#[cfg(not(feature = "small"))]
 pub(crate) static POW10_TAB: [PmHiLo; 696] = [
     PmHiLo {
         hi: 0xfa8fd5a0081c0289,
@@ -2795,3 +2794,148 @@ pub(crate) static POW10_TAB: [PmHiLo; 696] = [
         lo: 0xb48e6a0d2d2e5604,
     }, // 1e347 * 2**-1025
 ];
+
+#[cfg(feature = "small")]
+pub(crate) const K: i32 = 27;
+
+#[cfg(feature = "small")]
+pub(crate) const Q_MIN: i32 = -13;
+
+#[cfg(feature = "small")]
+pub(crate) static POW10_COARSE: [PmHiLo; 26] = [
+    PmHiLo {
+        hi: 0x8049a4ac0c5811af,
+        lo: 0xdfa4769288829d87,
+    }, // 1e-351 * 2**1293
+    PmHiLo {
+        hi: 0xcf42894a5dce35eb,
+        lo: 0xadf9b3537d798a46,
+    }, // 1e-324 * 2**1204
+    PmHiLo {
+        hi: 0xa76c582338ed2622,
+        lo: 0x50d50d47f5090db1,
+    }, // 1e-297 * 2**1114
+    PmHiLo {
+        hi: 0x873e4f75e2224e69,
+        lo: 0xa588bb5917fb5d6e,
+    }, // 1e-270 * 2**1024
+    PmHiLo {
+        hi: 0xda7f5bf590966849,
+        lo: 0x50c65b8aaf957661,
+    }, // 1e-243 * 2**935
+    PmHiLo {
+        hi: 0xb080392cc4349ded,
+        lo: 0x427286b26955304c,
+    }, // 1e-216 * 2**845
+    PmHiLo {
+        hi: 0x8e938662882af53f,
+        lo: 0xab814b848d7d1163,
+    }, // 1e-189 * 2**755
+    PmHiLo {
+        hi: 0xe65829b3046b0afb,
+        lo: 0xf34b5a5ceed5aeed,
+    }, // 1e-162 * 2**666
+    PmHiLo {
+        hi: 0xba121a4650e4ddec,
+        lo: 0x6d0cb29d9e931bec,
+    }, // 1e-135 * 2**576
+    PmHiLo {
+        hi: 0x964e858c91ba2656,
+        lo: 0xc595f8072aef0790,
+    }, // 1e-108 * 2**486
+    PmHiLo {
+        hi: 0xf2d56790ab41c2a3,
+        lo: 0x051d8d66bdc0463c,
+    }, // 1e-81 * 2**397
+    PmHiLo {
+        hi: 0xc428d05aa4751e4d,
+        lo: 0x55681eb3c3d94779,
+    }, // 1e-54 * 2**307
+    PmHiLo {
+        hi: 0x9e74d1b791e07e49,
+        lo: 0x88a15d9b30aacb82,
+    }, // 1e-27 * 2**217
+    PmHiLo {
+        hi: 0x8000000000000000,
+        lo: 0x0000000000000000,
+    }, // 1e0 * 2**127
+    PmHiLo {
+        hi: 0xcecb8f27f4200f3a,
+        lo: 0x0000000000000000,
+    }, // 1e27 * 2**38
+    PmHiLo {
+        hi: 0xa70c3c40a64e6c52,
+        lo: 0x666f6f49a09826dc,
+    }, // 1e54 * 2**-52
+    PmHiLo {
+        hi: 0x86f0ac99b4e8dafe,
+        lo: 0x965fd744c2128e5c,
+    }, // 1e81 * 2**-142
+    PmHiLo {
+        hi: 0xda01ee641a708dea,
+        lo: 0x17f190b7df336b6a,
+    }, // 1e108 * 2**-231
+    PmHiLo {
+        hi: 0xb01ae745b101e9e5,
+        lo: 0xa13fa23008d18070,
+    }, // 1e135 * 2**-321
+    PmHiLo {
+        hi: 0x8e41ade9fbebc27e,
+        lo: 0xeba770ec417b8cf8,
+    }, // 1e162 * 2**-411
+    PmHiLo {
+        hi: 0xe5d3ef282a242e82,
+        lo: 0x70e9973757925a05,
+    }, // 1e189 * 2**-500
+    PmHiLo {
+        hi: 0xb9a74a0637ce2ee2,
+        lo: 0x926ac1d428e8c96d,
+    }, // 1e216 * 2**-590
+    PmHiLo {
+        hi: 0x95f83d0a1fb69cda,
+        lo: 0xb54250efea9b0671,
+    }, // 1e243 * 2**-680
+    PmHiLo {
+        hi: 0xf24a01a73cf2dcd0,
+        lo: 0x439cc4c698c37313,
+    }, // 1e270 * 2**-769
+    PmHiLo {
+        hi: 0xc3b8358109e84f08,
+        lo: 0xf579d07f13b8ff37,
+    }, // 1e297 * 2**-859
+    PmHiLo {
+        hi: 0x9e19db92b4e31baa,
+        lo: 0x93f85d3d957cb92e,
+    }, // 1e324 * 2**-949
+];
+
+#[cfg(feature = "small")]
+pub(crate) static POW10_FINE: [u64; 27] = [
+    0x8000000000000000, // 1e0 * 2**127
+    0xa000000000000000, // 1e1 * 2**124
+    0xc800000000000000, // 1e2 * 2**121
+    0xfa00000000000000, // 1e3 * 2**118
+    0x9c40000000000000, // 1e4 * 2**114
+    0xc350000000000000, // 1e5 * 2**111
+    0xf424000000000000, // 1e6 * 2**108
+    0x9896800000000000, // 1e7 * 2**104
+    0xbebc200000000000, // 1e8 * 2**101
+    0xee6b280000000000, // 1e9 * 2**98
+    0x9502f90000000000, // 1e10 * 2**94
+    0xba43b74000000000, // 1e11 * 2**91
+    0xe8d4a51000000000, // 1e12 * 2**88
+    0x9184e72a00000000, // 1e13 * 2**84
+    0xb5e620f480000000, // 1e14 * 2**81
+    0xe35fa931a0000000, // 1e15 * 2**78
+    0x8e1bc9bf04000000, // 1e16 * 2**74
+    0xb1a2bc2ec5000000, // 1e17 * 2**71
+    0xde0b6b3a76400000, // 1e18 * 2**68
+    0x8ac7230489e80000, // 1e19 * 2**64
+    0xad78ebc5ac620000, // 1e20 * 2**61
+    0xd8d726b7177a8000, // 1e21 * 2**58
+    0x878678326eac9000, // 1e22 * 2**54
+    0xa968163f0a57b400, // 1e23 * 2**51
+    0xd3c21bcecceda100, // 1e24 * 2**48
+    0x84595161401484a0, // 1e25 * 2**44
+    0xa56fa5b99019a5c8, // 1e26 * 2**41
+];

tools/bench/Cargo.toml

@@ -4,6 +4,9 @@ version = "0.0.0"
 edition = "2024"
 publish = false
 
+[features]
+small = ["fpfmt/small"]
+
 [dependencies]
 fpfmt = { path = "../.." }
 ryu = "1"