Benchmark: Fast Array lookup

Script Preparation code:

var f32arr = new Float32Array(1000000);
f32arr.forEach(function (a) {
  a = 123456;
});

var doublearr = [];

for (var i = 0; i < 1000; i++) {
 doublearr[i] = [];
 for (var j = 0; j < 1000; j++) {
   doublearr[i].push(123456);
 }
}

var doublearrwithobject = [];

for (var i = 0; i < 1000; i++) {
 doublearrwithobject[i] = [];
 for (var j = 0; j < 1000; j++) {
   doublearrwithobject[i].push({ value: 123456 });
 }
}

function lookupFloat32 () {
  var x = f32arr[722500];
}

function lookupDoubleArr () {
  var y = doublearr[850][850];
}

function lookupDoubleArrWithObject () {
  var z = doublearrwithobject[850][850].value;
}

Tests:

lookupFloat32
lookupFloat32();
lookupDoubleArr
lookupDoubleArr();
lookupDoubleArrWithObject
lookupDoubleArrWithObject();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lookupFloat32
lookupDoubleArr
lookupDoubleArrWithObject

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a platform for testing JavaScript performance, and the provided benchmark definition represents three microbenchmarks: `lookupFloat32`, `lookupDoubleArr`, and `lookupDoubleArrWithObject`. These tests aim to measure the performance of JavaScript engines when accessing array elements with different data types (float 32, double array, and object).

**Benchmark Definition Explanation**

The benchmark definition consists of a script preparation code, which initializes arrays and populates them with data. The main test functions (`lookupFloat32`, `lookupDoubleArr`, and `lookupDoubleArrWithObject`) access the elements of these arrays using different methods.

1. **`f32arr`**: A float 32 array with 1 million elements, where each element is assigned a value.
2. **`doublearr`**: A double array with 1000 inner arrays, each containing 1000 elements, all initialized to the same value (123456).
3. **`doublearrwithobject`**: A double array with 1000 inner arrays, each containing an object with a single property `value`, also initialized to the same value (123456).

The test functions simply access the elements of these arrays using their indices.

**Options Compared**

The benchmark compares three options:

1. **Direct array access (`f32arr[722500]`)**: Directly accessing the element at index 722500 in the `f32arr` array.
2. **Nested array access (`doublearr[850][850]`)**: Accessing the inner array at index 850 of the `doublearr` array, and then accessing the first element of that inner array (at index 0).
3. **Nested object access (`doublearrwithobject[850][850].value`)**: Accessing the property `value` of the object stored in the inner array at index 850 of the `doublearrwithobject` array.

**Pros and Cons**

* **Direct array access**:
	+ Pros: Fast, simple, and efficient.
	+ Cons: May not be as secure or safe than other approaches, especially when dealing with large arrays.
* **Nested array access**:
	+ Pros: Allows for more control over the data structure and can be more readable in some cases.
	+ Cons: May be slower due to the extra layer of indirection.
* **Nested object access**:
	+ Pros: Provides a way to work with complex data structures, but may introduce additional overhead.
	+ Cons: Can be less efficient than direct array or nested array access.

**Library and Special JS Features**

None of the benchmark tests use any external libraries. However, it's worth noting that some modern JavaScript engines (e.g., V8) have introduced new features like `let` and `const` declarations, which can affect performance in certain cases.

**Other Considerations**

When dealing with large arrays or complex data structures, other factors to consider include:

* **Cache locality**: Accessing elements near each other in an array can improve cache locality, leading to better performance.
* **Type coercion**: Some JavaScript engines may perform type coercion when accessing elements of different data types, which can impact performance.
* **Garbage collection**: The frequency and timing of garbage collection can affect the performance of JavaScript applications.

**Alternatives**

Other alternatives for testing array access performance might include:

* Testing with larger or smaller arrays to see how performance scales.
* Using different data structures, such as linked lists or trees.
* Adding additional complexity to the test cases, such as nested loops or conditionals.
* Using a profiling tool to analyze the execution time of the benchmark tests.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36

Browser/OS: Chrome 53 on Mac OS X 10.11.6

View result in a separate tab

Test name	Executions per second
lookupFloat32	5461284.0 Ops/sec
lookupDoubleArr	5597454.5 Ops/sec
lookupDoubleArrWithObject	5463460.5 Ops/sec

Related benchmarks:

Fast Array lookup (version: 0)

Comparing performance of: lookupFloat32 vs lookupDoubleArr vs lookupDoubleArrWithObject

Created: 8 years ago by: Guest

Jump to the latest result

lookupFloat32

lookupDoubleArr

lookupDoubleArrWithObject

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