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

Jump 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: 9 months 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

Test name	Executions per second
Early Return	107381.5 Ops/sec
Compute Offset in Array	91905.5 Ops/sec
Math Min and Max Functions	44964.4 Ops/sec
Ternary Operators	687134.6 Ops/sec
If...else	683892.3 Ops/sec
Pure Arithmetic	793982.8 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.

Related benchmarks: