look into using Ryu instead of Errol3 for floating point printing

[andrewrk]

Bold claim:

simpler and approximately three times faster than the previously fastest implementation.

paper: https://dl.acm.org/citation.cfm?id=3192369
C implementation: https://github.com/ulfjack/ryu

things to measure:

• performance
• code size
• if it's possible to work without ever using floating point registers

[andrewrk]

Note if porting the reference C implementation: we should port the -DRYU_OPTIMIZE_SIZE stuff by checking builtin.Mode.ReleaseSmall.

[tiehuis]

I'll likely do an initial implementation of this in the next few days.

[tiehuis]

Will be committing here for the moment. https://github.com/tiehuis/zig-ryu

Also, it would be nice to implement proper f16 printing support and f128 (#1181) alongside so I'll keep these in mind.

[tiehuis]

Quick update:

• Preliminary support was added upstream for f128 and f80 values. I've got a local port nearly done.
• f16 as well I've pretty much done as we can reuse f32 formatting.

This leaves the formatted printing of values remaining before I'd be happy to make a PR. There is an upstream issue for that as well: ulfjack/ryu#27.

[tiehuis]

f16 and f128 printing support is now present using the 128-bit conversion backend. We should also have proper c_longdouble (80-bit float) printing as well when #1188 is done.

[andrewrk]

@tiehuis were you blocking on #1188 for this? I can prioritize that if you like.

[tiehuis]

Not really. Main requirement here is to put the time and effort in getting the formatted float output modes modes done for alignment/precision, scientific/decimal modes etc. It'll probably tie in with #1358 since they both touch a lot of the formatting code.

[tiehuis]

This is a response to #1290 (comment). Related moreso to this issue so bringing the discussion here.

Here are some actual numbers in regards to the size savings. First, we can construct two simple examples:

format-std.zig

const std = @import("std");

var buf: [32]u8 = undefined;

export fn print(value: f32) [*]const u8 {
    const slice = std.fmt.bufPrint(buf[0..], "{}", value) catch unreachable;
    return slice.ptr;
}

format-ryu.zig

const ryu = @import("index.zig");

var buf: [32]u8 = undefined;

export fn print(value: f32) [*]const u8 {
    const slice = ryu.floatToBuffer(value, buf[0..]);
    return slice.ptr;
}

Compiling both of these under --release-small with build-obj we get two object files. The output of readelf -s is as follows (omitting irrelevant noise).

format-std.o

Total size is 29163 bytes (excluding buf symbol).

Symbol table '.symtab' contains 483 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS format-std

   ...

   460: 0000000000000000    32 OBJECT  LOCAL  DEFAULT    6 buf
   461: 0000000000004668   200 OBJECT  LOCAL  DEFAULT    7 c_digits_lut
   462: 0000000000000000  3456 OBJECT  LOCAL  DEFAULT    7 enum3
   463: 0000000000000000 10368 OBJECT  LOCAL  DEFAULT    8 enum3_data
   464: 00000000000020e8  9600 OBJECT  LOCAL  DEFAULT    7 lookup_table
   465: 00000000000011f0  1788 FUNC    LOCAL  DEFAULT    2 std.fmt.errol.u64toa
   466: 00000000000018f0   168 FUNC    LOCAL  DEFAULT    2 std.math.frexp.frexp64

   ...

   479: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND __fixunsdfti
   480: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND __udivti3
   481: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND __umodti3
   482: 0000000000000000  4583 FUNC    GLOBAL DEFAULT    2 print

format-ryu.o

Total size is 3007 bytes. Note also that ryu only requires integer operations while errol operates on floats directly.

Symbol table '.symtab' contains 19 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS format-ryu
     2: 0000000000000000   200 OBJECT  LOCAL  DEFAULT    5 DIGIT_TABLE

    ...

     5: 0000000000000000    32 OBJECT  LOCAL  DEFAULT    4 buf
     6: 00000000000000c8   248 OBJECT  LOCAL  DEFAULT    5 float_pow5_inv_split
     7: 00000000000001c0   376 OBJECT  LOCAL  DEFAULT    5 float_pow5_split
 
        ...

    18: 0000000000000000  2183 FUNC    GLOBAL DEFAULT    2 print

An important thing to note is that internally our errol implementation only works on f64 values. Even when printing an f32 we cast up to an f32 and back down once down. Likewise for f128, in which we lose precision during printing. The current ryu implementation has a 32, 64 and 128 bit backend for each of the float types which any narrower type can use without loss of precision.

That being said, the above example is slightly apples to oranges, since we are comparing a 32-bit printing backend to a 64-bit. Modifying our original examples we get the following:

format-std.o

Same size as previously. Slightly smaller by a few bytes since casting between f32 to f64 is now not done.

format-ryu.o

Total size is 4176 bytes. Slightly larger that the f32 but not a huge amount. The increase in size is not linear as the types increase since the precomputed values are different between the engines. Storing lots of tables is only required for increasing runtime performance. We can precompute smaller amounts and compute based on these instead of doing them all to keep the table sizes reasonable. This is done as per the original implementation.

Symbol table '.symtab' contains 50 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS format-ryu
     2: 0000000000000000   200 OBJECT  LOCAL  DEFAULT    5 DIGIT_TABLE

    ...

    31: 0000000000000000    32 OBJECT  LOCAL  DEFAULT    4 buf
    32: 0000000000000000   208 OBJECT  LOCAL  DEFAULT    7 double_pow5_inv_split2
    33: 00000000000000d0   208 OBJECT  LOCAL  DEFAULT    7 double_pow5_split2
    34: 00000000000000c8   208 OBJECT  LOCAL  DEFAULT    5 double_pow5_table
    35: 0000000000000198    80 OBJECT  LOCAL  DEFAULT    5 pow5_inv_offsets
    36: 00000000000001e8    52 OBJECT  LOCAL  DEFAULT    5 pow5_offsets

    ...

    49: 0000000000000000  3220 FUNC    GLOBAL DEFAULT    2 print

Summary

• 5-10 times smaller table sizes
• Accurate floating point printing
• No floating point operations required (valuable for soft-float architectures)
• 2-3 times fast the errol
• Supports f16, f32 and f128 without messy casts to f64

[andrewrk]

Wow, huge improvements!