Benchmark: BigInt to BigEndian Bytes (extended by trincot)

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) & 0xffffffffn); 
    result[7] = low & 0xff;
    result[6] = (low >> 8) & 0xff;
    result[5] = (low >> 16) & 0xff;
    result[4] = (low >> 24) & 0xff;
    result[3] = high & 0xff;
    result[2] = (high >> 8) & 0xff;
    result[1] = (high >> 16) & 0xff;
    result[0] = (high >> 24) & 0xff;
    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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Loop ParseInt	1699444.9 Ops/sec
Loop Constructor	1687497.1 Ops/sec
DataView	1749622.6 Ops/sec
Direct Constructor	5739882.5 Ops/sec
Direct ParseInt	1591703.2 Ops/sec
Direct Constructor with split	9620428.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark described in the provided JSON is designed to evaluate various methods for converting a BigInt to a Big-endian byte array in JavaScript. Each test case focuses on a distinct implementation strategy for the conversion, allowing for a comparison of performance in terms of the number of executions per second.

### Options Compared in the Benchmark

1. **Loop with `parseInt`**: 
   - **Function**: `bigIntToBigEndianBytesLoopParseInt(value)`
   - **Description**: Converts the BigInt to a hexadecimal representation, then loops over each byte, parsing it with `parseInt`.
   - **Pros**: Simple and easy to read. 
   - **Cons**: `parseInt` can introduce overhead due to its string parsing.

2. **Loop with Constructor**: 
   - **Function**: `bigIntToBigEndianBytesLoopConstructor(value)`
   - **Description**: Similar to the previous, but uses the `Number` constructor to convert hex slices directly to bytes.
   - **Pros**: More direct conversion than `parseInt`.
   - **Cons**: Still involves slicing and may be less efficient than methods that avoid string manipulation.

3. **DataView**: 
   - **Function**: `bigIntToBigEndianBytesDataView(value)`
   - **Description**: Utilizes a `DataView` to directly set bytes in an `ArrayBuffer`.
   - **Pros**: More efficient for lower-level byte manipulations and avoids intermediate string representations.
   - **Cons**: Slightly more complex to set up than basic loops.

4. **Direct Constructor**: 
   - **Function**: `bigIntToUint8ArrayDirectConstructor(value)`
   - **Description**: Directly shifts the bits and constructs the byte array without intermediate steps.
   - **Pros**: Generally faster as it operates directly on numeric values.
   - **Cons**: May be less readable due to bitwise operations.

5. **Direct ParseInt**: 
   - **Function**: `bigIntToUint8ArrayDirectParseInt(value)`
   - **Description**: Similar to Direct Constructor but utilizes `parseInt` for each byte after shifting.
   - **Pros**: Can be more understandable for those familiar with `parseInt`.
   - **Cons**: Introduces overhead due to string parsing.

6. **Direct Constructor with Split**:
   - **Function**: `bigIntToUint8ArrayDirectConstructor2(value)`
   - **Description**: Splits the BigInt into two 32-bit values, then builds the byte array.
   - **Pros**: Effective in reducing the complexity of dealing with large numbers by breaking them down.
   - **Cons**: More complex to implement and understand but generally yields high performance.

### Performance Results

From the benchmark results:
- The **Direct Constructor with split** approach achieved the highest executions per second, showcasing its efficiency.
- Following closely are **Direct Constructor** and other methods, which performed significantly but were slower than the top performer.
- The **DataView** and looping methods like **Loop ParseInt** demonstrated lower performance, likely due to their reliance on string parsing and looping constructs.

### Conclusion and Considerations

While these implementations can be influenced by specific JavaScript engines and environments, generally:
- **Data manipulations at a lower level (using DataView or bitwise operations)** tend to be faster.
- **String manipulations** are often slower due to the overhead of parsing and allocation.
  
For developers looking at alternatives, methods in other languages (like using `Buffer` in Node.js, or methods in Python leveraging libraries like NumPy) could provide additional context or performance characteristics. However, in JavaScript, these implementations showcase the flexibility of handling BigInts and the impact of chosen methodologies on performance.

Software engineers should choose the approach that meets their specific needs while considering maintainability, readability, and performance based on the context of their application.

Related benchmarks:

BigInt to BigEndian Bytes (extended by trincot) (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):