Benchmark: array vs Float64Array vs mixed array

Script Preparation code:

var a = [...Array(10000)].map(_ => Math.random());
var ma = [...a];
ma[5000] = 'string';
var ta = (new Float64Array(10000)).map(_ => Math.random());

Tests:

array reverse
a.reverse();
typedArray reverse
ta.reverse();
array i/o
for (let i = 0; i < 10000; ++i) a[i] = a[i] + 1;
typedArray i/o
for (let i = 0; i < 10000; ++i) ta[i] = ta[i] + 1;
mixed array reverse
ma.reverse();
mixed array i/o
for (let i = 0; i < 10000; ++i) ma[i] = ma[i] + 1;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array reverse
typedArray reverse
array i/o
typedArray i/o
mixed array reverse
mixed array i/o

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview**

The provided JSON represents a JavaScript microbenchmark on MeasureThat.net. The benchmark compares the performance of three types of arrays: regular arrays, Float64Arrays, and mixed arrays (which are regular arrays with a mix of numeric and non-numeric values). The benchmark also tests the performance of array reversal and element update operations.

**Benchmark Definition**

The benchmark is defined in two parts:

1. **Script Preparation Code**: This code sets up the test data by creating an array `a` with 10,000 random numbers, converting it to a mixed array `ma`, and then reversing it.
2. **Html Preparation Code**: There is no HTML preparation code provided.

**Individual Test Cases**

The benchmark consists of six individual test cases:

1. **Array Reverse**: Tests the performance of reversing a regular array using `a.reverse()`.
2. **Typed Array Reverse**: Tests the performance of reversing a Float64Array using `ta.reverse()`.
3. **Array I/O**: Tests the performance of updating 10,000 elements in a regular array using a loop.
4. **Typed Array I/O**: Tests the performance of updating 10,000 elements in a Float64Array using a loop.
5. **Mixed Array Reverse**: Tests the performance of reversing a mixed array using `ma.reverse()`.
6. **Mixed Array I/O**: Tests the performance of updating 10,000 elements in a mixed array using a loop.

**Options Compared**

The benchmark compares the performance of three types of arrays:

1. **Regular Arrays**: Test case 2 (Array Reverse) and test cases 3-6 (Array I/O).
2. **Float64Arrays**: Test case 5 (Mixed Array Reverse) and test case 4 (Typed Array I/O).
3. **Mixed Arrays**: Test case 5 (Mixed Array Reverse).

**Pros and Cons of Different Approaches**

1. **Regular Arrays**:
	* Pros: Widely supported, easy to use.
	* Cons: Slower than typed arrays for numerical computations.
2. **Float64Arrays**:
	* Pros: Optimized for numerical computations, faster than regular arrays.
	* Cons: Limited usage due to limited data types (single precision floating-point numbers).
3. **Mixed Arrays**:
	* Pros: Allows a mix of numeric and non-numeric values, can be useful for certain applications.
	* Cons: Slower than typed arrays due to the overhead of storing non-numeric values.

**Library**

The `Float64Array` is a built-in JavaScript array type that provides optimized performance for numerical computations. It is part of the Web APIs specification and is supported by most modern browsers.

**Special JS Feature or Syntax**

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

**Other Alternatives**

If you want to compare the performance of regular arrays, Float64Arrays, and mixed arrays, you can also use other alternatives such as:

* Typed Arrays: Similar to Float64Arrays but with additional data types (Int8Array, Uint8Array, etc.).
* ArrayBuffers: A low-level array type that provides direct access to raw binary data.
* Web Workers: A JavaScript API for running scripts in parallel, which can be used to compare the performance of different array types.

Keep in mind that these alternatives may have additional overhead or requirements compared to the built-in array types.

Latest run results:

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

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

Browser/OS: Chrome 104 on Windows

View result in a separate tab

Test name	Executions per second
array reverse	142482.4 Ops/sec
typedArray reverse	389066.1 Ops/sec
array i/o	696.8 Ops/sec
typedArray i/o	701.9 Ops/sec
mixed array reverse	88779.1 Ops/sec
mixed array i/o	650.8 Ops/sec

Related benchmarks:

array vs Float64Array vs mixed array (version: 0)

Comparing performance of: array reverse vs typedArray reverse vs array i/o vs typedArray i/o vs mixed array reverse vs mixed array i/o

Created: 2 years ago by: Guest

Jump to the latest result

array reverse

typedArray reverse

array i/o

typedArray i/o

mixed array reverse

mixed array i/o

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