Benchmark: ArrayBuffer Copy Benchmark (2)

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();
}

Tests:

DataView
for (let i; i < size; i++) { view.setUint8(i, data[i]); }
Uint8Array by byte
for (let i; i < size; i++) { byte[i] = data[i]; }
Uint8Array with set
byte.set(buf);
with Float64Array
(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: 4 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36

Browser/OS: Chrome 137 on Linux

View result in a separate tab

Test name	Executions per second
DataView	39534352.0 Ops/sec
Uint8Array by byte	44106648.0 Ops/sec
Uint8Array with set	14855970.0 Ops/sec
with Float64Array	359328.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The provided JSON represents a benchmark that tests the performance of different approaches to copy data from an `ArrayBuffer` to a typed array using the `DataView` API. The benchmark is designed to compare the execution times of four different methods:

1.  Using `DataView.setUint8()`
2.  Assigning bytes directly to a `Uint8Array` (`byte`)
3.  Using `Uint8Array.set()` with a typed array (`Float64Array`) as an argument
4.  Creating a new `Float64Array` instance from the `ArrayBuffer` and assigning it to another `Float64Array`

**Library Usage**

The benchmark uses the following libraries:

1.  `ArrayBuffer`: A binary-valued data structure that can be used to store large amounts of data.
2.  `DataView`: An interface for viewing a binary buffer as if it were an array or other typed arrays.
3.  `Uint8Array` and `Float64Array`: Typed arrays that provide a convenient way to work with raw binary data.

**Special JavaScript Features**

The benchmark utilizes some special JavaScript features:

1.  **let and const**: The use of `let` and `const` declarations is not present in this example, but it's worth noting that they are used extensively in modern JavaScript.
2.  **Arrow functions**: The `for` loop iterations are replaced with arrow functions (`i => { ... }`) which are not used in this benchmark.

**Pros and Cons**

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

1.  Using `DataView.setUint8()`:
    *   Pros: Simple, straightforward, and easy to read.
    *   Cons: May be slower due to repeated function calls.
2.  Assigning bytes directly to a `Uint8Array` (`byte`):
    *   Pros: Fast and efficient since it avoids repeated function calls.
    *   Cons: Can be less readable and may have potential memory issues if not used carefully.
3.  Using `Uint8Array.set()` with a typed array (`Float64Array`) as an argument:
    *   Pros: More concise than the previous approach, but still efficient.
    *   Cons: May require additional setup (e.g., creating a new typed array instance).
4.  Creating a new `Float64Array` instance from the `ArrayBuffer` and assigning it to another `Float64Array`:
    *   Pros: Most concise approach among all options, which can make it more efficient.
    *   Cons: Requires creating additional typed array instances.

**Other Alternatives**

If you're interested in exploring other alternatives for copying data between `ArrayBuffer` and typed arrays, here are a few approaches:

1.  **Buffer**: A built-in Node.js module that provides an efficient way to work with binary data.
2.  **TypedArray.from()`: Creates a new typed array from an iterable source (e.g., an array of integers).
3.  **WebAssembly**: An emerging technology for executing code in web browsers, which can provide improved performance and efficiency.

For more information on these alternatives or to learn about other microbenchmarking tools like MeasureThat.net, I recommend exploring the official documentation and examples provided by each library.

Related benchmarks:

ArrayBuffer Copy Benchmark (2) (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

DataView

Uint8Array by byte

Uint8Array with set

with Float64Array

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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