Benchmark: JS number to UInt8Array 64-bit little endian

Script Preparation code:

function numberToUint8Array64LE_DataView(num) {
    const buf = new ArrayBuffer(8)
    const view = new DataView(buf)
    view.setUint32(0, num, true)
    view.setUint32(4, num >>> 32, true)
    return new Uint8Array(buf)
}

function numberToUint8Array64LE_direct(num) {
    const result = new Uint8Array(8)
    result[0] = num & 0xff
    result[1] = (num >>> 8) & 0xff
    result[2] = (num >>> 16) & 0xff
    result[3] = (num >>> 24) & 0xff
    result[4] = (num >>> 32) & 0xff
    result[5] = (num >>> 40) & 0xff
    result[6] = (num >>> 48) & 0xff
    result[7] = (num >>> 56) & 0xff
    return result
}

function numberToUint8Array64LE_bigint(num) {
    const bigIntValue = BigInt.asUintN(64, BigInt(num));
    const buffer = new ArrayBuffer(8);
    const dataView = new DataView(buffer);
    dataView.setBigUint64(0, bigIntValue, true);
    return Uint8Array.from(buffer.slice(0, 8));
}

Tests:

Through DataView
numberToUint8Array64LE_DataView(0xababababab)
Direct
numberToUint8Array64LE_direct(0xababababab)
With BigInt
numberToUint8Array64LE_bigint(0xababababab)

Historical Performance Data aggregated from 21 community runs

Desktop Results:

Chrome 15 runs

Direct

9.4M/s

Through DataView

2.0M/s

With BigInt

877K/s

Fastest: Direct (10.7x faster)

View exact numbers

✓ Direct: 9,409,328 ops/sec
• Through DataView: 2,043,638 ops/sec
• With BigInt: 876,655 ops/sec

Firefox 6 runs

Direct

84.3M/s

Through DataView

2.7M/s

With BigInt

2.3M/s

Fastest: Direct (36.3x faster)

View exact numbers

✓ Direct: 84,273,912 ops/sec
• Through DataView: 2,706,742 ops/sec
• With BigInt: 2,321,485 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
Through DataView
Direct
With BigInt

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 134 on Linux

View result in a separate tab

Direct

23.8M/s

Through DataView

1.5M/s

With BigInt

614K/s

View exact numbers

Test name	Executions per second
✓ Direct	23,844,822 Ops/sec
Through DataView	1,498,059 Ops/sec
With BigInt	614,450 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 JSON**

The provided JSON represents a benchmark that tests the performance of converting a 64-bit little-endian signed integer (`num`) to a `Uint8Array` using three different approaches:

1. `numberToUint8Array64LE_DataView`: This approach uses the `DataView` API to create a buffer and manipulate its bytes directly.
2. `numberToUint8Array64LE_direct`: This approach manually extracts individual bytes from the input integer using bitwise operations.
3. `numberToUint8Array64LE_bigint`: This approach converts the input integer to a 64-bit `BigInt` value, then uses the `DataView` API to create a buffer and manipulate its bytes.

**Options Compared**

The three approaches differ in their use of low-level memory manipulation:

* `numberToUint8Array64LE_DataView` relies on the `DataView` API to manage the conversion process.
* `numberToUint8Array64LE_direct` uses bitwise operations to extract individual bytes from the input integer.
* `numberToUint8Array64LE_bigint` converts the input integer to a `BigInt` value, which is then converted to a buffer using the `DataView` API.

**Pros and Cons of Each Approach**

Here's a brief summary:

1. `numberToUint8Array64LE_DataView`:
	* Pros: Efficient use of memory, potentially faster due to optimized native code.
	* Cons: May have overhead from creating a `DataView` object and managing its bytes.
2. `numberToUint8Array64LE_direct`:
	* Pros: Simple, low-level implementation that avoids potential overhead from higher-level APIs.
	* Cons: More prone to errors due to manual byte extraction, potentially slower due to the use of bitwise operations.
3. `numberToUint8Array64LE_bigint`:
	* Pros: Convenient conversion from integers to `BigInt` values, potentially faster due to optimized native code for `BigInt`.
	* Cons: May incur additional overhead due to the creation and management of a `BigInt` object.

**Library**

In this benchmark, no libraries are explicitly mentioned. However, it's worth noting that some browsers, like Firefox, may use various internal APIs or libraries to optimize performance-critical code.

**Special JS Features**

The benchmark uses some special JavaScript features:

1. `BigInt`: Introduced in ECMAScript 2019, `BigInt` allows representing integers with arbitrary precision.
2. `DataView`: Introduced in ECMAScript 5, `DataView` provides a low-level API for manipulating buffers and bytes.

These features are used to create a buffer and manipulate its bytes using different approaches.

**Other Alternatives**

If you're looking for alternatives or optimizations for this benchmark, consider the following:

1. Use `TypedArray` instead of `Uint8Array`: If performance is critical, using a typed array like `Int32Array` or `Float64Array` might be faster than converting to a `Uint8Array`.
2. Explore native modules: Depending on your target platform and browser, using native modules like `libuv` (for Linux) or `nodejs` (for Windows and macOS) might provide better performance.
3. Profile and optimize specific code paths: MeasureThat.net provides detailed benchmark results; analyzing these outputs can help identify bottlenecks in your code.

Keep in mind that the best approach will depend on the specifics of your use case, target platform, and desired trade-offs between development time, maintenance overhead, and performance.

JS number to UInt8Array 64-bit little endian (version: 0)

Comparing performance of: `Through DataView vs Direct vs With BigInt`

Created: 3 years ago by: Guest

Go to the latest result

Through DataView

Direct

With BigInt

Historical Performance Data aggregated from 21 community runs

Desktop Results:

Chrome 15 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

JS number to UInt8Array 64-bit little endian (version: 0)

Comparing performance of: Through DataView vs Direct vs With BigInt

Created: 3 years ago by: Guest

Go to the latest result

Through DataView

Direct

With BigInt

Historical Performance Data aggregated from 21 community runs

Desktop Results:

Chrome 15 runs

Firefox 6 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: `Through DataView vs Direct vs With BigInt`