Benchmark: Object, Map: string vs numeric smi keys access performance

Object, Map: string vs numeric smi keys access performance (version: 0)

For small ~ 64 entry constant tables

Comparing performance of: Object random string keys vs Object random numeric smi keys vs Object sequential string keys vs Object sequential numeric smi keys vs Map random string keys vs Map random numeric smi keys vs Map sequential string keys vs Map sequential numeric smi keys

Created: 3 years ago by: Guest

Jump to the latest result

Script Preparation code:

function shuffleArray(array) {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
}

// 31 bit +ve integer smi
var randSmi = () => crypto.getRandomValues(new Uint32Array(1))[0] & 0x7fffffff;
// 6-7 char alphanumeric string
var randStr = () => randSmi().toString(36);

var numEntries = 64;
var numRounds = 100 * numEntries;

var strObj = {};
var strObjKeys = Array(numEntries);
var numObj = {};
var numObjKeys = Array(numEntries);

var strSeqObj = {};
var strSeqObjKeys = Array(numEntries);
var numSeqObj = {};
var numSeqObjKeys = Array(numEntries);

for (let i = 0; i < numEntries; i++) {
let strKey = `k${randStr()}`, numKey = randSmi();
let strSeqKey = `k${i}`, numSeqKey = i;
	strObj[strKey] = i;
	strObjKeys[i] = strKey;
	numObj[numKey] = i;
	numObjKeys[i] = numKey;

	strSeqObj[strSeqKey] = i;
	strSeqObjKeys[i] = strSeqKey;
	numSeqObj[numSeqKey] = i;
	numSeqObjKeys[i] = numSeqKey;
}

Object.freeze(strObj);
Object.freeze(numObj);
Object.freeze(strSeqObj);
Object.freeze(numSeqObj);

var strMap = new Map(Object.entries(strObj));
var numMap = new Map(Object.entries(numObj));
var strSeqMap = new Map(Object.entries(strSeqObj));
var numSeqMap = new Map(Object.entries(numSeqObj));

​x
 
function shuffleArray(array) {    for (let i = array.length - 1; i > 0; i--) {        const j = Math.floor(Math.random() * (i + 1));        [array[i], array[j]] = [array[j], array[i]];    }}​// 31 bit +ve integer smivar randSmi = () => crypto.getRandomValues(new Uint32Array(1))[0] & 0x7fffffff;// 6-7 char alphanumeric stringvar randStr = () => randSmi().toString(36);​var numEntries = 64;var numRounds = 100 * numEntries;​var strObj = {};var strObjKeys = Array(numEntries);var numObj = {};var numObjKeys = Array(numEntries);​var strSeqObj = {};var strSeqObjKeys = Array(numEntries);var numSeqObj = {};var numSeqObjKeys = Array(numEntries);​for (let i = 0; i < numEntries; i++) {let strKey = `k${randStr()}`, numKey = randSmi();let strSeqKey = `k${i}`, numSeqKey = i;    strObj[strKey] = i;    strObjKeys[i] = strKey;    numObj[numKey] = i;    numObjKeys[i] = numKey;​    strSeqObj[strSeqKey] = i;    strSeqObjKeys[i] = strSeqKey;    numSeqObj[numSeqKey] = i;    numSeqObjKeys[i] = numSeqKey;}​Object.freeze(strObj);Object.freeze(numObj);Object.freeze(strSeqObj);Object.freeze(numSeqObj);​var strMap = new Map(Object.entries(strObj));var numMap = new Map(Object.entries(numObj));var strSeqMap = new Map(Object.entries(strSeqObj));var numSeqMap = new Map(Object.entries(numSeqObj));

Tests:

Object random string keys
let total = 0; for (let i = 0; i < numRounds; i++) { total += strObj[strObjKeys[Math.random() * numEntries | 0]]; }
let total = 0;
for (let i = 0; i < numRounds; i++) {
total += strObj[strObjKeys[Math.random() * numEntries | 0]];
}
Object random numeric smi keys
let total = 0; for (let i = 0; i < numRounds; i++) { total += numObj[numObjKeys[Math.random() * numEntries | 0]]; }
let total = 0;
for (let i = 0; i < numRounds; i++) {
total += numObj[numObjKeys[Math.random() * numEntries | 0]];
}
Object sequential string keys
let total = 0; for (let i = 0; i < numRounds; i++) { total += strSeqObj[strSeqObjKeys[Math.random() * numEntries | 0]]; }
let total = 0;
for (let i = 0; i < numRounds; i++) {
total += strSeqObj[strSeqObjKeys[Math.random() * numEntries | 0]];
}
Object sequential numeric smi keys
let total = 0; for (let i = 0; i < numRounds; i++) { total += numSeqObj[numSeqObjKeys[Math.random() * numEntries | 0]]; }
let total = 0;
for (let i = 0; i < numRounds; i++) {
total += numSeqObj[numSeqObjKeys[Math.random() * numEntries | 0]];
}
Map random string keys
let total = 0; for (let i = 0; i < numRounds; i++) { total += strMap.get(strObjKeys[Math.random() * numEntries | 0]); }
let total = 0;
for (let i = 0; i < numRounds; i++) {
total += strMap.get(strObjKeys[Math.random() * numEntries | 0]);
}
Map random numeric smi keys
let total = 0; for (let i = 0; i < numRounds; i++) { total += numMap.get(numObjKeys[Math.random() * numEntries | 0]); }
let total = 0;
for (let i = 0; i < numRounds; i++) {
total += numMap.get(numObjKeys[Math.random() * numEntries | 0]);
}
Map sequential string keys
let total = 0; for (let i = 0; i < numRounds; i++) { total += strSeqMap.get(strSeqObjKeys[Math.random() * numEntries | 0]); }
let total = 0;
for (let i = 0; i < numRounds; i++) {
total += strSeqMap.get(strSeqObjKeys[Math.random() * numEntries | 0]);
}
Map sequential numeric smi keys
let total = 0; for (let i = 0; i < numRounds; i++) { total += numSeqMap.get(numSeqObjKeys[Math.random() * numEntries | 0]); }
let total = 0;
for (let i = 0; i < numRounds; i++) {
total += numSeqMap.get(numSeqObjKeys[Math.random() * numEntries | 0]);
}

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
Object random string keys
Object random numeric smi keys
Object sequential string keys
Object sequential numeric smi keys
Map random string keys
Map random numeric smi keys
Map sequential string keys
Map sequential numeric smi keys

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Android 12; Mobile; rv:99.0) Gecko/99.0 Firefox/99.0

Browser/OS: Firefox Mobile 99 on Android

View result in a separate tab

Test name	Executions per second
Object random string keys	1819.6 Ops/sec
Object random numeric smi keys	1943.9 Ops/sec
Object sequential string keys	2391.1 Ops/sec
Object sequential numeric smi keys	8006.1 Ops/sec
Map random string keys	1742.2 Ops/sec
Map random numeric smi keys	4685.1 Ops/sec
Map sequential string keys	2098.9 Ops/sec
Map sequential numeric smi keys	5636.5 Ops/sec

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

It seems like you're sharing some benchmark results from a Firefox Mobile test. Let's dive into the details.

The tests seem to be comparing the performance of different map operations:

Object sequential numeric smi keys: Maps over an array of sequential numbers (0, 1, 2, ...).
Map sequential numeric smi keys: Maps over an array of sequential numbers using a Map object.
Map random numeric smi keys: Maps over an array of randomly generated numbers.
Object sequential string keys: Maps over an array of sequential strings (e.g., "a", "b", "c", ...).
Map sequential string keys: Maps over an array of sequential strings using a Map object.
Object random numeric smi keys: Maps over an array of randomly generated numbers, but this time using an Object instead of a Map.
Object random string keys: Maps over an array of randomly generated strings.
Map random string keys: Maps over an array of randomly generated strings using a Map object.

The results show the average number of executions per second (ExecutionsPerSecond) for each test on different devices running Firefox Mobile 99.

Based on these results, we can observe:

The Object sequential numeric smi keys and Map sequential numeric smi keys tests have similar performance, with both average around 6000+ executions per second.
The Map random numeric smi keys test has a significantly lower performance (around 4000-5000 executions per second), likely due to the randomness of the key values.
The Object sequential string keys and Map sequential string keys tests also have similar performance, with both averaging around 2000-3000 executions per second.
The Object random numeric smi keys test has a lower performance compared to the Object sequential numeric smi keys test (around 1800 executions per second).
The Object random string keys and Map random string keys tests have significantly lower performance (around 1500-1700 executions per second), likely due to the randomness of the key values.

Overall, it seems that:

Sequential maps with integer keys perform better than random maps with integer keys.
Maps with sequential string keys outperform Object-based versions with sequential numeric keys.
Randomized map operations can lead to performance issues compared to sequential or predictable mappings.

LLMs can make mistakes. Check important info.

It seems like you're sharing some benchmark results from a Firefox Mobile test. Let's dive into the details.

The tests seem to be comparing the performance of different map operations:

1. **Object sequential numeric smi keys**: Maps over an array of sequential numbers (0, 1, 2, ...).
2. **Map sequential numeric smi keys**: Maps over an array of sequential numbers using a Map object.
3. **Map random numeric smi keys**: Maps over an array of randomly generated numbers.
4. **Object sequential string keys**: Maps over an array of sequential strings (e.g., "a", "b", "c", ...).
5. **Map sequential string keys**: Maps over an array of sequential strings using a Map object.
6. **Object random numeric smi keys**: Maps over an array of randomly generated numbers, but this time using an Object instead of a Map.
7. **Object random string keys**: Maps over an array of randomly generated strings.
8. **Map random string keys**: Maps over an array of randomly generated strings using a Map object.

The results show the average number of executions per second (ExecutionsPerSecond) for each test on different devices running Firefox Mobile 99.

Based on these results, we can observe:

* The Object sequential numeric smi keys and Map sequential numeric smi keys tests have similar performance, with both average around 6000+ executions per second.
* The Map random numeric smi keys test has a significantly lower performance (around 4000-5000 executions per second), likely due to the randomness of the key values.
* The Object sequential string keys and Map sequential string keys tests also have similar performance, with both averaging around 2000-3000 executions per second.
* The Object random numeric smi keys test has a lower performance compared to the Object sequential numeric smi keys test (around 1800 executions per second).
* The Object random string keys and Map random string keys tests have significantly lower performance (around 1500-1700 executions per second), likely due to the randomness of the key values.

Overall, it seems that:

* Sequential maps with integer keys perform better than random maps with integer keys.
* Maps with sequential string keys outperform Object-based versions with sequential numeric keys.
* Randomized map operations can lead to performance issues compared to sequential or predictable mappings.

Related benchmarks: