Benchmark: Uint(8/16/32)Array.set performance compare

Script Preparation code:

var size = 5000;
var srcBuf = new ArrayBuffer(size);
var srcBufPtr8 = new Uint8Array(srcBuf);
var srcBufPtr16 = new Uint16Array(srcBuf);
var srcBufPtr32 = new Uint32Array(srcBuf);
var srcBufPtr64 = new BigUint64Array(srcBuf);
var destBuf = new ArrayBuffer(size);
var destBufPtr8 = new Uint8Array(destBuf);
var destBufPtr16 = new Uint16Array(destBuf);
var destBufPtr32 = new Uint32Array(destBuf);
var destBufPtr64 = new BigUint64Array(destBuf);

for (let i = 0; i < size; i++) {
	srcBufPtr8[i] = 100*Math.random();
}

Tests:

Uint8Array.set
destBufPtr8.set(srcBufPtr8);
Uint16Array.set
destBufPtr16.set(srcBufPtr16);
Uint32Array.set
destBufPtr32.set(srcBufPtr32);
BigUint64Array.set
destBufPtr64.set(srcBufPtr64);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Uint8Array.set
Uint16Array.set
Uint32Array.set
BigUint64Array.set

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and their pros/cons.

**Benchmark Overview**

The benchmark tests the performance of setting elements in different types of arrays: `Uint8Array`, `Uint16Array`, `Uint32Array`, and `BigUint64Array`. The test script prepares two buffers (`srcBuf` and `destBuf`) with a fixed size (5000), creates arrays from these buffers, populates the source array with random values, and then sets the elements of each target array to match the corresponding elements in the source array.

**Comparison Options**

The benchmark compares the performance of setting elements in different array types:

1. `Uint8Array.set`
2. `Uint16Array.set`
3. `Uint32Array.set`
4. `BigUint64Array.set`

**Pros and Cons**

Each approach has its strengths and weaknesses:

* **Native Arrays (`Uint8Array`, `Uint16Array`, `Uint32Array`)**:
	+ Pros: Native arrays are implemented in native code, which can lead to better performance compared to JavaScript arrays.
	+ Cons: They are limited to 64-bit systems and may not work as expected on 32-bit systems.
* **BigUint64Array**: A typed array implementation of Big Integers, optimized for high-performance operations.
	+ Pros: It's designed specifically for high-precision arithmetic operations, making it suitable for large-scale computations.
	+ Cons: It might be slower than native arrays due to the overhead of JavaScript's type system.

**Library Usage**

The test uses the `BigUint64Array` library, which is a part of the V8 JavaScript engine. The `BigUint64Array` constructor creates an array with 64-bit unsigned integers, optimized for high-performance operations.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntaxes being used in this benchmark.

**Other Alternatives**

If you wanted to run a similar benchmark but using different approaches, here are some alternatives:

1. **Native arrays with typed bindings**: Instead of using `BigUint64Array`, you could use native arrays with typed bindings (e.g., `Int8Array` or `Float32Array`) and manually cast the elements to 64-bit integers.
2. **Java or C++ libraries**: You could write a benchmark using Java or C++ libraries that provide high-performance arithmetic operations, such as the `BigInteger` class in Java or the `mpz_t` type in C++.
3. **WebAssembly**: You could compile your JavaScript code to WebAssembly (WASM) and run it on a WASM-enabled platform, which might offer better performance compared to traditional JavaScript execution.

Keep in mind that each of these alternatives would require significant modifications to the benchmark script and may not be as easy to implement or maintain as the original implementation.

Latest run results:

Run details: (Test run date: 10 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Uint8Array.set	4951525.5 Ops/sec
Uint16Array.set	4892249.0 Ops/sec
Uint32Array.set	4684644.5 Ops/sec
BigUint64Array.set	4995676.5 Ops/sec

Related benchmarks:

Uint(8/16/32)Array.set performance compare (version: 0)

Comparing performance of: Uint8Array.set vs Uint16Array.set vs Uint32Array.set vs BigUint64Array.set

Created: 3 years ago by: Guest

Jump to the latest result

Uint8Array.set

Uint16Array.set

Uint32Array.set

BigUint64Array.set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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