Benchmark: BigInt to BigEndian Bytes (extended by trincot, v2)

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;
}

// Added by trincot: first split BigInt into two numbers (32 bit), then work with those only
function bigIntToUint8ArrayDirectConstructor2(value) {
    const result = new Uint8Array(8);
    const low = Number(value & 0xffffffffn);
    const high = Number(value >> 32n); 
    result[7] = low & 0xff;
    result[6] = (low >>> 8) & 0xff;
    result[5] = (low >>> 16) & 0xff;
    result[4] = low >>> 24;
    result[3] = high & 0xff;
    result[2] = (high >>> 8) & 0xff;
    result[1] = (high >>> 16) & 0xff;
    result[0] = high >>> 24;
    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)
Direct Constructor with split
bigIntToUint8ArrayDirectConstructor2(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
Direct Constructor with split

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_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Loop ParseInt	5354088.5 Ops/sec
Loop Constructor	5543766.0 Ops/sec
DataView	4770309.5 Ops/sec
Direct Constructor	15368719.0 Ops/sec
Direct ParseInt	6233455.0 Ops/sec
Direct Constructor with split	29224200.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark focuses on converting BigInt values to byte arrays in Big Endian format using various JavaScript approaches. Each approach consists of different techniques for achieving this conversion, and the benchmark seeks to determine which method performs the conversion most efficiently.

### Approaches Compared

1. **Loop with `parseInt`** (`bigIntToBigEndianBytesLoopParseInt`)
   - **Description**: This approach converts the BigInt to a hexadecimal string, slices it into pairs of hexadecimal digits, and then uses `parseInt` to get the byte values.
   - **Pros**: Simple and straightforward to understand.
   - **Cons**: The usage of `parseInt` inside a loop can lead to performance penalties, particularly when executed many times.

2. **Loop with `Number` Constructor** (`bigIntToBigEndianBytesLoopConstructor`)
   - **Description**: Similar to the first approach, this uses `Number` to convert the byte pairs instead of `parseInt`.
   - **Pros**: Generally faster than `parseInt` because it bypasses base conversion.
   - **Cons**: Still involves loop overhead, which may not be optimal for performance.

3. **Using `DataView`** (`bigIntToBigEndianBytesDataView`)
   - **Description**: This method creates a `DataView` over an `ArrayBuffer` and uses `setBigUint64` to store the BigInt directly.
   - **Pros**: This is likely more performant since it directly manipulates binary data.
   - **Cons**: Slightly more complex set-up involving `ArrayBuffer` and `DataView`.

4. **Direct Constructor with Bitwise Operations** (`bigIntToUint8ArrayDirectConstructor`)
   - **Description**: This function employs bitwise operations to extract and assign the bytes directly into a `Uint8Array`.
   - **Pros**: Efficient as it avoids string conversion entirely and operates directly on numerical values.
   - **Cons**: May be less readable for those unfamiliar with bitwise operations.

5. **Direct Constructor with `parseInt`** (`bigIntToUint8ArrayDirectParseInt`)
   - **Description**: This approach is similar to the previous one but uses `parseInt` for byte extraction.
   - **Pros**: More intuitive for those familiar with parse conversion.
   - **Cons**: Performance degradation due to `parseInt` usage, which may add overhead.

6. **Direct Constructor with Split** (`bigIntToUint8ArrayDirectConstructor2`)
   - **Description**: This approach splits the BigInt into two 32-bit parts (low and high), then extracts bytes from these components.
   - **Pros**: Optimizes performance by working on lower-bit systems rather than individual bytes, potentially leveraging better CPU instruction sets.
   - **Cons**: Increased complexity due to the split operation.

### Benchmark Results

From the benchmarks, we can see the following performance results indicating the number of executions per second for each method on a specific browser and operating system:

- **Direct Constructor with split**: 11,349,633.0 executions/second (Best performer)
- **Direct Constructor**: 6,201,899.5 executions/second
- **DataView**: 1,877,769.75 executions/second
- **Direct ParseInt**: 1,860,158.125 executions/second
- **Loop Constructor**: 1,835,320.25 executions/second
- **Loop ParseInt**: 1,798,198.375 executions/second (Worst performer)

### Other Considerations

- **Performance Trade-Offs**: Different methods suit varying requirements. For high-performance applications, avoiding string manipulations and using direct binary data manipulation (such as via `DataView` or bitwise operations) is ideal.
- **Readability vs. Efficiency**: The more compact and straightforward methods are easier to understand but may be less efficient. Balancing readability with performance is a common concern in software engineering.

### Alternatives

- **Use of WebAssembly**: If more performance is required, alternative implementations, potentially using WebAssembly for the heavy lifting, could yield better results.
- **Third-party Libraries**: Libraries like `BigInt.js` or others focus on manipulation of large integers and may provide methods specifically tailored for this type of bit manipulation.
- **Different Endianness**: Depending on the application needs, consider implementing little-endian byte order conversions as well.

Overall, while the benchmark helps evaluate specific JavaScript techniques for BigInt to byte array conversion, it also reinforces general principles regarding performance considerations and trade-offs in software development.

Related benchmarks:

BigInt to BigEndian Bytes (extended by trincot, v2) (version: 1)

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

Created: 4 months ago by: Guest

Jump to the latest result

Loop ParseInt

Loop Constructor

DataView

Direct Constructor

Direct ParseInt

Direct Constructor with split

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