Benchmark: BigInt to BigEndian Bytes - with AB

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

function bigIntToBigEndianBytesLoopParseInt(value) {
    const hex = value.toString(16).padStart(16, '0');
    const bytes = new Uint8Array(8);
    for (let i = 0; i < 8; i++) {
        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
    }
    return bytes;
}

function bigIntToBigEndianBytesLoopConstructor(value) {
    const hex = value.toString(16).padStart(16, '0');
    const bytes = new Uint8Array(8);
    for (let i = 0; i < 8; i++) {
        bytes[i] = Number(hex.slice(i * 2, i * 2 + 2), 16);
    }
    return bytes;
}

function bigIntToBigEndianBytesDataView(value) {
    const buf = new ArrayBuffer(8);
    const view = new DataView(buf);

    view.setBigUint64(0, value);
    return new Uint8Array(buf);
}

function bigIntToUint8ArrayDirectConstructor(value) {
    const result = new Uint8Array(8);
    result[7] = Number(value & 0xffn);
    result[6] = Number((value >> 8n) & 0xffn);
    result[5] = Number((value >> 16n) & 0xffn);
    result[4] = Number((value >> 24n) & 0xffn );
    result[3] = Number((value >> 32n) & 0xffn);
    result[2] = Number((value >> 40n) & 0xffn);
    result[1] = Number((value >> 48n) & 0xffn);
    result[0] = Number((value >> 56n) & 0xffn);
    return result;
}

function bigIntToUint8ArrayDirectParseInt(value) {
    const result = new Uint8Array(8);
    result[7] = parseInt(value & 0xffn);
    result[6] = parseInt((value >> 8n) & 0xffn);
    result[5] = parseInt((value >> 16n) & 0xffn);
    result[4] = parseInt((value >> 24n) & 0xffn );
    result[3] = parseInt((value >> 32n) & 0xffn);
    result[2] = parseInt((value >> 40n) & 0xffn);
    result[1] = parseInt((value >> 48n) & 0xffn);
    result[0] = parseInt((value >> 56n) & 0xffn);
    return result;
}
function bigIntToUint8ArrayThroughBigIntAB(value) {
  return new Uint8Array(new BigInt64Array([value]).buffer);
}

Tests:

Loop ParseInt
bigIntToBigEndianBytesLoopParseInt(32149814014n)
Loop Constructor
bigIntToBigEndianBytesLoopConstructor(32149814014n)
DataView
bigIntToBigEndianBytesDataView(32149814014n)
Direct Constructor
bigIntToUint8ArrayDirectConstructor(32149814014n)
Direct ParseInt
bigIntToUint8ArrayDirectParseInt(32149814014n)
Through BigIntArrayBuffer
bigIntToUint8ArrayThroughBigIntAB(32149814014n)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Loop ParseInt
Loop Constructor
DataView
Direct Constructor
Direct ParseInt
Through BigIntArrayBuffer

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0

Browser/OS: Firefox 133 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Loop ParseInt	3806213.5 Ops/sec
Loop Constructor	2937407.0 Ops/sec
DataView	4264873.5 Ops/sec
Direct Constructor	7410491.5 Ops/sec
Direct ParseInt	3957166.8 Ops/sec
Through BigIntArrayBuffer	3968941.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 4 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON focuses on converting a `BigInt` value to an array of bytes in big-endian order using several different approaches in JavaScript. Each test case uses a specific method to perform this conversion, enabling comparison of their performance.

### Approaches Compared

1. **Loop with `parseInt`** (`bigIntToBigEndianBytesLoopParseInt`)
   - **Implementation**: Converts the `BigInt` to a hexadecimal string, then iterates through each byte, using `parseInt` to convert each pair of hex digits to a byte.
   - **Pros**: Fairly straightforward to understand and implement.
   - **Cons**: `parseInt` adds overhead that may slow down the operation due to its additional function calls.

2. **Loop with Constructor** (`bigIntToBigEndianBytesLoopConstructor`)
   - **Implementation**: Similar to the previous method but uses the `Number` constructor directly instead of `parseInt` for converting hex pairs to bytes.
   - **Pros**: Slightly more efficient than using `parseInt`, as it skips the string parsing overhead.
   - **Cons**: Still involves iterating through the string representation, which might not be the most efficient way.

3. **Using `DataView`** (`bigIntToBigEndianBytesDataView`)
   - **Implementation**: Creates an `ArrayBuffer` and uses a `DataView` to set the `BigInt` directly in binary format.
   - **Pros**: Fast and efficient, directly manipulates binary data without the need for string conversions.
   - **Cons**: Slightly more complex, as it involves understanding and using the `ArrayBuffer` and `DataView` APIs.

4. **Direct Constructor with Bitwise Operations** (`bigIntToUint8ArrayDirectConstructor`)
   - **Implementation**: Uses bitwise operations to extract bytes directly from the `BigInt` value, returning them in an `Uint8Array`.
   - **Pros**: Very fast since it avoids string conversions and directly computes byte values through bitwise manipulation.
   - **Cons**: Requires thorough understanding of bitwise operations, which might not be as intuitive.

5. **Direct ParseInt with Bitwise Operations** (`bigIntToUint8ArrayDirectParseInt`)
   - **Implementation**: Similar to the previous method, but uses `parseInt` to individually extract bytes.
   - **Pros**: Easier to read for some developers due to use of `parseInt`.
   - **Cons**: Slower than directly using bitwise manipulation because of the overhead of `parseInt`.

6. **Through `BigInt64Array`** (`bigIntToUint8ArrayThroughBigIntAB`)
   - **Implementation**: Stores the `BigInt` in a `BigInt64Array` and converts the underlying buffer to an `Uint8Array`.
   - **Pros**: Efficient and concise; directly leverages typed arrays.
   - **Cons**: The use of a typed array introduces some additional overhead, though typically minimal.

### Performance Results Summary

The reported execution speeds (in executions per second) for each method indicate their respective performance:

- **Direct Constructor**: ~7,410,491.5 executions/second (fastest)
- **DataView**: ~4,264,873.5 executions/second
- **Through BigIntArrayBuffer**: ~3,968,941.0 executions/second
- **Direct ParseInt**: ~3,957,166.75 executions/second
- **Loop ParseInt**: ~3,806,213.5 executions/second
- **Loop Constructor**: ~2,937,407.0 executions/second (slowest)

### Considerations and Alternatives

While the benchmark primarily focuses on these JavaScript approaches, alternative methods can include:

- **WebAssembly (Wasm)**: If performance is critical, converting this logic to Wasm may result in better performance due to lower-level execution.
- **Native Code**: Implementing this logic in a language like C/C++ and calling it from JavaScript could also improve performance significantly due to direct access to memory and optimized native execution.
- **Libraries such as `bigint.js` or `bignumber.js`**: These libraries provide abstractions for handling large integers and may offer different performance characteristics.

In conclusion, the benchmark provides valuable insights into how different methods of converting `BigInt` to byte arrays perform in JavaScript, helping developers choose the most appropriate solution based on performance needs and code complexity.

Related benchmarks:

BigInt to BigEndian Bytes - with AB (version: 1)

Comparing performance of: Loop ParseInt vs Loop Constructor vs DataView vs Direct Constructor vs Direct ParseInt vs Through BigIntArrayBuffer

Created: 4 months ago by: Guest

Jump to the latest result

Loop ParseInt

Loop Constructor

DataView

Direct Constructor

Direct ParseInt

Through BigIntArrayBuffer

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 4 months ago):