Benchmark: Perf difference when using looping over collection vs creating a cached projection for that access pattern (small array)

Perf difference when using looping over collection vs creating a cached projection for that access pattern (small array) (version: 2)

Intent is to measure the benefit of creating multiple "cache projections" (for lack of a better name) when using Redux Toolkit's EntityAdapter. It already handles everything in an "entities" object (keys are ids, values are the entity) and manages a list of ids separately. If we want to access a specific item based on the value of another key on that object, we are forced to loop through all the entities (either with Object.keys, Object.values, a for..in, or using the ids list) to find it. The solution tested here is to maintain another object that's simply a mapping between the key we want to look for and the id of the corresponding object for fast access. It is obviously faster, but by how much?

Comparing performance of: finding item using find with Object.values vs finding item using find with Object.keys vs looping with for..in vs finding item using find without Object.values (accessing entities using the ids array) vs using the itemIdByUuid "projection" we created

Created: 2 years ago by: Registered User

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]];
    }
}

var ids = [];
var uuids = [];
var entities = {};
var itemIdByUuid = {};
for(let i = 0; i < 25; i++) {
  const obj = {
    id: `id${i}`,
    uuid: crypto.randomUUID(),
    foo: "bar",
    bar: "foo",
  };
  
  entities[obj.id] = obj;
  ids.push(obj.id);
  itemIdByUuid[obj.uuid] = obj.id;
}

Tests:

finding item using find with Object.values
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)]; const itemMatchingSomeUUID = Object.values(entities).find((obj) => obj.uuid === randomUUID);
finding item using find with Object.keys
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)]; const itemMatchingSomeUUID = Object.keys(entities).find((id) => entities[id].uuid === randomUUID);
looping with for..in
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)]; let itemMatchingSomeUUID = null; for(const id in entities) { if(entities[id].uuid === randomUUID) { itemMatchingSomeUUID = entities[id]; break; } }
finding item using find without Object.values (accessing entities using the ids array)
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)]; const itemMatchingSomeUUID = ids.map((id) => entities[id]).find((obj) => obj.uuid === randomUUID);
using the itemIdByUuid "projection" we created
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)]; const itemMatchingSomeUUID = entities[itemIdByUuid[randomUUID]];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
finding item using find with Object.values
finding item using find with Object.keys
looping with for..in
finding item using find without Object.values (accessing entities using the ids array)
using the itemIdByUuid "projection" we created

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The benchmark measures the performance difference between four approaches to access a specific entity in an object:

1. Using `Object.values()` and `find()`
2. Using `Object.keys()` and `find()`
3. Using a `for...in` loop
4. Using a pre-computed mapping (`itemIdByUuid`) to directly access the entity

**Options Compared**

The benchmark compares the performance of these four approaches:

* Approach 1: Using `Object.values()` and `find()` to find an item in the `entities` object.
* Approach 2: Using `Object.keys()` and `find()` to find an item in the `entities` object.
* Approach 3: Using a `for...in` loop to iterate through the `entities` object and find an item.
* Approach 4: Using the pre-computed mapping (`itemIdByUuid`) to directly access the entity.

**Pros and Cons of Each Approach**

1. **Approach 1: Object.values() and find()**
	* Pros:
		+ Simple and concise code
		+ Efficient for most use cases, as it avoids unnecessary iterations.
	* Cons:
		+ May be slower than other approaches if the `entities` object is large, as it requires iterating through all objects to find a match.
2. **Approach 2: Object.keys() and find()**
	* Pros:
		+ Similar efficiency to Approach 1 for small to medium-sized `entities` objects.
		+ May be faster than Approach 3 for large `entities` objects, as it avoids the overhead of iterating through all keys.
	* Cons:
		+ Requires more code and may be less readable than Approaches 1 and 4.
3. **Approach 3: For...in loop**
	* Pros:
		+ Allows for fine-grained control over the iteration process.
	* Cons:
		+ Can be slower than other approaches, especially for large `entities` objects, due to the overhead of iterating through all keys and checking each one.
4. **Approach 4: itemIdByUuid mapping**
	* Pros:
		+ Provides direct access to the entity without requiring iteration or searching.
		+ May be faster than other approaches, especially for large `entities` objects.

**Pre-computed Mapping (itemIdByUuid)**

The pre-computed mapping (`itemIdByUuid`) is a crucial aspect of this benchmark. By creating a mapping between each item's ID and its corresponding entity, Approach 4 can directly access the entity without requiring iteration or searching. This approach can provide significant performance benefits for large `entities` objects.

**Benchmark Results**

The benchmark results show that:

* Approach 1 (Object.values() and find()) is generally the fastest approach.
* Approach 2 (Object.keys() and find()) is slower than Approach 1 but faster than Approach 3.
* Approach 3 (For...in loop) is the slowest approach, especially for large `entities` objects.
* Approach 4 (itemIdByUuid mapping) provides the best performance, often outperforming Approaches 1 and 2 by a significant margin.

These results highlight the importance of choosing the right approach based on the specific use case and size of the `entities` object.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36

Browser/OS: Chrome 97 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
finding item using find with Object.values	256127.8 Ops/sec
finding item using find with Object.keys	250206.2 Ops/sec
looping with for..in	275812.9 Ops/sec
finding item using find without Object.values (accessing entities using the ids array)	309266.5 Ops/sec
using the itemIdByUuid "projection" we created	1719342.4 Ops/sec

Related benchmarks:

Perf difference when using looping over collection vs creating a cached projection for that access pattern (small array) (version: 2)

Comparing performance of: finding item using find with Object.values vs finding item using find with Object.keys vs looping with for..in vs finding item using find without Object.values (accessing entities using the ids array) vs using the itemIdByUuid "projection" we created

Created: 2 years ago by: Registered User

Jump to the latest result

finding item using find with Object.values

finding item using find with Object.keys

looping with for..in

finding item using find without Object.values (accessing entities using the ids array)

using the itemIdByUuid "projection" we created

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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