Benchmark: BigInt to BigEndian Bytes

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

Tests:

Loop ParseInt
bigIntToBigEndianBytesLoopParseInt(32149814014n)
Loop Constructor
bigIntToBigEndianBytesLoopConstructor(32149814014n)
DataView
bigIntToBigEndianBytesDataView(32149814014n)
Direct Constructor
bigIntToUint8ArrayDirectConstructor(32149814014n)
Direct ParseInt
bigIntToUint8ArrayDirectParseInt(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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0

Browser/OS: Firefox 134 on Windows

View result in a separate tab

Test name	Executions per second
Loop ParseInt	2849222.8 Ops/sec
Loop Constructor	1508101.4 Ops/sec
DataView	2983838.0 Ops/sec
Direct Constructor	5215165.5 Ops/sec
Direct ParseInt	2909482.8 Ops/sec

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

LLMs can make mistakes. Check important info.

In this benchmark, the goal is to evaluate the performance of different methods for converting a BigInt value to an array of bytes in big-endian format. The benchmark provides five different implementations, each employing distinct techniques for performing the conversion. Let's break down each approach:

### Benchmarking Methods:

1. **Loop ParseInt Method** (`bigIntToBigEndianBytesLoopParseInt`)
   - **Implementation Details**: Converts the BigInt to its hexadecimal string representation, pads it to ensure it has a length of at least 16 characters, creates a Uint8Array, and fills it by parsing the hex string into byte values using `parseInt`.
   - **Pros**: Clear and straightforward; uses built-in parsing functionality.
   - **Cons**: Potentially slower than methods that avoid the overhead of `parseInt`, especially when executed multiple times in loops.

2. **Loop Constructor Method** (`bigIntToBigEndianBytesLoopConstructor`)
   - **Implementation Details**: Similar to the ParseInt method, but rather than using `parseInt`, it uses the `Number` constructor to convert hex pairs to bytes.
   - **Pros**: The use of `Number` can be slightly more efficient than `parseInt`, as there's no string parsing involved.
   - **Cons**: Still maintains a loop structure, which may introduce overhead compared to direct byte manipulation methods.

3. **DataView Method** (`bigIntToBigEndianBytesDataView`)
   - **Implementation Details**: Leverages the `DataView` class, which provides a low-level interface for reading and writing buffer data, to set a BigInt directly into an ArrayBuffer and obtain the Uint8Array representation.
   - **Pros**: Typically more performant for binary data manipulations. Avoids string conversions, leading to faster execution.
   - **Cons**: Slightly more complex because it uses additional abstractions like `ArrayBuffer` and `DataView`.

4. **Direct Constructor Method** (`bigIntToUint8ArrayDirectConstructor`)
   - **Implementation Details**: Directly shifts bits on the BigInt to populate the resulting Uint8Array. Each byte position is filled using bitwise operations.
   - **Pros**: Highly efficient; eliminates any intermediate string representation or parsing steps, making it ideal for performance.
   - **Cons**: The bit manipulation can be less intuitive, making it harder to read and maintain for less experienced developers.

5. **Direct ParseInt Method** (`bigIntToUint8ArrayDirectParseInt`)
   - **Implementation Details**: Similar to the direct constructor method but uses `parseInt` to convert isolated portions into bytes.
   - **Pros**: Still efficient due to direct manipulation, but with the added simplicity of converting via `parseInt`.
   - **Cons**: May experience some overhead due to `parseInt`, which can make it slower than the pure bit manipulation approach.

### Performance Results:

Based on the results reported in the latest benchmark, the `Direct Constructor` method outperformed all other methods, registering over 5.2 million executions per second. In contrast, the `Loop Constructor` method was the slowest, with approximately 1.5 million executions per second.

### Considerations:

- **Maintainability vs. Performance**: While performance is crucial, the best approach may also depend on the context of usage. The more complex methods may yield speed benefits at the cost of code readability and maintainability. 
- **Use cases**: For applications heavily reliant on byte manipulation (e.g., cryptography, data serialization), the more efficient methods (like the Direct Constructor) are preferred. For simpler applications, the more readable methods may suffice.
- **Cross-browser compatibility**: All proposed methods work in modern browsers; however, developers should be aware of performance variations across different environments and JavaScript engines.

### Alternatives:

1. **Buffer (in Node.js)**: If working in a Node.js environment, using the `Buffer` class may provide another means of performing similar conversions, especially when working with binary data.
2. **Typed Arrays**: The standardized `TypedArray` interfaces can also be considered for different data handling needs, like managing larger binary data.
3. **Custom Libraries**: Libraries such as `big-integer` or `decimal.js` offer BigInt-like functionality and may include utility features for conversion, though they may not necessarily outperform these tailored implementations.

This benchmark effectively illustrates how various methodologies can be harnessed for converting BigInts to byte arrays, with trade-offs in complexity, performance, and clarity.

Related benchmarks:

BigInt to BigEndian Bytes (version: 3)

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

Created: 4 months ago by: Registered User

Jump to the latest result

Loop ParseInt

Loop Constructor

DataView

Direct Constructor

Direct ParseInt

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