Benchmark: copy ArrayBuffer: DataView vs Uint8Array.set vs Float64Array.set vs by bytes v2

Script Preparation code:

var size = 0xFFFF;
var buf = new ArrayBuffer(size);
var view = new DataView(buf);
var byte = new Uint8Array(buf);

var data = new Uint8Array(size);

for (let i = 0; i < size; i++) {
	data[i] = 100*Math.random();
}

window._data = data;
window._buf = buf;

Tests:

DataView
data[Date.now()%data.length] = 43; for (let i; i < size; i++) { view.setUint8(i, data[i]); }
Uint8Array by byte
data[Date.now()%data.length] = 43; for (let i; i < size; i++) { byte[i] = data[i]; }
Uint8Array with set
data[Date.now()%data.length] = 43; byte.set(data);
with Float64Array
data[Date.now()%data.length] = 43; (new Float64Array(buf, 0, size/8)) .set(new Float64Array(data.buffer, 0, size/8));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
DataView
Uint8Array by byte
Uint8Array with set
with Float64Array

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Opera 79 on Windows

View result in a separate tab

Test name	Executions per second
DataView	1840064.5 Ops/sec
Uint8Array by byte	1816404.4 Ops/sec
Uint8Array with set	360648.1 Ops/sec
with Float64Array	281877.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, the different approaches compared, their pros and cons, and other considerations.

**Benchmark Overview**

The benchmark measures the performance of four different methods for copying data from an ArrayBuffer to a Uint8Array:

1. `DataView`
2. `Uint8Array` by byte (direct assignment)
3. `Uint8Array` with `set()` method
4. Using a `Float64Array` intermediate buffer

**Test Case Analysis**

Here's a brief explanation of each test case:

* **"DataView"`: This test case uses the `DataView` API to access the ArrayBuffer and sets its values using the `setUint8()` method.
* **"Uint8Array by byte"`: This test case directly assigns the values from the ArrayBuffer to a new Uint8Array using the assignment operator (`=`).
* **"Uint8Array with set()"**: This test case uses the `set()` method of the Uint8Array to assign its values.
* **"with Float64Array"`: This test case creates a new `Float64Array` buffer from the ArrayBuffer and sets its values using the `set()` method.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **"DataView"`:
	+ Pros: Efficient use of memory, can access data in arbitrary byte offsets.
	+ Cons: May require additional setup and handling for certain use cases.
* **"Uint8Array by byte"`:
	+ Pros: Simple and straightforward, easy to understand.
	+ Cons: Inefficient use of memory (copying data), may lead to slower performance due to overhead.
* **"Uint8Array with set()"**:
	+ Pros: Convenient and easy to use, doesn't require manual copying of data.
	+ Cons: May be slower than direct assignment due to the `set()` method's overhead.
* **"with Float64Array"`:
	+ Pros: Can take advantage of SIMD instructions for improved performance.
	+ Cons: Requires additional memory allocation and handling for a new buffer.

**Other Considerations**

* **Memory Allocation**: Each test case requires allocating memory for the ArrayBuffer, Uint8Array, and any intermediate buffers (Float64Array). The `DataView` approach can avoid some memory allocations since it uses existing memory.
* **Alignment Requirements**: Some browsers may require specific alignment requirements for certain types of data (e.g., Float64Arrays).
* **Cache Locality**: The order of the test cases may affect cache locality, which could impact performance. In this case, the first few test cases seem to access consecutive elements, which might be beneficial.

**Alternative Approaches**

If not using `DataView`, other alternatives for copying data from an ArrayBuffer to a Uint8Array include:

* **`new Uint8Array(buf.buffer, 0, size)`**: This approach creates a new Uint8Array and copies the data from the ArrayBuffer's buffer.
* **`new Float64Array(buf, 0, size / 8)`**: This approach creates a new Float64Array and copies the data from the ArrayBuffer's buffer.

Keep in mind that these alternatives might have different performance characteristics compared to the original test cases.

Related benchmarks:

copy ArrayBuffer: DataView vs Uint8Array.set vs Float64Array.set vs by bytes v2 (version: 0)

Comparing performance of: DataView vs Uint8Array by byte vs Uint8Array with set vs with Float64Array

Created: 3 years ago by: Guest

Jump to the latest result

DataView

Uint8Array by byte

Uint8Array with set

with Float64Array

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