Benchmark: inline vs function call vs function call x2 vs variable function

Script Preparation code:

function add(a, b){
	return a + b
}
function addRef(a, b){
	return add(a, b)
}
var variable_addRef = add

Tests:

inline
10+20
function call
add(10, 20)
function call x2
addRef(10, 20)
variable function
variable_addRef(10, 20)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
inline
function call
function call x2
variable function

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is designed to compare the performance of different approaches for calling a simple addition function:

1. Inline: The addition operation is written directly within the calling code, without referencing an external function.
2. Function call: A separate function `add` is defined to perform the addition, and its name is called from within the main code.
3. Function call x2: The same `add` function is called twice in a row, similar to the previous case.
4. Variable function: A variable named `variable_addRef` is assigned the address of the `add` function using the `var` keyword, and its name is called from within the main code.

**Options Compared**

The benchmark compares the performance of these four approaches:

* Inline vs. Function call: How does inline caching compare to a traditional function call?
* Function call x2 vs. Variable function: What's the difference in performance between calling the same function twice and using a variable with the function address?

**Pros and Cons**

1. **Inline**: Pros:
	* Can lead to better performance due to indirect function call overhead.
	* Less memory usage since no additional data is transferred.
Cons:
	* May not be compatible with all environments or browsers that don't support inline caching.
2. **Function Call**: Pros:
	* Wide compatibility across environments and browsers.
	* Easier maintenance and modification of the code.
Cons:
	* Additional overhead due to indirect function call, which can impact performance.
3. **Variable Function**: Pros:
	* Can lead to better performance since the variable's address is already cached in memory.
Cons:
	* May not be compatible with all environments or browsers that don't support variables with function addresses.
4. **Function Call x2**: This approach seems to be a variation of calling the same function twice, which would likely have similar performance characteristics as the original `function call` case.

**Library Usage**

None of the provided benchmark cases use any external libraries.

**Special JavaScript Features or Syntax**

The benchmark uses a few special features:

1. **Arrow functions**: Not explicitly used in this benchmark, but arrow functions are available.
2. **Template literals**: Not explicitly used in this benchmark, but template literals are available (e.g., `10+20` is equivalent to `"${10}+${20}"`).

**Other Alternatives**

If you'd like to test alternative approaches, consider the following:

1. Using a different function call convention (e.g., using pointers or references).
2. Implementing a custom caching mechanism for inline functions.
3. Comparing performance with other optimization techniques, such as loop unrolling or SIMD instructions.

Keep in mind that these alternatives might not be directly comparable to the original benchmark cases and may require significant changes to the codebase.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36

Browser/OS: Chrome 119 on Windows

View result in a separate tab

Test name	Executions per second
inline	807624896.0 Ops/sec
function call	14100558.0 Ops/sec
function call x2	7017114.0 Ops/sec
variable function	14066472.0 Ops/sec

Related benchmarks:

inline vs function call vs function call x2 vs variable function (version: 0)

Comparing performance of: inline vs function call vs function call x2 vs variable function

Created: one year ago by: Guest

Jump to the latest result

inline

function call

function call x2

variable function

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