Optimize float output

[xjb714]

The process of converting decimal numbers to BCD code can also be optimized. Use the SIMD instruction set. Please refer to https://github.com/xjb714/xjb/blob/main/src/ftoa_json.cpp#L642 for detailed information.

[vitaut]

Are you talking about float because double conversion already uses SIMD?

[xjb714]

Yes, you can refer to my implementation. However, for double, I used avx512. Your code does not involve avx512.

[vitaut]

A PR to use SIMD for float would be welcome but I don't think we need to track this as an issue.

[vitaut]

On a second thought, let's track this.

[TobiSchluter]

I played around with this a little, and it seems that the right thing for float on x86-64 is just to modify to_bcd8 to call get_double_significand_bcd_unshuffled_sse followed by the unshuffling (reading this I realize that the naming is confusing get_double_significand_bcd_unshuffled_sse returns a shuffled string which one has to call _mm_shuffle_XX on to unshuffle).

Observations:

1. when using 64 bit SIMD the compilers actually substitute 128bit SIMD (with default flags, this is configurable)
2. experimenting with bswap64 instead of the full 128bit shuffle showed no performance advantages
3. it gains almost a nanosecond, i.e. ~12% (8.5ns -> 7.5ns on my AMD Ryzen)

Since I now have access to an ARM64 based mac I'll try to play the same game with the NEON code, where I would have to split the to_digits function.

It is tempting to add a to_bcd2x8 function which can also be used in the double code, but I'm mainly thinking about the case where one converts multiple numbers. The binary -> decimal conversion would still have to happen two times, but the time spent converting to a digit string would be cut in half. Maybe something for fmtlib? I mentioned before that this can be done for doubles with AVX256, but here it would be practically free in terms of code.

Edit: I just learned about the movbe isntruction (which is a x86-64-v3 instruction that does byte-swapping while writing to memory). That may be a better fit for writing the string to memory, so observation 2 may have to be updated for that architecture level.

[vitaut]

Thanks for investigating!

it seems that the right thing for float on x86-64 is just to modify to_bcd8 to call get_double_significand_bcd_unshuffled_sse followed by the unshuffling

Makes sense, a PR is welcome.

It is tempting to add a to_bcd2x8 function which can also be used in the double code, but I'm mainly thinking about the case where one converts multiple numbers. The binary -> decimal conversion would still have to happen two times, but the time spent converting to a digit string would be cut in half. Maybe something for fmtlib?

That's an interesting idea but I don't think we have a use case for this in {fmt} since every argument is processed separately. One could probably write a slightly optimized formatter for complex numbers or ranges of FP numbers but that seems niche and better be solved via custom formatters outside of {fmt}.