Benchmark: Check Variants 2

HTML Preparation code:

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

Script Preparation code:

const asd1 = new Map().set(0b1000_0000, 1).set(0b0100_0000, 2).set(0b0010_0000, 3).set(0b0001_0000, 4).set(0b0000_1000, 5).set(0b0000_0100, 6).set(0b0000_0010, 7).set(0b0000_0001, 8);
const asd2 = { 0b1000_0000: 1, 0b0100_0000: 2, 0b0010_0000: 3, 0b0001_0000: 4, 0b0000_1000: 5, 0b0000_0100: 6, 0b0000_0010: 7, 0b0000_0001: 8 };
const asd3 = [ 0b1000_0000, 0b0100_0000, 0b0010_0000, 0b0001_0000, 0b0000_1000, 0b0000_0100, 0b0000_0010, 0b0000_0001 ];

Tests:

Map Check
const sizeSize = asd1.get(0b0000_0001) || 0;
Object Check
const sizeSize = asd2[0b0000_0001] || 0
Array Check
const sizeSize = asd3[asd3.indexOf(0b0000_0001)] ?? 0
Current Variant
const firstSizeByte = 0b0000_0001 let sizeSize = 0 if(firstSizeByte & 0b1000_0000) sizeSize = 1 else if(firstSizeByte & 0b0100_0000) sizeSize = 2 else if(firstSizeByte & 0b0010_0000) sizeSize = 3 else if(firstSizeByte & 0b0001_0000) sizeSize = 4 else if(firstSizeByte & 0b0000_1000) sizeSize = 5 else if(firstSizeByte & 0b0000_0100) sizeSize = 6 else if(firstSizeByte & 0b0000_0010) sizeSize = 7 else if(firstSizeByte & 0b0000_0001) sizeSize = 8

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map Check
Object Check
Array Check
Current Variant

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 21 days ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:136.0) Gecko/20100101 Firefox/136.0

Browser/OS: Firefox 136 on Linux

View result in a separate tab

Test name	Executions per second
Map Check	1519579776.0 Ops/sec
Object Check	1522534784.0 Ops/sec
Array Check	50298336.0 Ops/sec
Current Variant	492082784.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark defines a performance comparison of different data structures and lookup strategies in JavaScript for retrieving values associated with specific binary keys. Let’s break down the various approaches being tested and analyze their pros and cons:

### Approaches Being Compared

1. **Map Check**:
   - **Code**: `const sizeSize = asd1.get(0b0000_0001) || 0;`
   - **Structure**: A `Map` is used to store the binary-keyed values.
   - **Execution Speed**: 1,522,539,784 operations per second.

2. **Object Check**:
   - **Code**: `const sizeSize = asd2[0b0000_0001] || 0;`
   - **Structure**: An object is used to store the same set of key-value pairs.
   - **Execution Speed**: 1,519,579,776 operations per second.

3. **Array Check**:
   - **Code**: `const sizeSize = asd3[asd3.indexOf(0b0000_0001)] ?? 0;`
   - **Structure**: An array is used, with a lookup based on the index obtained via `indexOf`.
   - **Execution Speed**: 492,082,784 operations per second.

4. **Current Variant (Bitwise Operations)**:
   - **Code**: A series of bitwise checks to determine the size based on a specific byte.
   - **Execution Speed**: 50,298,336 operations per second.

### Pros and Cons of Each Approach

1. **Map Check**:
   - **Pros**: 
     - Maintains insertion order.
     - Can use non-string keys, which offers flexibility.
     - Typically, insertion and lookup times are O(1).
   - **Cons**:
     - Slight overhead compared to plain objects in simpler scenarios.
     - Larger memory footprint.

2. **Object Check**:
   - **Pros**:
     - Lightweight and straightforward for fixed key-value pairs.
     - Fast access time for known string keys.
   - **Cons**:
     - Can only use strings or Symbols as keys.
     - Does not maintain insertion order of keys (prior to ES6).

3. **Array Check**:
   - **Pros**:
     - Simple structure for sequentially numbered items.
     - Suitable for ordered data.
   - **Cons**:
     - Slower lookups due to the need to search through the array (`indexOf` has O(n) complexity).
     - Inefficient if values need to be accessed frequently.

4. **Current Variant (Bitwise Operations)**:
   - **Pros**:
     - Direct computation with constants for quick checks.
     - Low memory usage since no data structures are required.
   - **Cons**:
     - Less readable and maintainable; harder to extend.
     - Performance may drop if more conditions are added.

### Other Considerations and Alternatives

- **Other Storage Mechanisms**: If performance is critical and the dataset grows, using other structures like **Sets** for unique values or **WeakMaps** (for references that can be garbage collected) might be effective depending on the scenario.

- **Performance Alternatives**: For scenarios where memory usage and execution speed are the ultimate concerns, native binary manipulation in lower-level languages (like C or Rust) could provide optimal performance, especially in computational-heavy applications.

- **Evaluating Benchmark Conditions**: Factors like environmental differences (browser, operating system, and device type) can affect the results significantly; thus, benchmarks should be run in consistent environments.

### Special JavaScript Features Used

- **Binary Literals**: The use of `0b` prefix before binary numbers (e.g., `0b1000_0000`) is a modern JavaScript feature that allows developers to define binary literals easily. The underscore (`_`) within binary numbers improves readability but has no effect on their representation.

Overall, this benchmark effectively demonstrates how different data structures can impact performance in JavaScript, emphasizing the importance of choosing the appropriate structure based on the use case and operational requirements.

Related benchmarks:

Check Variants 2 (version: 1)

Comparing performance of: Map Check vs Object Check vs Array Check vs Current Variant

Created: 21 days ago by: Guest

Jump to the latest result

Map Check

Object Check

Array Check

Current Variant

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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