Benchmark: String Big array comparision 2

String Big array comparision 2 (version: 0)

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

Jump to the latest result

Script Preparation code:

// Create a random string of length 32
var r32str = Array.from({ length: 32 }, () => String.fromCharCode(Math.floor(Math.random() * 256))).join('');

// Create an array of 5000 random strings, each of length 32
var mil32str = Array.from({ length: 1_000_000 }, () => 
    Array.from({ length: 32 }, () => String.fromCharCode(Math.floor(Math.random() * 256))).join('')
);

// Create a random string of length 32
var r96str = Array.from({ length: 96 }, () => String.fromCharCode(Math.floor(Math.random() * 256))).join('');

// Create an array of 5000 random strings, each of length 32
var mil96str = Array.from({ length: 1_000_000 }, () => 
    Array.from({ length: 96 }, () => String.fromCharCode(Math.floor(Math.random() * 256))).join('')
);

// Create a random string of length 32
var r160str = Array.from({ length: 160 }, () => String.fromCharCode(Math.floor(Math.random() * 256))).join('');

// Create an array of 5000 random strings, each of length 32
var mil160str = Array.from({ length: 1_000_000 }, () => 
    Array.from({ length: 160 }, () => String.fromCharCode(Math.floor(Math.random() * 256))).join('')
);

Tests:

1 or 0 out of 10 million 32 byte arrays
// Compare the random string against each string in the array const b = mil32str.some(str => str === r32str);
1 or 0 out of 10 million 96 byte arrays
// Compare the random string against each string in the array const b = mil96str.some(str => str === r96str);
1 or 0 out of 10 million 160byte arrays
// Compare the random string against each string in the array const b = mil96str.some(str => str === r96str);

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 (X11; Ubuntu; Linux x86_64; rv:129.0) Gecko/20100101 Firefox/129.0

Browser/OS: Firefox 129 on Ubuntu

View result in a separate tab

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

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark is designed to compare the performance of three approaches for finding a single match in large arrays of strings:

1. **Integer-based comparison**: Using bitwise operations to compare each string in the array against a reference string.
2. **String-based comparison (32 bytes)**: Comparing each string in the array against a reference string, where both are 32-byte long.
3. **String-based comparison (96 and 160 bytes)**: Similar to the previous one, but with strings that are either 96 or 160 bytes long.

**Comparison Options**

The benchmark compares three approaches:

1. **`some()` method**: A built-in JavaScript method that returns `true` if at least one element in an array passes a test.
2. **Direct indexing**: Accessing each string in the array using its index, and then comparing it to the reference string.

**Pros and Cons**

Here's a brief summary of each approach:

1. **Integer-based comparison**:
	* Pros: May be faster due to optimized bitwise operations.
	* Cons: Requires more memory access and might not work correctly for strings with non-ASCII characters.
2. **String-based comparison (32 bytes)**:
	* Pros: Simple and straightforward, works well for ASCII strings.
	* Cons: Might be slower than the integer-based approach, especially for longer strings.
3. **String-based comparison (96 and 160 bytes)**:
	* Pros: Similar to the previous one, but allows testing with larger strings.
	* Cons: May be even slower due to increased memory access.

**Library Used**

None of the benchmark cases use a specific library. However, it's worth noting that the `some()` method is a built-in JavaScript method that uses a similar algorithm under the hood.

**Special JS Feature/Syntax**

The benchmark does not explicitly mention any special JavaScript features or syntax. It only relies on standard JavaScript functionality.

**Other Alternatives**

If you wanted to write your own benchmark, you might consider alternative approaches such as:

1. **Using `find()` instead of `some()`**: While `some()` is designed for finding a single match, `find()` can also be used with an accumulator function to achieve the same result.
2. **Using a custom loop**: Instead of relying on built-in methods like `some()`, you could write a custom loop to iterate over the array and perform the comparison.

Keep in mind that writing your own benchmark might not provide accurate results, as it may be biased towards your specific implementation or hardware configuration. Measuring this type of performance can be complex and requires careful consideration of various factors, such as memory allocation, cache hits, and branch prediction.

Related benchmarks: