Benchmark: Anonymous functions - big vs shared

Script Preparation code:

var makeCondition1 = (name, value) => {
    return (context) => {
        var result = context + name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        result += name + value;
        return result;
    };
}

var conditionHandler = (context, name, value) => {
    var result = context + name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    result += name + value;
    return result;
};

var makeCondition2 = (name, value) => {
    return (context) => conditionHandler(context, name, value);
}

var condition1 = makeCondition1(1, 2);
var condition2 = makeCondition2(1, 2);

Tests:

Make condition long
for(let i = 0; i < 1000; i++) makeCondition1(1, 2);
Make condition shared
for(let i = 0; i < 1000; i++) makeCondition2(1, 2);
Calculate condition long
condition1(10);
Calculate condition shared
condition2(10);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Make condition long
Make condition shared
Calculate condition long
Calculate condition shared

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:109.0) Gecko/20100101 Firefox/116.0

Browser/OS: Firefox 116 on Windows

View result in a separate tab

Test name	Executions per second
Make condition long	387175.2 Ops/sec
Make condition shared	405771.2 Ops/sec
Calculate condition long	23088224.0 Ops/sec
Calculate condition shared	19000220.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided benchmark.

**Benchmark Definition JSON**

The benchmark measures the performance difference between two approaches: creating a large, shared function and creating multiple small, independent functions with the same logic.

**Options Compared**

There are three options compared:

1. **Make condition long**: Creating a single function `condition1` that accumulates the result of multiple string concatenations.
2. **Make condition shared**: Creating a smaller number of small functions (`condition2`) and reusing the `conditionHandler` function to perform the same logic, but with less overhead.
3. **Calculate condition long** and **Calculate condition shared**: These test cases use the already created functions `condition1` and `condition2` and call them multiple times to measure their execution performance.

**Pros and Cons**

* **Make condition long**:
	+ Pros: Simple implementation, easy to understand.
	+ Cons: Single function accumulates more variables, leading to increased memory usage and potential stack overflow risks.
* **Make condition shared**:
	+ Pros: Reuses the same logic with less overhead, potentially reducing memory usage and improving cache performance.
	+ Cons: Requires a separate function to be created for each test case, adding complexity.
* **Calculate condition long** and **Calculate condition shared**:
	+ These tests focus on measuring the execution performance of the existing functions.

**Library and Special JS Features**

The benchmark uses JavaScript's function expression syntax (`(name, value) => { ... }`) to create anonymous functions. There is no explicit use of libraries or special features beyond standard JavaScript functionality.

**Other Alternatives**

If you wanted to measure similar performance characteristics, you could consider alternative approaches:

1. **Function inlining**: Measure the performance of the benchmark with and without function inlining to see if it affects the results.
2. **Dynamic function creation**: Create functions dynamically using `new Function()` or a similar method and compare their performance.
3. **Caching**: Implement caching mechanisms for the shared logic to measure its impact on performance.

Keep in mind that these alternatives would require significant changes to the benchmark setup, so it's essential to validate their results before drawing conclusions.

Related benchmarks:

Anonymous functions - big vs shared (version: 0)

Comparing performance of: Make condition long vs Make condition shared vs Calculate condition long vs Calculate condition shared

Created: one year ago by: Guest

Jump to the latest result

Make condition long

Make condition shared

Calculate condition long

Calculate condition shared

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):