Benchmark: Bitwise Big array comparision 2

Bitwise Big array comparision 2 (version: 1)

Bitwise big array comparision. Goal of this test is to figure out wether it's more efficient to find 1 out of many checksums as string or integer.

Comparing performance of: `1 or 0 out of 10 million 32 byte arrays vs 1 or 0 out of 10 million 96 byte arrays vs 1 or 0 out of 10 million 160byte arrays`

Created: one year ago by: Registered User

Go to the latest result

Script Preparation code:

var r32arr = new Uint8Array(32).map(() => Math.floor(Math.random() * 256));
var mil32arr = Array.from({ length: 10_000_000 }, () => new Uint8Array(32).map(() => Math.floor(Math.random() * 256)));

var r96arr = new Uint8Array(96).map(() => Math.floor(Math.random() * 256));
var mil96arr = Array.from({ length: 10_000_000 }, () => new Uint8Array(96).map(() => Math.floor(Math.random() * 256)));

var r160arr = new Uint8Array(160).map(() => Math.floor(Math.random() * 256));
var mil160arr = Array.from({ length: 10_000_000 }, () => new Uint8Array(160).map(() => Math.floor(Math.random() * 256)));

Tests:

1 or 0 out of 10 million 32 byte arrays
const b = mil32arr.some(arr => arr.every((value, index) => value === r32arr[index]));
1 or 0 out of 10 million 96 byte arrays
const b = mil96arr.some(arr => arr.every((value, index) => value === r96arr[index]));
1 or 0 out of 10 million 160byte arrays
const b = mil160arr.some(arr => arr.every((value, index) => value === r160arr[index]));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1 or 0 out of 10 million 32 byte arrays
1 or 0 out of 10 million 96 byte arrays
1 or 0 out of 10 million 160byte arrays

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Firefox 129 on Windows

View result in a separate tab

1 or 0 out of 10 million 32 byte arrays

3/s

1 or 0 out of 10 million 96 byte arrays

1/s

1 or 0 out of 10 million 160byte arrays

1/s

View exact numbers

Test name	Executions per second
✓ 1 or 0 out of 10 million 32 byte arrays	3 Ops/sec
1 or 0 out of 10 million 96 byte arrays	1 Ops/sec
1 or 0 out of 10 million 160byte arrays	1 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark tests the performance difference between using bitwise comparisons and string comparisons to find a single element in large arrays.

**Test Case Overview**

There are three test cases:

1. 32-byte arrays (`r32arr` and `mil32arr`)
2. 96-byte arrays (`r96arr` and `mil96arr`)
3. 160-byte arrays (`r160arr` and `mil160arr`)

Each test case uses the `some()` method, which returns a boolean value indicating whether at least one element in the array passes a given callback function.

**Benchmarking Options**

The benchmark compares the performance of two approaches:

1.  **Bitwise comparisons**: The callback function in the `some()` method checks for exact equality between each element of the large array and the corresponding element of the smaller array (`r32arr`, `r96arr`, or `r160arr`) using bitwise operations (e.g., `value === r32arr[index]`).
2.  **String comparisons**: The callback function in the `some()` method checks for exact equality between each character of the large array and the corresponding character of the smaller array (`r32arr`, `r96arr`, or `r160arr`) using string operations (e.g., `value === r32arr[index]`).

**Pros and Cons**

*   **Bitwise comparisons**: 
    *   Pros:
        *   Typically faster than string comparisons due to the optimized implementation of bitwise operations in JavaScript.
        *   May be more suitable for large arrays with a uniform character set (e.g., ASCII or Unicode code points).
    *   Cons:
        *   May not perform well when dealing with non-ASCII characters or Unicode code points, as bitwise operations may not provide accurate results.
*   **String comparisons**: 
    *   Pros:
        *   Can handle non-ASCII characters and Unicode code points correctly.
        *   May be more suitable for large arrays with a diverse character set.
    *   Cons:
        *   Typically slower than bitwise comparisons due to the overhead of string operations.

**Library Used**

In this benchmark, there is no specific library mentioned. However, the use of `Array.from()` and `Uint8Array` suggests that the benchmark is designed for JavaScript environments that support these APIs.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax mentioned in the benchmark code. The focus is on comparing bitwise and string comparisons, which are fundamental operations in JavaScript.

**Other Alternatives**

If you need to compare elements in large arrays, other alternatives to consider:

*   **Regular expressions**: Can be used for pattern matching and may provide better performance than string comparisons.
*   **Native array methods**: Depending on the programming language and environment, native array methods (e.g., `indexOf()`, `findIndex()`) might offer better performance than custom implementations like `some()`.

Keep in mind that the best approach depends on the specific requirements of your project, including character sets, data formats, and performance constraints.