Benchmark: Check Variants2 - MeasureThat.net

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 ];
const firstSizeByte = 0b0000_0001

Tests:

Map Check
const sizeSize = asd1.get(firstSizeByte) || 0;
Object Check
const sizeSize = asd2[firstSizeByte] || 0
Array Check
const sizeSize = asd3[asd3.indexOf(firstSizeByte)] ?? 0
Current Variant
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: 15 days ago)

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

Browser/OS: Firefox 138 on Windows

View result in a separate tab

Test name	Executions per second
Map Check	708894016.0 Ops/sec
Object Check	635119872.0 Ops/sec
Array Check	18966430.0 Ops/sec
Current Variant	73193792.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark described in the provided JSON tests the performance of different data structures and approaches in JavaScript to retrieve the value associated with a specific bit (or flag) in a byte represented by the variable `firstSizeByte`. Each test compares a different method of accessing or querying data to see which is faster, as indicated by the "ExecutionsPerSecond" metric.

### Data Structures and Their Pros/Cons

1. **Map Check**:
   - **Implementation**: Utilizes a `Map`, where the binary values are mapped to their corresponding integers.
   - **Code**:
     ```javascript
     const sizeSize = asd1.get(firstSizeByte) || 0;
     ```
   - **Pros**:
     - `Map` is highly optimized for key-value pairs, making retrieval efficient.
     - It maintains insertion order and allows any type of key.
   - **Cons**:
     - Overhead of using a `Map` as opposed to a plain object or array due to its internal data structure.
     - Slightly higher memory usage than other simple data structures.

2. **Object Check**:
   - **Implementation**: Uses a plain JavaScript object to map binary flags to their respective values.
   - **Code**:
     ```javascript
     const sizeSize = asd2[firstSizeByte] || 0;
     ```
   - **Pros**:
     - Simpler and potentially faster than `Map` for small and fixed sets of data.
     - Fewer overheads as it uses plain objects.
   - **Cons**:
     - Lack of order guarantees for key traversal (though not necessary for this use case).
     - Potential issues with key collisions if using non-string keys.

3. **Array Check**:
   - **Implementation**: Uses an array to hold binary values, and the index of the matching binary flag is used to get the corresponding value.
   - **Code**:
     ```javascript
     const sizeSize = asd3[asd3.indexOf(firstSizeByte)] ?? 0;
     ```
   - **Pros**:
     - Simplicity in design; can work well for indexed retrieval.
     - No additional overhead associated with objects or maps.
   - **Cons**:
     - Searching with `indexOf` is O(n), so it can be inefficient for larger datasets.
     - If the values are not guaranteed to be unique, this method may yield unexpected results.

4. **Current Variant**:
   - **Implementation**: Uses bitwise operations to perform checks against the flags directly encoded in the byte.
   - **Code**:
     ```javascript
     let sizeSize = 0;
     if(firstSizeByte & 0b1000_0000) sizeSize = 1;
     else if(firstSizeByte & 0b0100_0000) sizeSize = 2;
     // (and so on)
     ```
   - **Pros**:
     - Very fast, as it directly checks bits using bitwise operations, which are typically computationally inexpensive.
     - No additional memory usage, making it space-efficient.
   - **Cons**:
     - Less flexible, as it requires explicit checks for each bit, making the code harder to maintain.
     - As the number of bits or flags increases, this could lead to lengthy condition checks.

### Performance Results

From the benchmark results, the performance of these methods regarding `ExecutionsPerSecond` are as follows:
- **Map Check**: 260,067,664
- **Current Variant**: 253,369,040
- **Array Check**: 135,350,080
- **Object Check**: 112,624,864

### Summary of Considerations

- The `Map` implementation showcased the highest performance, suggesting it is the most optimized for key-value pair searches among the tested options, but may introduce some overhead.
- The current variant that leverages bitwise operations performed almost as well as the `Map`, suggesting that for this particular use case, it could be a very efficient way to handle specific flags when performance is crucial.
- The `Object` and `Array` implementations showed lesser performance, indicating that for larger or more complex datasets, they may not be ideal choices.

### Alternatives
Other alternatives outside of those tested could include:
- **Sets**: Useful for certain types of membership checks or uniqueness, but not relevant here since the task involves mapping keys to values.
- **Typed Arrays**: If the need is strictly for numeric data and performance is critical, typed arrays may offer better performance due to lower overhead.
- **Native JavaScript collections like `WeakMap` or `WeakSet`**: Used when key management beyond just reference types is needed, though not applicable in this particular scenario.

In conclusion, the choice of which approach to use depends on the specific requirements for performance, memory usage, and flexibility/maintainability needs within the codebase.

Related benchmarks:

Check Variants2 (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):