Benchmark: Array vs UInt8Array resizing

Script Preparation code:

c = new Uint8Array([255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255])

Tests:

Uint8Array
let stream = new Uint8Array() let a = 1000 while (a --> 0) { const buf = new Uint8Array(stream.length + c.length); buf.set(stream, 0); buf.set(c, stream.length); stream = buf; }
Array
let stream = [] let a = 1000 const push = Array.prototype.push; while (a --> 0) { push.apply(stream, c) new Uint8Array(stream) }

Historical Performance Data aggregated from 48 community runs

Desktop Results:

Chrome 26 runs

Uint8Array

179/s

Array

78/s

Fastest: Uint8Array (2.3x faster)

View exact numbers

✓ Uint8Array: 179 ops/sec
• Array: 78 ops/sec

Firefox 17 runs

Uint8Array

390/s

Array

76/s

Fastest: Uint8Array (5.1x faster)

View exact numbers

✓ Uint8Array: 390 ops/sec
• Array: 76 ops/sec

Mobile Results:

Chrome 5 runs

Uint8Array

100/s

Array

59/s

Fastest: Uint8Array (1.7x faster)

View exact numbers

✓ Uint8Array: 100 ops/sec
• Array: 59 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Uint8Array
Array

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 146 on Android

View result in a separate tab

Uint8Array

108/s

Array

64/s

View exact numbers

Test name	Executions per second
✓ Uint8Array	108 Ops/sec
Array	64 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 provided benchmark and its options.

**Benchmark Overview**

The benchmark is designed to compare the performance of two approaches for resizing arrays in JavaScript: `Uint8Array` and native JavaScript `Array`. The test aims to determine which approach is faster and more efficient.

**Script Preparation Code**

The script preparation code creates a constant array `c` containing 20 values (represented as `255`, which is the maximum value for an unsigned 8-bit integer).

**Benchmark Test Cases**

There are two individual test cases:

1. **Uint8Array**: This test case creates a new `Uint8Array` instance and resizes it by concatenating another `Uint8Array` instance (`stream`) with the constant array `c`. The resulting array is then reassigned to the original `stream` variable.
2. **Array**: This test case uses the `push()` method of native JavaScript arrays to add elements from the constant array `c` to an empty array `stream`. After each iteration, a new `Uint8Array` instance is created and assigned to `stream`.

**Library Used**

The `Uint8Array` class is used in the first test case. This is a built-in JavaScript class that provides a typed array for representing 8-bit unsigned integers.

**Special JS Feature/Syntax**

None are explicitly mentioned in the benchmark code, but it's worth noting that modern JavaScript engines have various optimizations and features that may impact performance, such as:

* Just-In-Time (JIT) compilation
* Garbage collection
* SIMD instructions

However, these effects are usually subtle and not directly related to the specific syntax or features used in this benchmark.

**Performance Considerations**

When comparing the two approaches:

* **Uint8Array**: This method uses a typed array, which can lead to faster performance due to:
	+ Reduced memory allocation and deallocation overhead.
	+ Improved cache locality.
	+ Faster iteration and indexing operations.
* **Array**: This method uses the `push()` method, which may incur additional overhead due to:
	+ Slower memory allocation and reallocation during each push operation.
	+ Increased garbage collection frequency.

However, modern JavaScript engines are optimized for native array operations, and the performance difference between these two approaches is likely to be small in practice.

**Other Alternatives**

There are other ways to resize arrays in JavaScript:

* Using `concat()` method: `stream = stream.concat(c)`
* Using `set()` method with a buffer-like object (e.g., `new ArrayBuffer()`)
* Using third-party libraries like `lodash` or `array-clone`

These alternatives may offer different performance characteristics, but they are not part of the benchmarked test cases.

Overall, the benchmark is designed to compare two specific approaches for resizing arrays in JavaScript and determine which one performs better. The results can help developers understand the trade-offs involved in using typed arrays versus native arrays, depending on their use case and performance requirements.

Array vs UInt8Array resizing (version: 2)

Comparing performance of: `Uint8Array vs Array`

Created: 5 years ago by: Registered User

Go to the latest result

Uint8Array

Array

Historical Performance Data aggregated from 48 community runs

Desktop Results:

Chrome 26 runs

Firefox 17 runs

Mobile Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Array vs UInt8Array resizing (version: 2)

Comparing performance of: Uint8Array vs Array

Created: 5 years ago by: Registered User

Go to the latest result

Uint8Array

Array

Historical Performance Data aggregated from 48 community runs

Desktop Results:

Chrome 26 runs

Firefox 17 runs

Mobile Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Uint8Array vs Array`