Benchmark: array vs int32array vs map fixed

Script Preparation code:

var array = [];
var iarray = new Int32Array(100);
var map = new Map();
for (let i = 0; i < 100; i++) {
    array.push(i);
    iarray[i] = i;
    map.set(i, i);
}

AخA
 
var array = [];var iarray = new Int32Array(100);var map = new Map();for (let i = 0; i < 100; i++) {    array.push(i);    iarray[i] = i;    map.set(i, i);}

Tests:

array

for(let i = 0; i < 100; i++){
  array[i] = array[i] + 1;
  if(i == 50) break;
}

 
for(let i = 0; i < 100; i++){  array[i] = array[i] + 1;  if(i == 50) break;}

int32array

for(let i = 0; i < 100; i++){
  iarray[i] = iarray[i] + 1;
  if(i == 50) break;
}

 
for(let i = 0; i < 100; i++){  iarray[i] = iarray[i] + 1;  if(i == 50) break;}

map

for(let i = 0; i < 100; i++){
  map.set(i, map.get(i) + 1);
  if(i == 50) break;
}

 
for(let i = 0; i < 100; i++){  map.set(i, map.get(i) + 1);  if(i == 50) break;}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
array
int32array
map

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 18_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 18 on iOS 18.1.1

View result in a separate tab

Test name	Executions per second
array	32544928.0 Ops/sec
int32array	47834236.0 Ops/sec
map	3625482.8 Ops/sec

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

Benchmark Overview

The provided JSON represents a JavaScript microbenchmark test case on the MeasureThat.net website. The benchmark compares the performance of three data structures: arrays, Int32Array objects, and Map instances.

Tested Options and Their Pros/Cons

Arrays
- Approach: Using a traditional JavaScript array with push and indexing operations.
- Pros:
  - Simple to implement and understand.
  - Wide support across browsers and platforms.
- Cons:
  - Slow performance due to the overhead of dynamic array resizing and searching.
Int32Array Objects
- Approach: Using a typed array with uint8ClampedValue and indexing operations.
- Pros:
  - Faster performance compared to traditional arrays due to optimized memory management.
  - Better cache locality, reducing memory access latency.
- Cons:
  - Limited support across browsers and platforms (e.g., older versions of Chrome).
Map Instances
- Approach: Using a Map object with set and get operations.
- Pros:
  - Fast performance due to optimized hash table management.
  - Good cache locality, reducing memory access latency.
- Cons:
  - Higher overhead compared to traditional arrays or Int32Array objects.

Library Usage

The test case uses the following libraries:

Map: The built-in JavaScript Map object is used for comparison.
Int32Array: The typed array API is used to create an Int32Array object for comparison.

Both of these libraries are part of the JavaScript Standard Library and have good support across browsers and platforms.

Special JS Features

There are no special JavaScript features or syntax used in this benchmark.

Other Considerations

When choosing a data structure for performance-critical code, consider the trade-offs between simplicity, support, and performance. Int32Array objects can offer better performance than traditional arrays, but their limited browser support may be a concern. Maps can provide fast performance, but they might incur higher overhead due to hash table management.

Alternative Data Structures

Other data structures that could be compared in this benchmark include:

Typed Arrays: Besides Int32Array, other typed arrays like Uint8Array, Float32Array, and BigInt64Array could be used.
Slices or Subarrays: Some JavaScript engines allow creating slices or subarrays of existing arrays, which could provide similar performance to Int32Array objects.
Vector Libraries: External libraries like Mathjs or TensorFlow.js could be used for numerical computations, offering optimized performance and additional features.
Native Array Buffers: Some browsers support native array buffers, which can provide low-level memory management and optimization opportunities.

Keep in mind that the choice of data structure ultimately depends on the specific use case and requirements of the application.

LLMs can make mistakes. Check important info.

**Benchmark Overview**

**Tested Options and Their Pros/Cons**

1. **Arrays**
	* Approach: Using a traditional JavaScript array with `push` and indexing operations.
	* Pros:
		+ Simple to implement and understand.
		+ Wide support across browsers and platforms.
	* Cons:
		+ Slow performance due to the overhead of dynamic array resizing and searching.
2. **Int32Array Objects**
	* Approach: Using a typed array with `uint8ClampedValue` and indexing operations.
	* Pros:
		+ Faster performance compared to traditional arrays due to optimized memory management.
		+ Better cache locality, reducing memory access latency.
	* Cons:
		+ Limited support across browsers and platforms (e.g., older versions of Chrome).
3. **Map Instances**
	* Approach: Using a Map object with `set` and `get` operations.
	* Pros:
		+ Fast performance due to optimized hash table management.
		+ Good cache locality, reducing memory access latency.
	* Cons:
		+ Higher overhead compared to traditional arrays or Int32Array objects.

**Library Usage**

The test case uses the following libraries:

1. **Map**: The built-in JavaScript Map object is used for comparison.
2. **Int32Array**: The typed array API is used to create an Int32Array object for comparison.

Both of these libraries are part of the JavaScript Standard Library and have good support across browsers and platforms.

**Special JS Features**

There are no special JavaScript features or syntax used in this benchmark.

**Other Considerations**

**Alternative Data Structures**

Other data structures that could be compared in this benchmark include:

1. **Typed Arrays**: Besides Int32Array, other typed arrays like Uint8Array, Float32Array, and BigInt64Array could be used.
2. **Slices or Subarrays**: Some JavaScript engines allow creating slices or subarrays of existing arrays, which could provide similar performance to Int32Array objects.
3. **Vector Libraries**: External libraries like Mathjs or TensorFlow.js could be used for numerical computations, offering optimized performance and additional features.
4. **Native Array Buffers**: Some browsers support native array buffers, which can provide low-level memory management and optimization opportunities.

Keep in mind that the choice of data structure ultimately depends on the specific use case and requirements of the application.

Related benchmarks:

array vs int32array vs map fixed (version: 0)

Comparing performance of: array vs int32array vs map

Created: 2 years ago by: Registered User

Jump to the latest result