Benchmark: fast absolute value (branched & branchless) vs abs

Script Preparation code:

var abs = Math.abs;
var fastAV = a => a - ((a < 0) * a * 2);
var fastAV2 = a => a < 0 ? -a : a;

Tests:

native
abs(-10); abs(10); abs(-10.1); abs(10.1);
custom (branchless)
fastAV(-10); fastAV(10); fastAV(-10.1); fastAV(10.1);
custom (branched)
fastAV2(-10); fastAV2(10); fastAV2(-10.1); fastAV2(10.1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native
custom (branchless)
custom (branched)

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/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
native	6599628.5 Ops/sec
custom (branchless)	6569579.5 Ops/sec
custom (branched)	6522691.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a benchmark test comparing three different approaches to calculate the absolute value of a number in JavaScript:

1. Native implementation using `Math.abs()`
2. Branchless implementation (fast absolute value) using a single operation
3. Branched implementation (custom fast absolute value) using a conditional statement

**Tested Options**

The three options are compared as follows:

* **Native**: The standard `Math.abs()` function in JavaScript.
* **Custom (Branchless)**: A branchless implementation that uses a single operation to calculate the absolute value, avoiding the use of conditional statements.
* **Custom (Branched)**: A branched implementation that uses a conditional statement to determine whether the input is negative or non-negative.

**Pros and Cons**

Here are some pros and cons of each approach:

### Native (`Math.abs()`)

Pros:

* Widely supported and optimized by JavaScript engines
* Easy to understand and maintain

Cons:

* May incur overhead due to function call and stack lookup
* May not be as efficient as custom implementations for specific use cases

### Custom (Branchless)

Pros:

* Can be faster than the native implementation, especially for small inputs
* Reduces overhead by avoiding function calls and conditional statements

Cons:

* Requires careful optimization to avoid unnecessary branches
* May require manual handling of edge cases (e.g., NaN, infinity)

### Custom (Branched)

Pros:

* Easier to understand and maintain than branchless implementations
* Handles edge cases (e.g., NaN, infinity) explicitly

Cons:

* May incur overhead due to conditional statements and function calls
* May not be as efficient as branchless implementations for large inputs

**Library Used**

There is no explicit library mentioned in the provided JSON. However, it's worth noting that some JavaScript engines, like WebAssembly (WASM), may provide additional optimization options or runtime libraries that can improve performance.

**Special JS Feature/Syntax**

The benchmark test uses a special syntax feature called **"const declarations"**, which was introduced in ECMAScript 2015 (ES6). This allows the use of `const` to declare variables that cannot be reassigned. The syntax is used throughout the provided JSON, including in the script preparation code and individual test cases.

**Alternatives**

Some alternative approaches to benchmarking JavaScript performance include:

* Using a Just-In-Time (JIT) compiler, like V8 or SpiderMonkey, to generate optimized machine code for specific use cases.
* Utilizing parallel processing techniques, such as multi-threading or concurrent execution, to evaluate multiple test cases simultaneously.
* Employing more advanced optimization techniques, such as loop unrolling or memoization, to improve performance in specific areas of the codebase.

Keep in mind that each alternative approach has its own strengths and weaknesses, and may require additional expertise and resources to implement effectively.

Related benchmarks:

fast absolute value (branched & branchless) vs abs (version: 0)

Comparing performance of: native vs custom (branchless) vs custom (branched)

Created: 2 years ago by: Guest

Jump to the latest result

native

custom (branchless)

custom (branched)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):