Benchmark: Array vs TypedArray vs f32 write performance

Tests:

Array write
var array = new Array(100000).fill(0); for (let i=0; i<array.length; i++) { array[i] = array[i] + 1; }
TypedArray write
var typedArray = new Uint8Array(100000).fill(0); for (let i=0; i<typedArray.length; i++) { typedArray[i] = typedArray[i] + 1; }
f32
var typedArray = new Float32Array(100000).fill(0); for (let i=0; i<typedArray.length; i++) { typedArray[i] = typedArray[i] + 1; }
i32
var typedArray = new Uint32Array(100000).fill(0); for (let i=0; i<typedArray.length; i++) { typedArray[i] = typedArray[i] + 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array write
TypedArray write
f32
i32

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 33 minutes ago)

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

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
Array write	2614.1 Ops/sec
TypedArray write	8280.5 Ops/sec
f32	4532.1 Ops/sec
i32	4302.5 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 13 days ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark titled "Array vs TypedArray vs f32 write performance" compares the performance of different JavaScript array types during a simple write operation. The individual tests included in the benchmark assess the speed of writing values to different array implementations: a standard JavaScript `Array`, a `TypedArray` of type `Uint8Array`, a `TypedArray` of type `Float32Array`, and another `TypedArray` of type `Uint32Array`.

### Test Cases Explained

1. **Array Write:**
   - **Definition:** A standard JavaScript `Array` is created with 100,000 elements, all initialized to `0`. The benchmark iterates through the elements and increments each value by `1`.
   - **Pros:** 
     - Easy to use and widely known.
     - Flexible in terms of the types of data it can hold.
   - **Cons:** 
     - Generally slower performance due to the dynamic nature and additional overhead in handling various data types.

2. **TypedArray Write (Uint8Array):**
   - **Definition:** A `Uint8Array` (an 8-bit unsigned integer array) is similarly created with 100,000 elements initialized to `0`, and each element is incremented by `1`.
   - **Pros:**
     - More efficient in terms of memory usage and performance due to its fixed type and compact storage.
     - Optimized for handling raw binary data.
   - **Cons:** 
     - Limited to a specific numeric type (in this case, unsigned 8-bit integers).

3. **TypedArray Write (Float32Array):**
   - **Definition:** A `Float32Array` (32-bit floating-point number array) is also created and operated on in the same manner.
   - **Pros:**
     - Suitable for applications requiring floating-point calculations, often faster than native JavaScript arrays for numerical computing tasks.
   - **Cons:**
     - Like other typed arrays, it also has limited flexibility compared to standard arrays.

4. **TypedArray Write (Uint32Array):**
   - **Definition:** A `Uint32Array` (32-bit unsigned integer array) is tested using the same increment operation.
   - **Pros:**
     - Provides an efficient way to work with larger unsigned integers, with optimized memory layout.
   - **Cons:**
     - Again, restricted to a specific data type, which can be limiting in some applications.

### Performance Results

The most recent benchmark results show the number of executions per second for each test case:

- **TypedArray Write:** 7465.31 executions/sec
- **Float32Array Write:** 3817.64 executions/sec
- **Uint32Array Write:** 3562.63 executions/sec
- **Array Write:** 2471.25 executions/sec

From the results, it's clear that:

- **TypedArrays are significantly faster** than the standard `Array`. This speed advantage stems from their more efficient memory handling and fixed data type, which allows JavaScript engines to optimize performance better than with flexible arrays.
- Between the different `TypedArrays`, `Uint8Array` showed the best performance, likely due to its simple nature in terms of data structure, followed by `Float32Array` and `Uint32Array`.

### Alternative Considerations

Alternatives to using these different data structures depend on the specific application requirements.

1. **Standard Arrays** may be sufficient for most general use cases where size does not need to be optimal, and their flexibility is a benefit.
2. **Using Object arrays** or `Set` structures may be considered where specific operations (duplicates management, dynamic size, etc.) are required, though these may not be well-suited for raw performance tasks.
3. **Other TypedArrays,** such as `Int16Array`, `Float64Array`, etc., provide different ranges and precisions suited for particular applications but would follow similar performance patterns based on their fixed size and data types.

### Conclusion

In summary, this benchmark illustrates the performance advantages of using `TypedArrays` over standard JavaScript arrays when high-speed numerical operations are required. The trade-offs between flexibility and performance should be considered based on the specific needs of the application, with `TypedArrays` being the preferred choice for performance-critical tasks that involve large sets of numerical data.

Related benchmarks:

Array vs TypedArray vs f32 write performance (version: 1)

Comparing performance of: Array write vs TypedArray write vs f32 vs i32

Created: 13 days ago by: Guest

Jump to the latest result

Array write

TypedArray write

f32

i32

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 13 days ago):