buffer: improve performance of multiple Buffer operations#61871
Open
thisalihassan wants to merge 7 commits intonodejs:mainfrom
Open
buffer: improve performance of multiple Buffer operations#61871thisalihassan wants to merge 7 commits intonodejs:mainfrom
thisalihassan wants to merge 7 commits intonodejs:mainfrom
Conversation
Collaborator
|
Review requested:
|
nodejs-github-bot
added
buffer
thisalihassan
force-pushed
the
buffer-perf-improvements
branch
from
d2ba38f to
495feb5
Compare
Renegade334
reviewed
Feb 17, 2026
Comment on lines
+1210
to
+1217
| void FastSwap16(Local<Value> receiver, | ||
| Local<Value> buffer_obj, | ||
| // NOLINTNEXTLINE(runtime/references) | ||
| FastApiCallbackOptions& options) { | ||
| HandleScope scope(options.isolate); | ||
| ArrayBufferViewContents<char> buffer(buffer_obj); | ||
| CHECK(nbytes::SwapBytes16(const_cast<char*>(buffer.data()), buffer.length())); | ||
| } |
Member
There was a problem hiding this comment.
These fast callbacks are non-identical to the conventional callbacks they shadow.
- The existing callbacks validate their argument and throws to JS if invalid, whereas your fast callbacks hard-crash the process. It might be better to validate in the JS layer, then use the same unwrapping logic on both sides.
- Your fast callback cannot have a different return convention to the conventional callback. You will need to remove the return value from the conventional callback.
Member
There was a problem hiding this comment.
Was removing the validation instead of moving it to js intentional?
Also fast paths can keep the validation and fall back to slow i think, so we can still validate on the src side?
Member
There was a problem hiding this comment.
Also fast paths can keep the validation and fall back to slow i think, so we can still validate on the src side?
This is outdated, the fast API doesn't use fallback any more (since Node.js v23.x).
However, any validation in a JS wrapper should be shadowed by a CHECK or DCHECK in the C++ binding.
lib/buffer.js
Outdated
| byteOffset, | ||
| encodingsMap.ascii, | ||
| dir), | ||
| indexOfString(buf, val, byteOffset, encodingsMap.latin1, dir), |
Member
There was a problem hiding this comment.
Same behaviour AFAICT, but encodingsMap.ascii seems more appropriate.
Contributor
Author
There was a problem hiding this comment.
Yes same behaviour IndexOfString only has branches for UCS2, UTF8, and Latin1, Adding an ASCII branch to IndexOfString would just be a duplicate of the Latin1 branch since ASCII is a subset of Latin1.
Member
There was a problem hiding this comment.
That's my point, these are still discrete encodings even though the behaviour here is the same, so this should pass encodingsMap.ascii to the binding and IndexOfString should add a condition to send this down the same path.
Comment on lines
+1210
to
+1217
| void FastSwap16(Local<Value> receiver, | ||
| Local<Value> buffer_obj, | ||
| // NOLINTNEXTLINE(runtime/references) | ||
| FastApiCallbackOptions& options) { | ||
| HandleScope scope(options.isolate); | ||
| ArrayBufferViewContents<char> buffer(buffer_obj); | ||
| CHECK(nbytes::SwapBytes16(const_cast<char*>(buffer.data()), buffer.length())); | ||
| } |
Member
There was a problem hiding this comment.
Fast callbacks should include debug tracking and call tests.
Contributor
Author
There was a problem hiding this comment.
Thanks for sharing these I will update the code
Renegade334
added
performance
Codecov Report❌ Patch coverage is
Additional details and impacted files@@ Coverage Diff @@
## main #61871 +/- ##
========================================
Coverage 89.65% 89.65%
========================================
Files 676 676
Lines 206231 206365 +134
Branches 39505 39534 +29
========================================
+ Hits 184898 185019 +121
- Misses 13463 13475 +12
- Partials 7870 7871 +1
🚀 New features to boost your workflow:
|
thisalihassan
force-pushed
the
buffer-perf-improvements
branch
4 times, most recently
from
1395d2f to
01ba74f
Compare
Renegade334
reviewed
Feb 18, 2026
src/node_buffer.cc
Outdated
| FastApiCallbackOptions& options) { | ||
| TRACK_V8_FAST_API_CALL("buffer.swap16"); | ||
| HandleScope scope(options.isolate); | ||
| ArrayBufferViewContents<char> buffer(buffer_obj); |
Member
There was a problem hiding this comment.
ArrayBufferViewContents is wrong here, as buffer.data() may be a stack-allocated copy of the byte data rather than the data itself. SPREAD_BUFFER_ARG is the correct macro to use here, as per the conventional callback.
Contributor
Author
There was a problem hiding this comment.
@Renegade334 replaced ArrayBufferViewContents with SPREAD_BUFFER_ARG in all three fast swap callbacks
ChALkeR
reviewed
Feb 18, 2026
Member
There was a problem hiding this comment.
For toHex, wait until #61609, which improves native perf significantly (more than Uint8Array.prototype.toHex)
See also #60249 (comment)
ChALkeR
reviewed
Feb 18, 2026
| } else if (value.length === 1) { | ||
| // Fast path: If `value` fits into a single byte, use that numeric value. | ||
| if (normalizedEncoding === 'utf8') { | ||
| if (normalizedEncoding === 'utf8' || normalizedEncoding === 'ascii') { |
Member
There was a problem hiding this comment.
Currently, ascii behaves exactly like latin1
Unsure if by design or accidentally
Contributor
Author
There was a problem hiding this comment.
yes, this is safe by design I am just extending the existing single byte numeric optimization to cover ASCII, since the guard already constrains it to the valid ASCII range.
Contributor
Author
|
Note on toBase64 / toBase64url: I also tried replacing the C++ base64Slice/base64urlSlice bindings with V8's Uint8Array.prototype.toBase64() (similar to the toHex change) but it caused a 35-54% regression across all buffer sizes so I reverted base64/base64url and kept only the toHex optimization which showed a clear +26-37% win. |
Member
|
@thisalihassan toHex doesn't show a win anymore with Instead, it's ~3x slower. See nodejs/nbytes#12 |
Contributor
Author
|
Hi @ChALkeR thanks for flagging I was not aware. I benchmarked the nibble approach locally and it's indeed a much bigger win (~3x vs my ~30% with toHex). Reverted the toHex path entirely the other changes in this PR are unaffected. Should I include the nbytes nibble HexEncode optimization in this PR or keep them as separate PRs?
|
anonrig
reviewed
Feb 18, 2026
|
|
||
| function testFastSwap32() { | ||
| const buf = Buffer.alloc(256); | ||
| buf.swap32(); |
Member
There was a problem hiding this comment.
Each of these methods should test the output of relevant swrap methods.
Contributor
Author
There was a problem hiding this comment.
Done each test now verifies the swapped output
Contributor
Author
There was a problem hiding this comment.
can you please re-review when you get time?
| } else if (value.length === 1) { | ||
| // Fast path: If `value` fits into a single byte, use that numeric value. | ||
| if (normalizedEncoding === 'utf8') { | ||
| if (normalizedEncoding === 'utf8' || normalizedEncoding === 'ascii') { |
Member
There was a problem hiding this comment.
Please update comment to why we can add ASCII here.
| if (length !== undefined) { | ||
| validateInteger(length, 'length', 0); | ||
| end = offset + length; | ||
| end = MathMin(offset + length, viewLength); |
Member
There was a problem hiding this comment.
Can you add a comment to why we have this change now?
Contributor
Author
There was a problem hiding this comment.
Sure, the clamping is required because we switched from TypedArrayPrototypeSlice (which clamped silently)
Contributor
Author
Hi @ChALkeR I see that your changes landed, congratualtions on that huge win. Is there benchmark-ci that we can run on this PR? I can rebase it |
Contributor
Author
|
I re-ran the benchmark against the latest main (which contains the nibble improvement) and found out there are few regressions caused by my code:
I tried fixing this regression but unavoidable Attaching Details below: buffer-benchmark-all-rebased.csv -- raw benchmark CSV |
Contributor
Author
|
compare-R-output.txt-- full output from Rscript benchmark/compare.R (shared as a file to avoid cluttering the PR comment). |
- copyBytesFrom: calculate byte offsets directly instead of
slicing into an intermediate typed array
- toString('hex'): use V8 Uint8Array.prototype.toHex() builtin
- fill: add single-char ASCII fast path
- indexOf: use indexOfString directly for ASCII encoding
- swap16/32/64: add V8 Fast API functions
- Guard ensureUint8ArrayToHex against --no-js-base-64 flag by falling back to C++ hexSlice when toHex is unavailable - Remove THROW_AND_RETURN_UNLESS_BUFFER and return value from slow Swap16/32/64 to match fast path conventions (JS validates) - Add TRACK_V8_FAST_API_CALL to FastSwap16/32/64 - Add test/parallel/test-buffer-swap-fast.js for fast API verification
Remove V8 Uint8Array.prototype.toHex() path for Buffer.toString('hex')
in favour of the upcoming nbytes HexEncode improvement (nodejs/nbytes#12)
which is ~3x faster through the existing C++ hexSlice path.
Refs: nodejs/nbytes#12
thisalihassan
force-pushed
the
buffer-perf-improvements
branch
from
59f5d09 to
48abfc5
Compare
Contributor
Author
|
PS: I resolved some conflicts |
Contributor
Author
|
Hi @ChALkeR @anonrig @Renegade334 is this PR ready to land? can you also please check the latest benchmarks i have posted, I have compiled PDF for this benchmark in one my comments above for more detail 
|
Qard
approved these changes
Mar 3, 2026
Member
Qard
left a comment
Qard
left a comment
There was a problem hiding this comment.
Generally LGTM, but one small nit.
Contributor
Contributor
Author
|
Results from the CI, however it tells a slightly different story than my local benchmark at n=30 |
ChALkeR
reviewed
Mar 5, 2026
ChALkeR
reviewed
Mar 5, 2026
| return this; | ||
| } | ||
| return _swap16(this); | ||
| _swap16(this); |
Member
There was a problem hiding this comment.
what would happen if it's called on not a TypeArrayView now?
Member
There was a problem hiding this comment.
i.e. Buffer.prototype.swap16.apply(new Array(128))
Contributor
Author
There was a problem hiding this comment.
Good catch, I will add a JS side guard
Member
There was a problem hiding this comment.
It changes the method to not being callable on a typedarray that is not an uint8array, but the previous behavior was inconsistent in that case anyway as the js part swapped elements and the src part swapped bytes
So I think explicitly blocking non-uint8arr should be fine and not a semver-major?
(perhaps cc @nodejs/lts just in case)
ChALkeR
reviewed
Mar 5, 2026
lib/buffer.js
Outdated
Comment on lines
1270
to
1271
Member
There was a problem hiding this comment.
does this still hold? including the threshold
Contributor
Author
There was a problem hiding this comment.
Good call. I benchmarked all sizes at n=30 with the JS loop removed to force the Fast API path the crossover is now between 32 and 64 bytes (at len=64, Fast API is +55-102% faster) let's lowered thresholds from 128/192 to 32, sounds good?
confidence improvement accuracy (*) (**) (***)
buffers/buffer-swap.js n=1000000 len=1024 method='swap16' aligned='false' *** 17.32 % ±0.69% ±0.92% ±1.20%
buffers/buffer-swap.js n=1000000 len=1024 method='swap16' aligned='true' *** 25.28 % ±0.79% ±1.05% ±1.37%
buffers/buffer-swap.js n=1000000 len=1024 method='swap32' aligned='false' *** 17.46 % ±1.86% ±2.48% ±3.23%
buffers/buffer-swap.js n=1000000 len=1024 method='swap32' aligned='true' *** 19.87 % ±3.73% ±5.02% ±6.66%
buffers/buffer-swap.js n=1000000 len=1024 method='swap64' aligned='false' *** 17.06 % ±0.81% ±1.08% ±1.41%
buffers/buffer-swap.js n=1000000 len=1024 method='swap64' aligned='true' *** 20.90 % ±1.06% ±1.41% ±1.84%
buffers/buffer-swap.js n=1000000 len=128 method='swap16' aligned='false' *** 75.18 % ±3.58% ±4.80% ±6.33%
buffers/buffer-swap.js n=1000000 len=128 method='swap16' aligned='true' *** 71.18 % ±5.91% ±7.94% ±10.49%
buffers/buffer-swap.js n=1000000 len=128 method='swap32' aligned='false' *** 223.63 % ±5.28% ±7.10% ±9.41%
buffers/buffer-swap.js n=1000000 len=128 method='swap32' aligned='true' *** 222.05 % ±7.30% ±9.83% ±13.02%
buffers/buffer-swap.js n=1000000 len=128 method='swap64' aligned='false' *** 199.01 % ±3.32% ±4.44% ±5.84%
buffers/buffer-swap.js n=1000000 len=128 method='swap64' aligned='true' *** 196.73 % ±2.93% ±3.92% ±5.15%
buffers/buffer-swap.js n=1000000 len=192 method='swap16' aligned='false' *** 64.24 % ±6.79% ±9.14% ±12.11%
buffers/buffer-swap.js n=1000000 len=192 method='swap16' aligned='true' *** 68.78 % ±3.34% ±4.44% ±5.79%
buffers/buffer-swap.js n=1000000 len=192 method='swap32' aligned='false' *** 65.99 % ±2.24% ±3.01% ±3.98%
buffers/buffer-swap.js n=1000000 len=192 method='swap32' aligned='true' *** 67.15 % ±1.48% ±1.97% ±2.56%
buffers/buffer-swap.js n=1000000 len=192 method='swap64' aligned='false' *** 73.17 % ±3.08% ±4.11% ±5.38%
buffers/buffer-swap.js n=1000000 len=192 method='swap64' aligned='true' *** 73.66 % ±5.28% ±7.06% ±9.24%
buffers/buffer-swap.js n=1000000 len=2056 method='swap16' aligned='false' *** 6.42 % ±3.37% ±4.50% ±5.89%
buffers/buffer-swap.js n=1000000 len=2056 method='swap16' aligned='true' *** 18.17 % ±0.79% ±1.05% ±1.37%
buffers/buffer-swap.js n=1000000 len=2056 method='swap32' aligned='false' *** 5.63 % ±2.11% ±2.84% ±3.77%
buffers/buffer-swap.js n=1000000 len=2056 method='swap32' aligned='true' *** 14.59 % ±3.11% ±4.19% ±5.55%
buffers/buffer-swap.js n=1000000 len=2056 method='swap64' aligned='false' *** 6.64 % ±0.72% ±0.96% ±1.26%
buffers/buffer-swap.js n=1000000 len=2056 method='swap64' aligned='true' *** 15.72 % ±0.83% ±1.10% ±1.43%
buffers/buffer-swap.js n=1000000 len=256 method='swap16' aligned='false' *** 59.88 % ±1.10% ±1.47% ±1.91%
buffers/buffer-swap.js n=1000000 len=256 method='swap16' aligned='true' *** 64.75 % ±1.66% ±2.22% ±2.90%
buffers/buffer-swap.js n=1000000 len=256 method='swap32' aligned='false' *** 61.13 % ±1.43% ±1.91% ±2.51%
buffers/buffer-swap.js n=1000000 len=256 method='swap32' aligned='true' *** 66.13 % ±3.85% ±5.14% ±6.73%
buffers/buffer-swap.js n=1000000 len=256 method='swap64' aligned='false' *** 63.29 % ±4.56% ±6.06% ±7.89%
buffers/buffer-swap.js n=1000000 len=256 method='swap64' aligned='true' *** 63.97 % ±1.21% ±1.61% ±2.09%
buffers/buffer-swap.js n=1000000 len=32 method='swap16' aligned='false' * -2.06 % ±1.95% ±2.60% ±3.41%
buffers/buffer-swap.js n=1000000 len=32 method='swap16' aligned='true' 0.61 % ±5.45% ±7.34% ±9.71%
buffers/buffer-swap.js n=1000000 len=32 method='swap32' aligned='false' *** -10.32 % ±3.61% ±4.80% ±6.25%
buffers/buffer-swap.js n=1000000 len=32 method='swap32' aligned='true' *** -9.89 % ±2.89% ±3.88% ±5.14%
buffers/buffer-swap.js n=1000000 len=32 method='swap64' aligned='false' *** -23.02 % ±1.39% ±1.86% ±2.44%
buffers/buffer-swap.js n=1000000 len=32 method='swap64' aligned='true' *** -22.16 % ±2.26% ±3.01% ±3.94%
buffers/buffer-swap.js n=1000000 len=64 method='swap16' aligned='false' *** 102.39 % ±4.19% ±5.60% ±7.34%
buffers/buffer-swap.js n=1000000 len=64 method='swap16' aligned='true' *** 104.13 % ±8.21% ±10.97% ±14.38%
buffers/buffer-swap.js n=1000000 len=64 method='swap32' aligned='false' *** 72.60 % ±4.43% ±5.92% ±7.78%
buffers/buffer-swap.js n=1000000 len=64 method='swap32' aligned='true' *** 75.07 % ±1.88% ±2.51% ±3.26%
buffers/buffer-swap.js n=1000000 len=64 method='swap64' aligned='false' *** 58.19 % ±3.33% ±4.45% ±5.83%
buffers/buffer-swap.js n=1000000 len=64 method='swap64' aligned='true' *** 53.81 % ±7.15% ±9.61% ±12.71%
buffers/buffer-swap.js n=1000000 len=768 method='swap16' aligned='false' *** 24.77 % ±0.83% ±1.10% ±1.43%
buffers/buffer-swap.js n=1000000 len=768 method='swap16' aligned='true' *** 25.49 % ±2.20% ±2.96% ±3.92%
buffers/buffer-swap.js n=1000000 len=768 method='swap32' aligned='false' *** 23.44 % ±5.17% ±6.95% ±9.18%
buffers/buffer-swap.js n=1000000 len=768 method='swap32' aligned='true' *** 23.28 % ±1.85% ±2.49% ±3.28%
buffers/buffer-swap.js n=1000000 len=768 method='swap64' aligned='false' *** 24.95 % ±1.01% ±1.34% ±1.75%
buffers/buffer-swap.js n=1000000 len=768 method='swap64' aligned='true' *** 24.14 % ±1.22% ±1.63% ±2.13%
buffers/buffer-swap.js n=1000000 len=8 method='swap16' aligned='false' *** -65.29 % ±1.07% ±1.43% ±1.89%
buffers/buffer-swap.js n=1000000 len=8 method='swap16' aligned='true' *** -65.21 % ±2.58% ±3.46% ±4.58%
buffers/buffer-swap.js n=1000000 len=8 method='swap32' aligned='false' *** -70.24 % ±1.38% ±1.85% ±2.43%
buffers/buffer-swap.js n=1000000 len=8 method='swap32' aligned='true' *** -69.64 % ±2.18% ±2.94% ±3.90%
buffers/buffer-swap.js n=1000000 len=8 method='swap64' aligned='false' *** -74.69 % ±2.65% ±3.55% ±4.69%
buffers/buffer-swap.js n=1000000 len=8 method='swap64' aligned='true' *** -74.21 % ±1.98% ±2.66% ±3.54%
buffers/buffer-swap.js n=1000000 len=8192 method='swap16' aligned='false' 3.85 % ±4.53% ±6.02% ±7.84%
buffers/buffer-swap.js n=1000000 len=8192 method='swap16' aligned='true' *** 8.17 % ±1.48% ±1.99% ±2.61%
buffers/buffer-swap.js n=1000000 len=8192 method='swap32' aligned='false' 2.91 % ±3.53% ±4.69% ±6.10%
buffers/buffer-swap.js n=1000000 len=8192 method='swap32' aligned='true' *** 9.90 % ±2.74% ±3.69% ±4.89%
buffers/buffer-swap.js n=1000000 len=8192 method='swap64' aligned='false' 0.58 % ±3.38% ±4.50% ±5.86%
buffers/buffer-swap.js n=1000000 len=8192 method='swap64' aligned='true' *** 9.73 % ±2.00% ±2.68% ±3.53%
buffers/buffer-swap.js n=1000000 len=96 method='swap16' aligned='false' *** 169.05 % ±3.56% ±4.75% ±6.21%
buffers/buffer-swap.js n=1000000 len=96 method='swap16' aligned='true' *** 167.61 % ±4.25% ±5.65% ±7.36%
buffers/buffer-swap.js n=1000000 len=96 method='swap32' aligned='false' *** 142.63 % ±2.33% ±3.12% ±4.07%
buffers/buffer-swap.js n=1000000 len=96 method='swap32' aligned='true' *** 144.52 % ±3.78% ±5.03% ±6.54%
buffers/buffer-swap.js n=1000000 len=96 method='swap64' aligned='false' *** 118.22 % ±3.54% ±4.72% ±6.16%
buffers/buffer-swap.js n=1000000 len=96 method='swap64' aligned='true' *** 117.67 % ±3.01% ±4.01% ±5.22%
Be aware that when doing many comparisons the risk of a false-positive
result increases. In this case, there are 66 comparisons, you can thus
expect the following amount of false-positive results:
3.30 false positives, when considering a 5% risk acceptance (*, **, ***),
0.66 false positives, when considering a 1% risk acceptance (**, ***),
0.07 false positives, when considering a 0.1% risk acceptance (***)
Contributor
Author
There was a problem hiding this comment.
I fine tuned it more to see finer threshold here are the results
swap16: threshold at 32 (wins at 40, flat at 32)
swap32: threshold at 32 (wins at 40, loses at 32)
swap64: threshold at 48 (loses at 40, wins at 48)
len: [24, 32, 40, 48, 56, 64, 96, 128]
n=30
confidence improvement accuracy (*) (**) (***)
buffers/buffer-swap.js n=1000000 len=128 method='swap16' aligned='false' *** 71.81 % ±1.25% ±1.66% ±2.17%
buffers/buffer-swap.js n=1000000 len=128 method='swap16' aligned='true' *** 71.54 % ±1.27% ±1.70% ±2.22%
buffers/buffer-swap.js n=1000000 len=128 method='swap32' aligned='false' *** 225.55 % ±2.43% ±3.24% ±4.24%
buffers/buffer-swap.js n=1000000 len=128 method='swap32' aligned='true' *** 223.82 % ±2.31% ±3.10% ±4.08%
buffers/buffer-swap.js n=1000000 len=128 method='swap64' aligned='false' *** 188.61 % ±13.26% ±17.86% ±23.71%
buffers/buffer-swap.js n=1000000 len=128 method='swap64' aligned='true' *** 193.06 % ±2.44% ±3.28% ±4.33%
buffers/buffer-swap.js n=1000000 len=32 method='swap16' aligned='false' -0.77 % ±2.11% ±2.82% ±3.72%
buffers/buffer-swap.js n=1000000 len=32 method='swap16' aligned='true' * 3.81 % ±3.06% ±4.12% ±5.44%
buffers/buffer-swap.js n=1000000 len=32 method='swap32' aligned='false' *** -9.94 % ±2.08% ±2.79% ±3.67%
buffers/buffer-swap.js n=1000000 len=32 method='swap32' aligned='true' *** -11.74 % ±1.24% ±1.66% ±2.16%
buffers/buffer-swap.js n=1000000 len=32 method='swap64' aligned='false' *** -20.22 % ±2.05% ±2.75% ±3.65%
buffers/buffer-swap.js n=1000000 len=32 method='swap64' aligned='true' *** -22.31 % ±1.46% ±1.95% ±2.54%
buffers/buffer-swap.js n=1000000 len=40 method='swap16' aligned='false' *** 19.73 % ±2.77% ±3.70% ±4.86%
buffers/buffer-swap.js n=1000000 len=40 method='swap16' aligned='true' *** 17.92 % ±3.01% ±4.04% ±5.32%
buffers/buffer-swap.js n=1000000 len=40 method='swap32' aligned='false' *** 6.82 % ±2.19% ±2.93% ±3.85%
buffers/buffer-swap.js n=1000000 len=40 method='swap32' aligned='true' * 3.92 % ±3.70% ±4.96% ±6.55%
buffers/buffer-swap.js n=1000000 len=40 method='swap64' aligned='false' *** -7.18 % ±1.31% ±1.75% ±2.29%
buffers/buffer-swap.js n=1000000 len=40 method='swap64' aligned='true' * -4.99 % ±4.59% ±6.17% ±8.16%
buffers/buffer-swap.js n=1000000 len=48 method='swap16' aligned='false' *** 35.26 % ±1.90% ±2.53% ±3.30%
buffers/buffer-swap.js n=1000000 len=48 method='swap16' aligned='true' *** 35.72 % ±1.92% ±2.56% ±3.34%
buffers/buffer-swap.js n=1000000 len=48 method='swap32' aligned='false' *** 25.27 % ±1.89% ±2.52% ±3.28%
buffers/buffer-swap.js n=1000000 len=48 method='swap32' aligned='true' *** 26.36 % ±2.25% ±2.99% ±3.90%
buffers/buffer-swap.js n=1000000 len=48 method='swap64' aligned='false' *** 6.91 % ±3.65% ±4.88% ±6.40%
buffers/buffer-swap.js n=1000000 len=48 method='swap64' aligned='true' *** 8.63 % ±1.51% ±2.01% ±2.61%
buffers/buffer-swap.js n=1000000 len=56 method='swap16' aligned='false' *** 51.76 % ±6.79% ±9.11% ±12.02%
buffers/buffer-swap.js n=1000000 len=56 method='swap16' aligned='true' *** 52.77 % ±2.26% ±3.01% ±3.92%
buffers/buffer-swap.js n=1000000 len=56 method='swap32' aligned='false' *** 42.66 % ±2.36% ±3.15% ±4.09%
buffers/buffer-swap.js n=1000000 len=56 method='swap32' aligned='true' *** 42.23 % ±2.02% ±2.69% ±3.50%
buffers/buffer-swap.js n=1000000 len=56 method='swap64' aligned='false' *** 17.33 % ±4.06% ±5.44% ±7.15%
buffers/buffer-swap.js n=1000000 len=56 method='swap64' aligned='true' *** 21.52 % ±2.44% ±3.26% ±4.26%
buffers/buffer-swap.js n=1000000 len=64 method='swap16' aligned='false' *** 105.28 % ±2.64% ±3.52% ±4.60%
buffers/buffer-swap.js n=1000000 len=64 method='swap16' aligned='true' *** 106.73 % ±2.36% ±3.15% ±4.11%
buffers/buffer-swap.js n=1000000 len=64 method='swap32' aligned='false' *** 72.98 % ±2.03% ±2.71% ±3.54%
buffers/buffer-swap.js n=1000000 len=64 method='swap32' aligned='true' *** 75.11 % ±2.15% ±2.86% ±3.72%
buffers/buffer-swap.js n=1000000 len=64 method='swap64' aligned='false' *** 55.22 % ±1.55% ±2.06% ±2.69%
buffers/buffer-swap.js n=1000000 len=64 method='swap64' aligned='true' *** 57.80 % ±2.09% ±2.78% ±3.63%
buffers/buffer-swap.js n=1000000 len=96 method='swap16' aligned='false' *** 163.96 % ±2.85% ±3.80% ±4.96%
buffers/buffer-swap.js n=1000000 len=96 method='swap16' aligned='true' *** 162.39 % ±1.78% ±2.37% ±3.09%
buffers/buffer-swap.js n=1000000 len=96 method='swap32' aligned='false' *** 142.52 % ±2.52% ±3.36% ±4.38%
buffers/buffer-swap.js n=1000000 len=96 method='swap32' aligned='true' *** 140.51 % ±2.31% ±3.08% ±4.01%
buffers/buffer-swap.js n=1000000 len=96 method='swap64' aligned='false' *** 119.28 % ±2.34% ±3.11% ±4.05%
buffers/buffer-swap.js n=1000000 len=96 method='swap64' aligned='true' *** 116.69 % ±3.63% ±4.84% ±6.30%
Be aware that when doing many comparisons the risk of a false-positive
result increases. In this case, there are 48 comparisons, you can thus
expect the following amount of false-positive results:
2.40 false positives, when considering a 5% risk acceptance (*, **, ***),
0.48 false positives, when considering a 1% risk acceptance (**, ***),
0.05 false positives, when considering a 0.1% risk acceptance (***)
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
7 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Multiple performance improvements to Buffer operations, verified with benchmarks (15-30 runs, comparing old vs new binaries built from same tree).
Changes
Buffer.copyBytesFrom()(+100-210%)Avoid intermediate
TypedArrayPrototypeSliceallocation by calculating byte offsets directly into the source TypedArray's underlying ArrayBuffer.Buffer.prototype.fill("t", "ascii")(+26-37%)ASCII
indexOf(+14-46%)Call
indexOfStringdirectly for ASCII encoding instead of first converting the search value to a Buffer viafromStringFastand then callingindexOfBuffer. ASCII and Latin-1 share the same byte values for characters 0-127.swap16/32/64(+3-38%)Add V8 Fast API C++ functions (
FastSwap16/32/64) alongside the existing slow path. Largest gains at len=256 (+35%).Benchmark results
Key results (15-30 runs,
***= p < 0.001):Attaching Details below:
detail.pdf -- visual breakdown
buffer-benchmark-all-rebased.csv -- raw benchmark CSV
compare-R-output.txt-- full output