perf: use native v8 toBase64() / toHex() in Buffer#toString ?

[ChALkeR]

Available since #59805

According to quick testing, they seem to be 1.6-1.7x faster than Buffer#toString('base64') and Buffer#toString('hex')

Note: this does not apply to fromBase64/fromHex (and those would be incompatible anyway)

Ref: https://tc39.es/proposal-arraybuffer-base64

[Renegade334]

These remain flagged in V8, so the API cannot depend on their existence – in theory, Node.js can be called with --no-js-base-64.

[ChALkeR]

@Renegade334 Uint8Array.prototype.toBase64/toHex presence can be checked at startup time (saved to primordials?)
Keeping both paths should bring in only a few lines

[bakkot]

Huh, I thought these were all using the same library (simdutf) under the hood, so I'm surprised there would be a performance difference.

[panva]

In case anyone wanted to run the benchmarks and the full test suite for it

panva@ca9f66d

[ChALkeR]

This seems affected by the buffer size, will plot a graph (on a built nightly version)

[ChALkeR]

On the bottom graphs, lower is faster
On the upper graphs, values > 1 is where native is faster than Buffer

For base64, that's a middle area of the chart only (512 bytes - ~512 KiB), after 512 KiB native is ~2x slower
For hex, that's everything below 512 KiB (after that they are roughly equal)

Note the log scale and that 512 bytes - 512 KiB is probably the common case, despite taking up only the middle of the plot

The strange thing is that above 512 KiB, Buffer.toString('base64') is faster than below 512 KiB

i.e. Buffer.toString('base64') is 2x faster on 768 KiB than on 512 KiB.

toBase64(262144): native x 26,376 ops/sec @ 37μs/op (27μs..1250μs)
toBase64(262144): Buffer x 21,117 ops/sec @ 47μs/op (35μs..1526μs)
toHex(262144): native x 9,231 ops/sec @ 108μs/op (94μs..1246μs)
toHex(262144): Buffer x 6,983 ops/sec @ 143μs/op (126μs..1397μs)
toBase64(524288): native x 14,307 ops/sec @ 69μs/op (50μs..4ms)
toBase64(524288): Buffer x 11,579 ops/sec @ 86μs/op (66μs..3ms) <-- A
toHex(524288): native x 4,809 ops/sec @ 207μs/op (185μs..1700μs)
toHex(524288): Buffer x 5,229 ops/sec @ 191μs/op (183μs..457μs)
toBase64(786432): native x 9,812 ops/sec @ 101μs/op (80μs..943μs)
toBase64(786432): Buffer x 24,744 ops/sec @ 40μs/op (34μs..528μs) <-- B, faster than A?
toHex(786432): native x 3,234 ops/sec @ 309μs/op (281μs..844μs)
toHex(786432): Buffer x 3,499 ops/sec @ 285μs/op (274μs..530μs)

Data: https://docs.google.com/spreadsheets/d/1CZLUWoEf5vDgJh1uq7jlu-mZEJuZ9Svln9c3wUV71DY/edit

Upd:
1.Buffer#toString('base64') seems to be ~3x faster on 773935 than on 773934:
2. Buffer#toString('hex') seems to be ~1.5x faster on 515957 than on 515956:

toBase64(773934): Buffer x 8,021 ops/sec @ 124μs/op (102μs..1674μs)
toBase64(773935): Buffer x 24,469 ops/sec @ 40μs/op (32μs..563μs)
toHex(515956): Buffer x 3,678 ops/sec @ 271μs/op (235μs..1415μs)
toHex(515957): Buffer x 5,319 ops/sec @ 187μs/op (167μs..533μs)

Seems to be related to string length (1031913 vs 1031914)?
This is also reproducible on Node.js 24 and 22

[ChALkeR]

Huh, searched for those exact numbers and found #1024 from 10 years ago

Externalized strings?