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

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
array sort	1149.9 Ops/sec
typedArray sort	38877.2 Ops/sec
array i/o	121869.5 Ops/sec
typedArray i/o	228000.0 Ops/sec
typedArray i/o w convert back to array	3768.9 Ops/sec
create arrays	10974.8 Ops/sec
create typed arrays	2232.9 Ops/sec
create typed arrays in typed array	335.4 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months 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.

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: 9 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 2 months ago):