Benchmark: Function call vs array access

Script Preparation code:

var memory = new ArrayBuffer(1024 * 1024);
var memoryF32 = new Float32Array(memory);
var memoryU32 = new Uint32Array(memory);

Tests:

Array access
for (let i = 0; i < 1024; ++i) { memoryF32[i] = Math.random(); } for (let i = 1; i < 1024; ++i) { memoryF32[i-1] = memoryF32[i] * 2; } for (let i = 1; i < 1024; ++i) { memoryU32[i + 1024] = memoryF32[i] > 0.5 ? 1 : 0; }
Function access
const readF32 = (idx) => memoryF32[idx]; const writeF32 = (idx, value) => memoryF32[idx] = value; const writeU32 = (idx, value) => memoryU32[idx+1024] = value; for (let i = 0; i < 1024; ++i) { writeF32(i, Math.random()); } for (let i = 1; i < 1024; ++i) { writeF32(i-1, readF32(i) * 2); } for (let i = 1; i < 1024; ++i) { writeU32(i, memoryF32[i] > 0.5 ? 1 : 0); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array access
Function access

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 91 on Windows

View result in a separate tab

Test name	Executions per second
Array access	2106.1 Ops/sec
Function access	2147.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its options.

**Benchmark Overview**

The benchmark compares two approaches: function call vs array access. The test case creates an array of 1024 elements, fills it with random values, and then performs operations on it using both methods.

**Options Compared**

1. **Function Call**: This approach uses functions to read and write values in the array. The functions `readF32` and `writeF32` take an index as an argument, while `writeU32` takes an additional value.
2. **Array Access**: This approach directly accesses the array elements using indexing.

**Pros and Cons of Each Approach**

**Function Call**

Pros:

* Can be more flexible and efficient for complex operations
* Can reduce memory allocation and deallocation overhead

Cons:

* May incur higher function call overhead compared to direct array access
* Requires additional memory for function arguments (in this case, `value`)

**Array Access**

Pros:

* Directly accesses the data without function call overhead
* Reduces memory allocation and deallocation overhead

Cons:

* Can be slower due to indexing operations
* May require more complex arithmetic operations (e.g., multiplying by 2 in this test case)

**Library Used**

None. This benchmark only uses built-in JavaScript functionality, not any external libraries.

**Special JS Features or Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax beyond standard array and function operations.

**Other Considerations**

The benchmark's results are influenced by various factors, such as:

* **Memory Allocation**: The test case allocates a large buffer to simulate an array of 1024 elements. The performance difference between the two approaches may vary depending on the specific memory allocation strategy.
* **Loop Unrolling**: Some modern JavaScript engines (e.g., V8 in Chrome) perform loop unrolling, which can affect the performance of both approaches. However, this is not explicitly tested in this benchmark.
* **Cache Effects**: The test case accesses elements in a contiguous block (i.e., `memoryF32[i]` and `memoryF32[i-1]`). Cache effects may play a role in determining the performance difference between the two approaches.

**Alternatives**

If you're interested in exploring alternative approaches or testing different scenarios, consider the following:

* **SIMD Instructions**: Modern CPUs often support SIMD (Single Instruction, Multiple Data) instructions, which can accelerate array operations. You could test the performance of a SIMD-enabled JavaScript library or framework.
* **Native Code Generation**: Some JavaScript engines, like V8, generate native machine code for critical paths. Testing the performance of these generated codes might reveal interesting performance differences.
* **Other Array Operations**: You could modify the benchmark to explore other array operations, such as searching, sorting, or reduction functions.

Feel free to ask if you'd like me to elaborate on any of these points!

Related benchmarks:

Function call vs array access (version: 0)

Comparing performance of: Array access vs Function access

Created: 3 years ago by: Registered User

Jump to the latest result

Array access

Function access

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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