Benchmark: Effect of function calls in loops

Script Preparation code:

var N = 10000;
var xs = Array.from(Array(N).keys())
var ys = xs.map((x) => (x + 3) * 0.89 - 16)
var res = Array(N)

function normalFunction(a, b) {
    return Math.sqrt(a ** 2 + b ** 2)
}

var arrowFunction = (a, b) => Math.sqrt(a ** 2 + b ** 2);

Tests:

No function
for (let i = 0; i < N; i++) { res[i] = Math.sqrt(xs[i]**2 + ys[i]**2) }
With normal function
for (let i = 0; i < N; i++) { res[i] = normalFunction(xs[i], ys[i]) }
With arrow function
for (let i = 0; i < N; i++) { res[i] = arrowFunction(xs[i], ys[i]) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
No function
With normal function
With arrow function

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark that tests the effect of function calls in loops. The script preparation code defines two functions: `normalFunction` and `arrowFunction`, which calculate the Euclidean distance between two points using different syntax.

In essence, the benchmark measures how much faster one approach is compared to another when calculating distances within a loop.

**Options Compared**

The benchmark compares three approaches:

1. **No function**: This option bypasses both functions altogether, directly using arithmetic operations.
2. **With normal function**: This option uses `normalFunction` to calculate distances.
3. **With arrow function**: This option uses the shorthand syntax of `arrowFunction` to calculate distances.

**Pros and Cons**

*   **No function**: This approach is likely the fastest since it avoids the overhead of function calls. However, it might be less readable or maintainable due to the lack of explicit code.
*   **With normal function**: Using a named function can make the code more readable but introduces an extra level of abstraction. It's still relatively fast and easy to understand.
*   **With arrow function**: This approach provides a concise way to express the calculation without the need for a dedicated function. However, it might be less readable or maintainable than using a traditional named function.

**Other Considerations**

When interpreting the benchmark results, consider factors like:

*   **Cache locality**: The order of operations and data access patterns can affect cache performance.
*   **Compiler optimizations**: Modern JavaScript compilers (like V8 in Chrome) perform various optimizations that might impact performance differences between approaches.
*   **Browser version**: The specific browser version used for testing can influence the results, especially if it's not a recent release.

**Libraries and Special Features**

There are no libraries or special features explicitly mentioned in this benchmark. However, keep in mind that some JavaScript engines (like V8) provide additional optimizations or features that might affect performance, such as:

*   **Just-In-Time (JIT) compilation**: Some browsers can perform JIT compilation to optimize performance-critical code.
*   **Garbage collection**: The frequency and type of garbage collection can impact performance, especially in microbenchmarks.

**Alternatives**

If you're interested in exploring alternative approaches or libraries for similar benchmarks, consider the following:

*   **Benchmarking frameworks**: Libraries like Benchmark.js, Microbenchmark, or jsperf provide tools for writing and comparing benchmarks.
*   **Language-specific optimizations**: Depending on your target language, there may be built-in optimizations or features that can affect performance.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36

Browser/OS: Chrome 115 on Linux

View result in a separate tab

Test name	Executions per second
No function	221.7 Ops/sec
With normal function	192.3 Ops/sec
With arrow function	193.4 Ops/sec

Related benchmarks:

Effect of function calls in loops (version: 0)

Comparing performance of: No function vs With normal function vs With arrow function

Created: one year ago by: Guest

Jump to the latest result

No function

With normal function

With arrow function

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):