Benchmark: array vs float32array performance test

Script Preparation code:

function getRandomInt(max) {
    return Math.floor(Math.random() * max);
}

var a = [...new Array(10000)].map(_ => getRandomInt(1000000));
var ta = (new Float32Array(10000)).map(_ => getRandomInt(1000000));

Tests:

array sort
a.sort();
typedArray sort
ta.sort();
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; }
typedArray i/o w convert back to array
for (let i = 0; i < 10000; ++i) { ta[i] = ta[i] + 1; } let tb = Array.from(ta);
create arrays
const a = []; for (let i = 0; i < 10000; ++i) { a.push([i]); }
create typed arrays
const a = []; for (let i = 0; i < 10000; ++i) { a.push(new Float32Array([i])); }
create typed arrays in typed array
const a = new Float32Array(10000); for (let i = 0; i < 10000; ++i) { a[i] = new Float32Array([i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array sort
typedArray sort
array i/o
typedArray i/o
typedArray i/o w convert back to array
create arrays
create typed arrays
create typed arrays in typed array

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided JSON represents a benchmark test that compares the performance of different operations involving Arrays and TypedArrays (Float32Array) in JavaScript. The test is designed to measure the execution time of various tasks, such as sorting, iterating over arrays, creating arrays and typed arrays, and converting between them.

**Options compared:**

1. **Array vs Float32Array**: The primary comparison is between using regular Arrays (`a`) and TypedArrays (Float32Array) (`ta`).
2. **Sorting**: Two sorting methods are tested:
	* `Array.sort()`
	* `TypedArray.sort()`
3. **I/O Operations**:
	* Reading from an array: `for (let i = 0; i < 10000; ++i) { a[i] = a[i] + 1; }`
	* Writing to an array: `for (let i = 0; i < 10000; ++i) { ta[i] = ta[i] + 1; }`
	* Converting typed array back to array: `let tb = Array.from(ta);`
4. **Array Creation**:
	* Creating an empty array with `[]`: `const a = []`
	* Creating a typed array with Float32Array: `const ta = new Float32Array(10000)`
5. **Typed Arrays in Typed Array**: A special case where the typed array is created inside another typed array.

**Pros and Cons of each approach:**

1. **Array vs Float32Array**:
	* Pros:
		+ Familiarity and ease of use
		+ Better support for most JavaScript features and libraries
	* Cons:
		+ Generally slower due to dynamic typing and boxing/unboxing overhead
2. **Sorted operations**:
	* Both `Array.sort()` and `TypedArray.sort()` are optimized for their respective types, but `TypedArray` is likely to be faster in terms of execution time.
3. **I/O Operations**:
	* Reading from an array might not have significant performance differences between arrays and typed arrays, as most JavaScript engines will automatically optimize the operation.
	* Writing to an array or converting a typed array back to an array might show some differences due to potential overhead in boxing/unboxing and array operations.
4. **Array Creation**:
	* Creating empty arrays is generally faster than creating typed arrays.
5. **Typed Arrays in Typed Array**:
	* This special case is likely to be slower due to the added complexity of nested typed arrays.

**MeasureThat.net results:**

The provided execution times for each test show that:

1. `TypedArray` operations tend to be faster, especially when it comes to sorting and I/O operations.
2. Creating empty arrays is significantly faster than creating typed arrays.
3. The performance differences between array and typed array operations are more pronounced for specific tasks, like I/O operations and creation.

These results demonstrate the benefits of using TypedArrays (Float32Array) in JavaScript for performance-critical applications, particularly when working with large datasets or complex computations. However, it's essential to consider factors like code readability, maintainability, and compatibility when deciding between arrays and typed arrays.

Latest run results:

Run details: (Test run date: 6 days ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Linux

View result in a separate tab

Test name	Executions per second
array sort	9337.1 Ops/sec
typedArray sort	9307.5 Ops/sec
array i/o	94803.5 Ops/sec
typedArray i/o	124301.9 Ops/sec
typedArray i/o w convert back to array	13817.8 Ops/sec
create arrays	10950.2 Ops/sec
create typed arrays	1962.7 Ops/sec
create typed arrays in typed array	338.9 Ops/sec

Related benchmarks:

array vs float32array performance test (version: 4)

Comparing performance of: array sort vs typedArray sort vs array i/o vs typedArray i/o vs typedArray i/o w convert back to array vs create arrays vs create typed arrays vs create typed arrays in typed array

Created: 8 months ago by: Registered User

Jump to the latest result

array sort

typedArray sort

array i/o

typedArray i/o

typedArray i/o w convert back to array

create arrays

create typed arrays

create typed arrays in typed array

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