Benchmark: Check Variants - 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 ];

Tests:

Map Check
const sizeSize = asd1.get(0b1000_0000) || 0;
Object Check
const sizeSize = asd2[0b1000_0000] || 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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Linux

View result in a separate tab

Test name	Executions per second
Map Check	274840928.0 Ops/sec
Object Check	118216200.0 Ops/sec
Array Check	103998432.0 Ops/sec
Current Variant	268651200.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark defined as "Check Variants" evaluates the performance of different data structures and methods in JavaScript for retrieving values based on predefined binary keys, specifically using `Map`, `Object`, and `Array`. Each approach has its own strengths and weaknesses. Below are the details of the individual test cases, what options are compared, and their characteristics.

### Test Cases and Their Comparisons

1. **Map Check**
   - **Benchmark Definition:** `const sizeSize = asd1.get(0b1000_0000) || 0;`
   - **Description:** This test uses a `Map` object, which allows keys of any type to be used. Here, `asd1` is a `Map` initialized with binary keys.
   - **Pros:** 
     - Fast lookups due to hash table implementation.
     - Supports object keys, which `Object` does not.
   - **Cons:**
     - A bit more memory overhead than a plain object.
  
2. **Object Check**
   - **Benchmark Definition:** `const sizeSize = asd2[0b1000_0000] || 0;`
   - **Description:** This test evaluates the performance of a standard JavaScript object as a dictionary.
   - **Pros:** 
     - Simple and intuitive syntax for simple key/value storage.
     - Less overhead in memory when only simple data types are involved.
   - **Cons:**
     - Performance can degrade for large key sets or frequent modifications.
     - Key types are limited to strings (or Symbols).

3. **Array Check**
   - **Benchmark Definition:** `const sizeSize = asd3[asd3.indexOf(0b0000_0001)] ?? 0;`
   - **Description:** This test uses an array, looking for the index of a binary value and returning its size.
   - **Pros:** 
     - Arrays maintain order and can be useful for ordered collections.
     - Easy to iterate over.
   - **Cons:**
     - Slower lookups due to linear search (`indexOf`), as it must iterate through the entire array.
     - Less efficient for large datasets.

4. **Current Variant**
   - **Benchmark Definition:** `if-else` statements to manually check individual bits of a byte.
   - **Description:** This variant retrieves the size by performing bitwise operations on a byte to determine which bit is set.
   - **Pros:** 
     - Very fast for fixed-size checks as it can short-circuit.
     - Direct access without the overhead of data structures.
   - **Cons:**
     - Less scalable for larger numbers or various configurations since it’s hardcoded.
     - Non-idiomatic for JavaScript, as it may not leverage more advanced data structures.

### Additional Considerations and Alternatives

- **Performance:** As indicated by the benchmark results, the `Map` implementation performs the best, followed closely by the direct bitwise approach (`Current Variant`). The primary takeaway is that for frequent and high-performance use cases, leveraging `Map` can yield significant performance gains.
  
- **Memory Usage:** If memory consumption is a critical factor and you have simple key-value pairs, using an `Object` might be a better choice despite its drawbacks in scalability.

- **Ease of Use:** `Map` and `Object` generally offer more flexibility and ease of use for developers as dictionaries or associative arrays when compared to low-level bitwise operations that need careful handling.
  
- **Alternatives:**
  - **WeakMap / WeakSet:** These collections are useful for memory management when you need to store key-value pairs but want garbage collection to manage the memory of their keys.
  - **Sets:** If uniqueness of values is the primary concern, introducing sets can be advantageous, though this benchmark specifically targets key-value access rather than collection integrity.

### Conclusion
While all options have different implications for performance, memory usage, and ease of coding, the chosen structure must depend on specific application needs—whether they prioritize speed, memory efficiency, or ease of implementation.

Related benchmarks:

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