Benchmark: Perf difference when using find on collection vs creating a cached projection for that access pattern

Perf difference when using find on collection vs creating a cached projection for that access pattern (version: 0)

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.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.

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

Created: 4 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 < 5000; 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 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 without Object.values (accessing entities using the ids array)
using the itemIdByUuid "projection" we created

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition JSON and explain what's being tested, the options compared, their pros and cons, and other considerations.

**Benchmark Overview**

The benchmark measures the performance difference between three approaches to access an entity in a Redux Toolkit EntityAdapter:

1. Using `Object.values` with `find` to search for an item based on its UUID.
2. Accessing entities directly using their IDs stored in the `ids` array.
3. Creating a "cached projection" (in this case, `itemIdByUuid`) that maps UUIDs to entity IDs.

**Benchmark Options Compared**

The benchmark compares these three approaches:

1. **Finding item using find with Object.values**: This approach uses `Object.values` to get an array of all entities and then uses the `find` method to search for an item based on its UUID.
2. **Finding item using find without Object.values (accessing entities using the ids array)**: This approach directly accesses the `ids` array, which contains entity IDs, and then uses `find` to locate the corresponding entity.
3. **Using the itemIdByUuid "projection"**: This approach creates a mapping between UUIDs and entity IDs (`itemIdByUuid`) and uses it to directly access the desired entity.

**Pros and Cons of Each Approach**

1. **Finding item using find with Object.values**:
	* Pros: Simple and straightforward.
	* Cons: May be slower due to the need to iterate over all entities in `Object.values`.
2. **Finding item using find without Object.values (accessing entities using the ids array)**:
	* Pros: Faster than iterating over all entities, as it only accesses the specific ID.
	* Cons: Requires additional memory to store the `ids` array and may have performance overhead due to array indexing.
3. **Using the itemIdByUuid "projection"**:
	* Pros: Fastest approach, as it directly maps UUIDs to entity IDs without iteration over all entities.
	* Cons: Requires additional memory to create and maintain the `itemIdByUuid` mapping.

**Library Used**

The benchmark uses the following library:

1. **Crypto**: For generating random UUIDs (`crypto.randomUUID()`).
2. **Math.random()**: For generating random numbers used in the shuffle function (`shuffleArray`).

**Special JS Feature/Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax, but it leverages some built-in functions and methods like `Object.values`, `find`, `map`, and `for...in`.

**Other Considerations**

The benchmark is likely designed to:

* Evaluate the performance benefits of using a cached projection (like `itemIdByUuid`) in Redux Toolkit's EntityAdapter.
* Test the trade-offs between iterating over all entities or accessing specific IDs stored in an array.

To achieve similar results, you could use other benchmarking frameworks like BenchmarkJS, or experiment with different approaches to accessing entities in your own codebase.

Related benchmarks: