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: 9 months ago by: Registered User

Jump 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)));

​x
 
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]));
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]));
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]));
const b = mil160arr.some(arr => arr.every((value, index) => value === r160arr[index]));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 9 months 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

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

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

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:

32-byte arrays (r32arr and mil32arr)
96-byte arrays (r96arr and mil96arr)
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:

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]).
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.

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.

Related benchmarks: