Benchmark: Testing array lookup vs storing it in a variable first

Script Preparation code:

var arr = new Array(100_000)
for (let i=0; i< 100_000; ++i) {
	arr[i] = {
    	x1: Math.random(),
      	x2: Math.random(),
      	x3: Math.random(),
      	x4: Math.random(),
      	x5: Math.random()
    }
}

Tests:

as i
for (let i=0; i< arr.length; ++i) { arr[i].x1 += 10 arr[i].x2 += 10 arr[i].x3 += 10 arr[i].x4 += 10 arr[i].x5 += 10 }
as vari
for (let i=0; i< arr.length; ++i) { let iter = arr[i] iter.x1 += 10 iter.x2 += 10 iter.x3 += 10 iter.x4 += 10 iter.x5 += 10 }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
as i
as vari

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Windows

View result in a separate tab

Test name	Executions per second
as i	32.6 Ops/sec
as vari	98.5 Ops/sec

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, the options being compared, and their pros and cons.

**Benchmark Definition**

The benchmark definition consists of two scripts that are used to test array lookup performance. The first script creates an array of 100,000 objects with random properties (`x1`, `x2`, `x3`, `x4`, and `x5`) and then uses a loop to increment each property by 10.

**Script Preparation Code**
```javascript
var arr = new Array(100_000)
for (let i=0; i< 100_000; ++i) {
  arr[i] = {
    x1: Math.random(),
    x2: Math.random(),
    x3: Math.random(),
    x4: Math.random(),
    x5: Math.random()
  }
}
```
This script creates an array of 100,000 objects with random properties.

**Html Preparation Code**

There is no HTML preparation code provided, which means that the benchmark does not require any specific HTML structure or content to run.

**Individual Test Cases**

The benchmark consists of two individual test cases:

1. **as i**
```javascript
for (let i=0; i< arr.length; ++i) {
  arr[i].x1 += 10
  arr[i].x2 += 10
  arr[i].x3 += 10
  arr[i].x4 += 10
  arr[i].x5 += 10
}
```
This script uses a direct index (`arr[i]`) to access each element in the array and increment its properties.

2. **as vari**
```javascript
for (let i=0; i< arr.length; ++i) {
  let iter = arr[i]
  iter.x1 += 10
  iter.x2 += 10
  iter.x3 += 10
  iter.x4 += 10
  iter.x5 += 10
}
```
This script creates a local variable (`iter`) for each element in the array and uses that variable to access its properties.

**What is being tested?**

The benchmark is testing the performance difference between two approaches:

1. **Direct index**: Accessing an array element using its direct index (`arr[i]`).
2. **Variable iteration**: Creating a local variable (`iter`) for each element in the array and using that variable to access its properties.

**Pros and Cons of each approach:**

**Direct Index (as i)**

Pros:

* Simple and straightforward
* May be faster due to reduced overhead of creating a local variable

Cons:

* Can lead to stack overflow errors if the array is very large, since each iteration creates a new scope on the call stack.
* May not be suitable for arrays with complex or nested data structures.

**Variable Iteration (as vari)**

Pros:

* Reduces risk of stack overflow errors, since each iteration only creates a local variable that lives in memory.
* Can be more efficient for arrays with complex or nested data structures.

Cons:

* Adds overhead due to the creation and management of local variables.
* May lead to slower performance due to increased function call overhead.

**Library usage**

There is no explicit library usage mentioned in the benchmark definition. However, it's possible that some internal libraries or engine optimizations are being used beneath the surface.

**Special JS feature/syntax**

The benchmark uses a few special JavaScript features:

* **let**: Used to declare the loop variables `i` and `iter`.
* **for...of**: Not explicitly used, but implied by the use of the `for...in` loop.
* **Math.random()**: Used to generate random values for the array elements.

**Alternatives**

There are alternative approaches that could be tested in this benchmark:

1. **Using a library or framework's optimized array operations**: Some libraries (e.g., Lodash) provide optimized array operations that might outperform the built-in JavaScript methods.
2. **Using SIMD instructions**: If the system supports SIMD (Single Instruction, Multiple Data) instructions, they could be used to accelerate the array iteration.
3. **Using a different data structure**: Alternatives like arrays of objects or even custom structures optimized for this specific use case could potentially outperform the built-in JavaScript arrays.

Keep in mind that the choice of approach often depends on the specific requirements and constraints of the application, as well as performance optimization goals.

Related benchmarks:

Testing array lookup vs storing it in a variable first (version: 0)

Comparing performance of: as i vs as vari

Created: one year ago by: Guest

Jump to the latest result

as i

as vari

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