Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
Feature Requests
FAQ
Register
Log In
branchless max vs Math.max (cached & uncached)
(version: 0)
Benchmark.js
Comparing performance of:
cached Math.max vs fastMax vs Math.max
Created:
4 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var fastMax = (a, b) => (a - (((a - b) >> 31) & (a - b))); var max = Math.max;
Tests:
cached Math.max
max(Math.random(), Math.random(), Math.random())
fastMax
fastMax(Math.random(), Math.random(), Math.random())
Math.max
Math.max(Math.random(), Math.random(), Math.random())
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (3)
Previous results
Fork
Test case name
Result
cached Math.max
fastMax
Math.max
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15
Browser/OS:
Safari 17 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=554188" width="100%" height="500px"></iframe>
fastMax
4.5M/s
cached Math.max
4.3M/s
Math.max
4.0M/s
View exact numbers
Test name
Executions per second
✓
fastMax
4,473,288 Ops/sec
cached Math.max
4,333,355 Ops/sec
Math.max
4,039,007 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's dive into the explanation of the provided benchmark. **What is being tested?** The benchmark measures the performance difference between three approaches to find the maximum value of three random numbers: 1. `fastMax`: A custom implementation of `Math.max` that uses bitwise operations to avoid calling the `Math.max` function directly. 2. `cached Math.max`: An implementation of `Math.max` where the result is cached (i.e., stored in a variable) and reused instead of recalculating it every time. 3. `Math.max`: The built-in `Math.max` function from JavaScript's standard library. **Options compared** The benchmark compares the performance of these three approaches: * **Pros and Cons:** + `fastMax`: This approach avoids calling `Math.max`, which can be expensive. However, it uses bitwise operations, which might not be as readable or maintainable as other approaches. + `cached Math.max`: This approach reuses the cached result, which can reduce overhead compared to recalculating the maximum value every time. However, it might consume more memory if the benchmark is run multiple times. + `Math.max`: This is the built-in implementation that provides good performance and readability. However, it's not optimized for this specific use case. * **Other considerations:** + The benchmark doesn't consider other factors like input distribution or edge cases, which might affect the results. **Library usage** None of the test cases uses any external libraries beyond JavaScript's standard library (`Math`). **Special JS features or syntax** The custom implementation `fastMax` uses bitwise operations to avoid calling `Math.max`. Specifically, it uses the following trick: ```javascript var fastMax = (a, b) => (a - (((a - b) >> 31) & (a - b))); ``` This expression takes advantage of the fact that in two's complement representation, the most significant bit of an integer represents the sign. By subtracting `b` from `a`, shifting the result to the right by 31 bits (`>>> 31`), and then performing a bitwise AND with `a - b`, the resulting value is equivalent to the maximum of `a` and `b`. This trick avoids calling `Math.max`, making it faster. Overall, the benchmark provides a simple and straightforward way to compare the performance of different approaches to finding the maximum value of three random numbers.
Related benchmarks
Math.max/min vs if vs ternary vs bitwise & ~~ - 4 numbers
array math.max (3 variants) vs for loop (4 variants)
array math.max (3 variants) vs for loop (5 variants)
Comments
Confirm delete:
Do you really want to delete benchmark?