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

HTML Preparation code:

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

Script Preparation code:

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;
}

// Forward assignment instead of backward
function bigIntToUint8ArrayDirectConstructor3(value) {
    const result = new Uint8Array(8);
    const low = Number(value & 0xffffffffn);
    const high = Number(value >> 32n);
    result[0] = high >>> 24;
    result[1] = (high >>> 16) & 0xff;
    result[2] = (high >>> 8) & 0xff;
    result[3] = high & 0xff;
    result[4] = low >>> 24;
    result[5] = (low >>> 16) & 0xff;
    result[6] = (low >>> 8) & 0xff;
    result[7] = low & 0xff;
    return result;
}

Tests:

Direct Constructor
bigIntToUint8ArrayDirectConstructor(32149814014n)
With split
bigIntToUint8ArrayDirectConstructor2(32149814014n)
With split and forward assignment
bigIntToUint8ArrayDirectConstructor3(32149814014n)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Direct Constructor
With split
With split and forward assignment

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
Direct Constructor	6574462.5 Ops/sec
With split	11788106.0 Ops/sec
With split and forward assignment	11554508.0 Ops/sec

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

LLMs can make mistakes. Check important info.

### Overview of the Benchmark

The benchmark titled "BigInt to BigEndian Bytes (extended by trincot, v3)" measures the performance of three different JavaScript functions that convert a `BigInt` (a type in JavaScript for representing large integers) into a `Uint8Array` (a typed array representing an array of 8-bit unsigned integers) in Big Endian byte order. This conversion is crucial in scenarios such as serialization, cryptography, and network communication where byte representation is necessary.

### Tested Options

The benchmark compares three methods for performing this conversion:

1. **Direct Constructor**
   - **Function**: `bigIntToUint8ArrayDirectConstructor(value)`
   - **Description**: This function directly shifts and masks the bits of the `BigInt` to create the `Uint8Array`. It extracts each byte by performing bitwise operations and utilizes the `Number` constructor to convert the `BigInt` slices into integers.
   - **Performance**: It is the slowest of the three, with a result of approximately **6,574,462.5 executions per second**.

2. **With Split**
   - **Function**: `bigIntToUint8ArrayDirectConstructor2(value)`
   - **Description**: This method first splits the `BigInt` into two 32-bit integers (`low` and `high`) before performing the byte extraction. This approach simplifies the bit manipulation processes required to convert larger `BigInt` values.
   - **Performance**: It exhibits the best performance among the three, achieving around **11,788,106 executions per second**.

3. **With Split and Forward Assignment**
   - **Function**: `bigIntToUint8ArrayDirectConstructor3(value)`
   - **Description**: This variation also splits the `BigInt` into the two integers but assigns the results into the array in order from the highest byte to the lowest. 
   - **Performance**: Similar to the second method but slightly slower, with **11,554,508 executions per second**.

### Pros and Cons of Approaches

- **Direct Constructor**
  - **Pros**: Straightforward implementation; easy to understand the bit shifting.
  - **Cons**: Less efficient for larger `BigInt` values due to repetitive bit manipulations without optimization.

- **With Split**
  - **Pros**: More efficient as it reduces complexity by dividing the `BigInt` into two manageable parts. Bitwise operations on 32 bits are generally faster than on 64 bits.
  - **Cons**: Slightly more code complexity but benefits in terms of performance outweigh this.

- **With Split and Forward Assignment**
  - **Pros**: Similar advantages to the second method regarding performance; logical structure in terms of order in which bytes are placed in the output array.
  - **Cons**: Slight trade-off with execution speed compared to the second, possibly due to additional overhead in element indexing and assignment.

### Considerations

1. **Browser Variability**: Performance results are specific to the environment under which the benchmarks were executed (in this case, Chrome 131 on Windows). Different browsers and platforms may yield different results due to varying JavaScript engines and optimizations.

2. **BigInt and Uint8Array Support**: The `BigInt` type and `Uint8Array` are relatively new in the JavaScript ecosystem. While they have become widely supported, understanding their behavior and performance implications in different environments is crucial for developers.

3. **Use Cases**: Depending on the nature of the application (i.e., the size of the integers being handled), the choice among these methods could have significant implications on performance and efficiency.

### Alternatives

Other alternatives for handling similar cases of converting large integers to byte arrays may include:

- Using libraries like **Buffer** in Node.js, which provides utilities for handling binary data and may have optimizations tailored for performance.
- Utilizing third-party libraries such as **ByteBuffer.js** or **ASN.1** libraries, which incorporate sophisticated methods for encoding and decoding binary data.
- Custom implementations leveraging WebAssembly (Wasm) for potentially improved performance for complex applications.

This benchmark serves as a useful tool in understanding how different implementations in JavaScript can impact performance when handling `BigInt` operations, providing developers with insight into which method may be most appropriate for their needs.

Related benchmarks:

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

Comparing performance of: Direct Constructor vs With split vs With split and forward assignment

Created: 4 months ago by: Guest

Jump to the latest result

Direct Constructor

With split

With split and forward assignment

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