Benchmark: Finding the Fastest Clamp

Finding the Fastest Clamp (version: 0)

Generates a list of random numbers between -1.5 and +1.5 then loops through the list with each function. Functions that uses branches should have more variance in speed since they can potentially exit early. Functions that use arithmetic should have little to no variance but do more computation.

Comparing performance of: `Early Return vs Compute Offset in Array vs Math Min and Max Functions vs Ternary Operators vs If...else vs Pure Arithmetic`

Created: one year ago by: Guest

Go to the latest result

Script Preparation code:

var numbers = new Array(1000);
var results = new Array(1000);

for (let i = 0; i < numbers.length; i++);
{
  numbers[i] = (Math.random() - 0.5) * 3;
}

function clamp(min, value, max) {
	if (value >= max)
		return max;
	if (value <= min)
		return min;
	return value;
}

function clamp2(min, value, max) {
	return [min, value, max][1 + (value >= max) - (value <= min)];
}

function clamp3(min, value, max) {
	return Math.max(value, Math.min(value, max));
}

function clamp4(min, value, max) {
    return value <= min ? min : (value >= max ? max : value);
}

function clamp5(min, value, max) {
	if (value >= max)
		return max;
	else if (value <= min)
		return min;
	else
		return value;
}

function clamp6(min, value, max) {
	return  (value >= max) * (max - value) +
			(value <= min) * (min - value) +
			value;
}

Tests:

Early Return
for (let i = 0; i < numbers.length; i++) { results[i] = clamp(0, numbers[i], 1.0); }
Compute Offset in Array
for (let i = 0; i < numbers.length; i++) { results[i] = clamp2(0, numbers[i], 1.0); }
Math Min and Max Functions
for (let i = 0; i < numbers.length; i++) { results[i] = clamp3(0, numbers[i], 1.0); }
Ternary Operators
for (let i = 0; i < numbers.length; i++) { results[i] = clamp4(0, numbers[i], 1.0); }
If...else
for (let i = 0; i < numbers.length; i++) { results[i] = clamp5(0, numbers[i], 1.0); }
Pure Arithmetic
for (let i = 0; i < numbers.length; i++) { results[i] = clamp6(0, numbers[i], 1.0); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Early Return
Compute Offset in Array
Math Min and Max Functions
Ternary Operators
If...else
Pure Arithmetic

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0

Browser/OS: Firefox 140 on Mac OS X 10.15

View result in a separate tab

Pure Arithmetic

794K/s

Ternary Operators

687K/s

If...else

684K/s

Early Return

107K/s

Compute Offset in Array

92K/s

Math Min and Max Functions

45K/s

View exact numbers

Test name	Executions per second
✓ Pure Arithmetic	793,983 Ops/sec
Ternary Operators	687,135 Ops/sec
If...else	683,892 Ops/sec
Early Return	107,381 Ops/sec
Compute Offset in Array	91,905 Ops/sec
Math Min and Max Functions	44,964 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark measures the performance of different JavaScript functions for clamping (restricting) a value within a specified range.

**Options Compared**

1. **Early Return**: The `clamp` function uses early returns to exit early when the condition is met, reducing unnecessary computations.
2. **Compute Offset in Array**: This approach calculates the index offset before accessing the array, which may reduce cache misses and improve performance.
3. **Math Min and Max Functions**: Instead of using a custom implementation, this approach relies on built-in `Math.min` and `Math.max` functions, which are typically faster and more efficient.
4. **If...else**: This option uses an if-else statement to determine the clamped value, introducing branching logic that may slow down the computation.
5. **Pure Arithmetic**: This approach only performs arithmetic operations without any conditional statements or branching.

**Pros and Cons**

* **Early Return**:
	+ Pros: Reduces unnecessary computations, potentially faster execution.
	+ Cons: May introduce additional branch prediction errors if not done correctly.
* **Compute Offset in Array**:
	+ Pros: Potential cache hits due to contiguous memory access.
	+ Cons: May increase computational overhead due to index calculation.
* **Math Min and Max Functions**:
	+ Pros: Leveraging built-in, optimized functions reduces execution time.
	+ Cons: May rely on browser-specific implementations or caching effects.
* **If...else**:
	+ Pros: Simple implementation with minimal code changes.
	+ Cons: Introduces branching logic, potentially slower execution.
* **Pure Arithmetic**:
	+ Pros: Avoids conditional statements and branching, potentially faster execution.
	+ Cons: Requires careful calculation to ensure correct results.

**Library Usage**

The benchmark uses the `Math` library for its built-in `min` and `max` functions. No other libraries are explicitly mentioned in the provided code.

**Special JS Features or Syntax**

None of the specific features or syntax (e.g., arrow functions, async/await) are used in this benchmark. The focus is on comparing different algorithmic approaches to clamping a value within a specified range.

**Conclusion**

The choice of optimization approach can significantly impact performance in this benchmark. Early return and pure arithmetic approaches show promise, while the use of `Math` library functions and if-else statements may introduce additional overhead. Computing offset in array might lead to cache hits, but also introduces computational overhead. The optimal approach depends on the specific requirements and constraints of the application.