Benchmark: Long int keys (19 digits) (one select)

Script Preparation code:

var keyCount = 65535
var keys = []
var map = new Map()
var obj = {}


// 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 = 3000000000000000000+((4000000000000000000*Math.random())|0)
  keys.push(key)
  map.set(key,val)
  obj[key] = val
}

​x
 
var keyCount = 65535var keys = []var map = new Map()var obj = {}​​// Hide lookup keys to prevent V8 cheating (AKA Optimizing)var getConspicuousKey = seed => keys[Math.floor(seed * keyCount)]​​// Setup out test objects w/ random valuesfor (let i=0; i<keyCount; i++) {  let val = Math.random()  let key = 3000000000000000000+((4000000000000000000*Math.random())|0)  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) }
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] }
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) }
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] }
for (let i=0; i<keyCount; i++) {
let seed = Math.random()
let key = getConspicuousKey(seed)
a = obj[key]
}

Single map

  let seed = Math.random()
  let key = getConspicuousKey(seed)
  a = map.get(key)

 
  let seed = Math.random()  let key = getConspicuousKey(seed)  a = map.get(key)​

Single obj

  let seed = Math.random()
  let key = getConspicuousKey(seed)
  a = obj[key]

 
  let seed = Math.random()  let key = getConspicuousKey(seed)  a = obj[key]​

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Conspicuous Map lookup
Conspicuous Obj lookup
Conspicuous Map lookup 2
Conspicuous Obj lookup 2
Single map
Single obj

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36

Browser/OS: Chrome 110 on Linux

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	21.4 Ops/sec
Conspicuous Obj lookup	13.6 Ops/sec
Conspicuous Map lookup 2	22.6 Ops/sec
Conspicuous Obj lookup 2	13.8 Ops/sec
Single map	1377314.5 Ops/sec
Single obj	883642.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

I'll provide an explanation of the benchmark, its options, pros and cons, and other considerations.

Benchmark Overview

The benchmark measures the performance of two data structures: Maps (JavaScript objects with key-value pairs) and Objects (custom JavaScript objects). The test cases compare the execution time of lookups in both data structures using a similar approach. This allows us to isolate the overhead of using an Object versus a Map for lookups.

Options Compared

The benchmark compares the performance of two approaches:

Conspicuous Map lookup: Using the map.get() method with a key that is "conspicuous" (i.e., generated by Math.random() * keyCount and then scaled to fit within an array of 19-digit integers). This approach is used in multiple test cases.
Single map/obj: Using the map.get() or obj[key] method with a simple, fixed key (the first 19 digits of a random integer).
Conspicuous Map lookup 2 and Conspicuous Obj lookup 2: Similar to Conspicuous Map lookup, but with slightly different implementation details.

Pros and Cons

Conspicuous approach: This approach generates keys that are likely to be stored in the cache, which can lead to faster lookups. However, it also introduces additional overhead due to the randomization and scaling.
Single map/obj approach: This approach uses fixed, simple keys that are unlikely to be cached. It is simpler and more predictable than the Conspicuous approach but likely slower.

Considerations

The use of Math.random() to generate keys introduces variability in the benchmark results, which can make it harder to draw conclusions.
The choice of data structure (Map vs Object) depends on the specific use case. Maps are generally more convenient for lookups and insertions, while Objects provide more control over key-value pairs.
The use of "conspicuous" keys is a technique used by V8 (the JavaScript engine in Chrome) to optimize performance. By using similar keys, we can isolate this optimization effect.

Libraries and Special Features

The benchmark uses no external libraries besides the standard JavaScript Map and Object constructors. There are no special JavaScript features or syntax used in this benchmark.

Other Alternatives

If you want to modify or extend this benchmark, here are some alternative approaches:

Use different data structures (e.g., Sets, Arrays) for comparison.
Introduce additional factors that affect performance (e.g., hash collisions, cache thrashing).
Modify the key generation scheme to change the distribution of keys.
Add additional test cases with different characteristics (e.g., more keys, different data types).

LLMs can make mistakes. Check important info.

I'll provide an explanation of the benchmark, its options, pros and cons, and other considerations.

**Benchmark Overview**

**Options Compared**

The benchmark compares the performance of two approaches:

1. **Conspicuous Map lookup**: Using the `map.get()` method with a key that is "conspicuous" (i.e., generated by `Math.random() * keyCount` and then scaled to fit within an array of 19-digit integers). This approach is used in multiple test cases.
2. **Single map/obj**: Using the `map.get()` or `obj[key]` method with a simple, fixed key (the first 19 digits of a random integer).
3. **Conspicuous Map lookup 2** and **Conspicuous Obj lookup 2**: Similar to Conspicuous Map lookup, but with slightly different implementation details.

**Pros and Cons**

* **Conspicuous approach**: This approach generates keys that are likely to be stored in the cache, which can lead to faster lookups. However, it also introduces additional overhead due to the randomization and scaling.
* **Single map/obj approach**: This approach uses fixed, simple keys that are unlikely to be cached. It is simpler and more predictable than the Conspicuous approach but likely slower.

**Considerations**

* The use of `Math.random()` to generate keys introduces variability in the benchmark results, which can make it harder to draw conclusions.
* The choice of data structure (Map vs Object) depends on the specific use case. Maps are generally more convenient for lookups and insertions, while Objects provide more control over key-value pairs.
* The use of "conspicuous" keys is a technique used by V8 (the JavaScript engine in Chrome) to optimize performance. By using similar keys, we can isolate this optimization effect.

**Libraries and Special Features**

The benchmark uses no external libraries besides the standard JavaScript `Map` and `Object` constructors. There are no special JavaScript features or syntax used in this benchmark.

**Other Alternatives**

If you want to modify or extend this benchmark, here are some alternative approaches:

* Use different data structures (e.g., Sets, Arrays) for comparison.
* Introduce additional factors that affect performance (e.g., hash collisions, cache thrashing).
* Modify the key generation scheme to change the distribution of keys.
* Add additional test cases with different characteristics (e.g., more keys, different data types).

Related benchmarks:

Long int keys (19 digits) (one select) (version: 0)

Based on https://www.measurethat.net/Benchmarks/Show/11290/4/map-vs-object-real-world-performance but with long int keys

Comparing performance of: Conspicuous Map lookup vs Conspicuous Obj lookup vs Conspicuous Map lookup 2 vs Conspicuous Obj lookup 2 vs Single map vs Single obj

Created: 2 years ago by: Guest

Jump to the latest result

Conspicuous Map lookup

Conspicuous Obj lookup

Conspicuous Map lookup 2

Conspicuous Obj lookup 2