Benchmark: Map vs Object (real-world) Performance (better) 2

Script Preparation code:

var keyCount = 16384
var keys = []
var map = new Map()
var arr = []
var obj = Object.create(null)
delete obj.x


// Hide lookup keys to prevent V8 cheating (AKA Optimizing)
var getConspicuousKey = seed => keys[Math.floor(seed * keyCount)]


// Setup out test objects w/ random values
for (let i=0; i<keyCount; i++) {
  let val = Math.random()
  let key = Math.random().toString()
  keys.push(key)
  map.set(key,val)
  obj[key] = val
}

Tests:

Conspicuous Map lookup
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = map.get(key) }
Conspicuous Obj lookup
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = obj[key] }
Conspicuous Map lookup 2
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = map.get(key) }
Conspicuous Obj lookup 2
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = obj[key] }
add arr
const arr1 = [] for (let i=0; i<keyCount; i++) { let v = Math.random() arr1.push(v) }
add map
const map1 = new Map() for (let i=0; i<keyCount; i++) { let v = Math.random() map1.set(i,v) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Conspicuous Map lookup
Conspicuous Obj lookup
Conspicuous Map lookup 2
Conspicuous Obj lookup 2
add arr
add map

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark is designed to compare the performance of two data structures: Maps (using `Map` in JavaScript) and Objects (using `Object`). The test creates a large dataset of 16,384 entries each and performs two types of lookups on both data structures: "Conspicuous Map lookup" and "Conspicuous Obj lookup". Additionally, it tests adding an array and a map to the objects.

**Options Compared**

The benchmark compares the performance of:

1. **Map**: Using `Map` in JavaScript to store key-value pairs.
2. **Object**: Using `Object` in JavaScript as a dictionary or hash table.

**Pros and Cons**

* **Maps (using `Map`)**:
	+ Pros: Efficient lookup, insertion, and deletion operations. Maps are designed for this purpose and provide good performance.
	+ Cons: May have additional overhead due to the creation of iterators and other internal data structures.
* **Objects (using `Object`)**:
	+ Pros: Fast lookups can be achieved using bracket notation (`obj[key]`) and property access (`obj['key']`).
	+ Cons: Object lookups are not as efficient as Map lookups, especially for large datasets. This is because objects use a linear search approach to find properties.

**Other Considerations**

* The benchmark uses a technique called "conspicuous lookup" to make the data structure being tested more distinguishable from others. In this case, it's using a random seed to generate keys that are not present in the array or map.
* The benchmark creates a large dataset of 16,384 entries each, which is likely intended to simulate real-world scenarios where performance needs to be measured under heavy loads.

**Library and Purpose**

The `Map` class is used for this benchmark because it's designed specifically for storing key-value pairs. It provides an efficient way to perform lookups, insertions, and deletions using the `get()`, `set()`, and `delete()` methods.

**Special JS Feature or Syntax**

None mentioned in this specific benchmark, but note that JavaScript has other data structures like Sets, which are designed for fast membership testing. Additionally, modern JavaScript engines have optimized performance features like Just-In-Time (JIT) compilation, which can further impact the performance of the benchmark results.

Now, regarding alternative benchmarks:

* Other data structures that could be compared in this benchmark include:
	+ `Set`: A lightweight collection of unique values.
	+ `Array`: An array-based implementation for storing and accessing key-value pairs.
	+ `WeakMap` or `WeakObjectCache`: For storing weak references between objects.

These alternatives would require modifications to the benchmark's approach, but they could provide interesting insights into performance differences between different data structures.

Latest run results:

Run details: (Test run date: 4 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36 Edg/126.0.0.0

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	104.3 Ops/sec
Conspicuous Obj lookup	113.2 Ops/sec
Conspicuous Map lookup 2	108.6 Ops/sec
Conspicuous Obj lookup 2	112.9 Ops/sec
add arr	405.6 Ops/sec
add map	357.0 Ops/sec

Related benchmarks:

Map vs Object (real-world) Performance (better) 2 (version: 0)

Lookup of map vs object (in a real-world test format)

Comparing performance of: Conspicuous Map lookup vs Conspicuous Obj lookup vs Conspicuous Map lookup 2 vs Conspicuous Obj lookup 2 vs add arr vs add map

Created: 5 months ago by: Registered User

Jump to the latest result

Conspicuous Map lookup

Conspicuous Obj lookup

Conspicuous Map lookup 2

Conspicuous Obj lookup 2

add arr

add map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):