Benchmark: Array vs Uint32Array (TypedArray) (part 2)

Array vs Uint32Array (TypedArray) (part 2) (version: 1)

array.reverse(), array.toSorted(), array.sort(), array[i]

Comparing performance of: Array.reverse() vs TypedArray.reverse() vs Array.toSorted() vs TypedArray.toSorted() vs Array.sort() vs TypedArray.sort() vs Array[i] (sequential) vs TypedArray[i] (sequential) vs Array[i] (random) vs TypedArray[i] (random)

Created: 2 years ago by: Registered User

Jump to the latest result

Script Preparation code:

var arr32 = new Uint32Array(16384)
crypto.getRandomValues(arr32)
var array = Array.from(arr32)

Tests:

Array.reverse()
array.reverse()
TypedArray.reverse()
arr32.reverse()
Array.toSorted()
array.toSorted()
TypedArray.toSorted()
arr32.toSorted()
Array.sort()
array.sort(); array.reverse(); // fast "un-sort"
TypedArray.sort()
arr32.sort(); arr32.reverse(); // fast "un-sort"
Array[i] (sequential)
for (let i = 0; i < 16384; i++) array[i]++
TypedArray[i] (sequential)
for (let i = 0; i < 16384; i++) arr32[i]++
Array[i] (random)
for(let i = 0; i < 16384; i++) array[i * 11003 % 16384] = array[i * 12011 % 16384] + array[i * 13001 % 16384]
TypedArray[i] (random)
for(let i = 0; i < 16384; i++) arr32[i * 11003 % 16384] = arr32[i * 12011 % 16384] + arr32[i * 13001 % 16384]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.reverse()
TypedArray.reverse()
Array.toSorted()
TypedArray.toSorted()
Array.sort()
TypedArray.sort()
Array[i] (sequential)
TypedArray[i] (sequential)
Array[i] (random)
TypedArray[i] (random)

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Mobile Safari 18 on iOS 18.1

View result in a separate tab

Test name	Executions per second
Array.reverse()	155784.2 Ops/sec
TypedArray.reverse()	459471.6 Ops/sec
Array.toSorted()	572.8 Ops/sec
TypedArray.toSorted()	2422.8 Ops/sec
Array.sort()	737.1 Ops/sec
TypedArray.sort()	56303.6 Ops/sec
Array[i] (sequential)	158691.8 Ops/sec
TypedArray[i] (sequential)	127760.3 Ops/sec
Array[i] (random)	29545.0 Ops/sec
TypedArray[i] (random)	23856.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its results.

**Benchmark Definition**

The benchmark measures the performance of three types of array operations:

1. `array.reverse()`
2. `arr32.reverse()` (using TypedArray)
3. `array.sort()` followed by `array.reverse()` (a sequence of operations)

Additionally, two other tests are included:

1. Accessing elements in an array sequentially (`array[i]`)
2. Accessing elements in a TypedArray sequentially (`arr32[i]`)
3. Accessing elements in an array randomly (`array[i]` with random indices)
4. Accessing elements in a TypedArray randomly (`arr32[i]` with random indices)

**Options Compared**

The benchmark compares the performance of different approaches:

* Using an ordinary JavaScript `array`
* Using a `TypedArray` (specifically, `Uint32Array`)
* A sequence of operations: sorting and then reversing the array

**Pros and Cons of Different Approaches**

1. **Ordinary JavaScript `array`**:
	* Pros: Easy to use, no need for explicit type declaration.
	* Cons: May be slower due to the overhead of dynamic typing and potential memory allocation.
2. **TypedArray (`Uint32Array`)**:
	* Pros: Provides a dedicated array type optimized for performance, especially when dealing with large arrays of integers or floats.
	* Cons: Requires explicit type declaration, may require more code to set up.
3. **Sequence of operations (sorting and then reversing)**:
	* Pros: Can be faster than reversing an array in place due to the opportunity to reuse existing memory allocations.
	* Cons: May not take advantage of modern CPU optimizations that can reverse arrays efficiently.

**Results**

The benchmark results show varying performance across different tests. The `TypedArray` approach generally performs better, especially for sequential access and random access. However, the sequence of operations test shows mixed results, with some tests benefiting from this approach while others are slower.

**Notable Insights**

* Reversing an array in place is not always the fastest way to reverse an array.
* Using a TypedArray can provide significant performance gains, especially for large arrays or arrays that contain integers or floats.
* The sequence of operations test highlights the importance of optimizing individual steps in a computational pipeline.

Overall, this benchmark provides valuable insights into the performance characteristics of different approaches when working with arrays in JavaScript.

Related benchmarks: