`<string>`: `to_string()` for integers could be faster

[StephanTLavavej]

Related to #1024 and #3805 but not a duplicate.

In DevCom-10402949, a user has suggested using the divide-by-100 approach (already used by Ryu/<charconv>) to print digits faster. (Note: Due to licensing concerns, please DO NOT refer to libstdc++'s implementation linked by the DevCom suggestion.) They have also suggested calling memcpy() for 2 bytes, although I find this surprising and would want to confirm via benchmarking.

[heretic13]

Hello.

About memcpy for 2 bytes.
Here is the test program.

https://godbolt.org/z/c5Y75fss7

Here you can see the work of different compilers on optimizing memcpy calls and manually copying two bytes.

Most compilers for Debug mode replace the memcpy call with length 2 with a byte transfer.
But MSVC leaves the memcpy call, which in my opinion is not entirely optimal. This is a question for the Microsoft C/C++ compiler optimization team.

But if we turn on the Release mode (-O2), then absolutely ALL compilers generate optimal code. You can see
that a memcpy call with length 2 turns into a byte transfer in an optimal way. Such code is shorter in assembly instructions and contains fewer Register<->Memory exchange instructions.

This is observed on x86, x86-64, arm platforms.

This is just a small study.
But this of course requires writing performance test programs.

[CaseyCarter]

Your fun1 can't be optimized into a 16-bit load and a 16-bit store because the source and destination could alias, i.e., pDst could be pSrc + 1. Nevertheless, I also can't convince the compiler to generate optimal code except by calling memcpy: https://godbolt.org/z/osx1W3xWc.

[heretic13]

I changed the two bytes copy test.

In real life, we will divide a number by 100 and the remainder of the division will be used as an index in an array of constants.
That is, the source of the data is known. Unknown index in array.

The results are now inconsistent.
Sometimes the latest versions of gcc and clang do the same code for copying bytes and calling memcpy, sometimes they don't.
But msvc always makes different code (the memcpy version is shorter).

https://godbolt.org/z/4dea8q788