Benchmark: Branchless vs Branched Angle Inversion

Script Preparation code:

const PI = Math.PI;
function invertAngleBranch(angle) {
  if (angle + PI > PI) return (angle - PI)
   else return angle + PI 
};
function invertAngleBranchless(angle) {
  return (angle + PI > PI) * (angle - PI) + (angle + PI <= PI) * (angle + PI);
};
function invertAngleBranchlessC1(angle) {
  let tmp = angle + PI;
  return (tmp > PI) * (angle - PI) + (tmp <= PI) * tmp;
};
let tmp2 = NaN; //initialize with float for v8
function invertAngleBranchlessC2(angle) {
  tmp2 = angle + PI;
  return (tmp2 > PI) * (angle - PI) + (tmp2 <= PI) * tmp2;
};
var rnd = Math.random;

Tests:

branched
return invertAngleBranch(rnd());
branchless
return invertAngleBranchless(rnd());
branchless in-scope caching
return invertAngleBranchlessC1(rnd());
branchless out of scope caching
return invertAngleBranchlessC2(rnd());

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
branched
branchless
branchless in-scope caching
branchless out of scope caching

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0

Browser/OS: Firefox 129 on Windows

View result in a separate tab

Test name	Executions per second
branched	597312192.0 Ops/sec
branchless	1779229184.0 Ops/sec
branchless in-scope caching	1777615616.0 Ops/sec
branchless out of scope caching	477350048.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Definition**

The benchmark measures the performance difference between three variants of an angle inversion function in JavaScript:

1. `invertAngleBranch`: The traditional, branched approach with an if-else statement.
2. `invertAngleBranchless`: A branchless implementation using a conditional operator.
3. `invertAngleBranchlessC1` and `invertAngleBranchlessC2`: Two alternative implementations that use caching techniques to minimize the number of evaluations.

**Options Compared**

The benchmark compares the performance of three different approaches:

* Branched approach (`invertAngleBranch`)
* Branchless approach with in-scope caching (`invertAngleBranchlessC1`)
* Branchless approach with out-of-scope caching (`invertAngleBranchlessC2`)

**Pros and Cons**

Here's a brief summary of each approach:

* **Branched approach (`invertAngleBranch`)**: Simple, straightforward implementation. However, it may lead to slower performance due to the if-else statement.
* **Branchless approach with in-scope caching (`invertAngleBranchlessC1`)**: Uses a temporary variable to cache the result of `angle + PI`. This reduces the number of evaluations but still incurs overhead due to the conditional operator.
* **Branchless approach with out-of-scope caching (`invertAngleBranchlessC2`)**: Similar to `C1`, but uses NaN (Not a Number) initialization for the temporary variable. The purpose of using NaN is unclear, as it will likely lead to errors or unexpected behavior.

**Library and Special JS Features**

The benchmark doesn't use any notable libraries, but it does rely on:

* `Math.PI`: A built-in constant representing pi.
* Conditional operator (`?:`): A feature introduced in ECMAScript 2015 (ES6).

**Other Considerations**

The benchmark's focus is on measuring the performance difference between these three approaches. However, there are some additional considerations:

* The use of NaN initialization for `tmp2` in `invertAngleBranchlessC2` might lead to unexpected behavior or errors.
* The caching techniques used in `C1` and `C2` can potentially introduce overhead due to the creation and management of temporary variables.
* The benchmark only measures performance on a single device platform (Desktop, Windows) with a specific browser version (Firefox 129). Results may vary across different platforms, browsers, or architectures.

**Alternatives**

If you were to recreate this benchmark, consider exploring additional approaches or variations:

* Use a more modern JavaScript engine, like V8 or SpiderMonkey, to see if the results differ.
* Implement additional caching techniques, such as memoization or tabling, to further optimize performance.
* Compare the performance of these approaches on different device platforms (e.g., Mobile, WebAssembly) or browser versions.

Keep in mind that the benchmark's focus is on measuring the performance difference between three specific approaches. However, exploring alternative implementations and variations can provide valuable insights into optimization techniques and performance characteristics.

Related benchmarks:

Branchless vs Branched Angle Inversion (version: 0)

Comparing performance of: branched vs branchless vs branchless in-scope caching vs branchless out of scope caching

Created: 4 years ago by: Guest

Jump to the latest result

branched

branchless

branchless in-scope caching

branchless out of scope caching

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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