Benchmark: Reselect defaultMemoize

Script Preparation code:

function defaultEqualityCheck(a, b) {
  return a === b
}

function defaultMemoize_original(func, equalityCheck = defaultEqualityCheck) {
  let lastArgs = null
  let lastResult = null
  return (...args) => {
    if (
      lastArgs === null ||
      lastArgs.length !== args.length ||
      !args.every((value, index) => equalityCheck(value, lastArgs[index]))
    ) {
      lastResult = func(...args)
    }
    lastArgs = args
    return lastResult
  }
}

function defaultMemoize_optimized(func, equalityCheck = defaultEqualityCheck) {
  const isEqual = (value, index) => equalityCheck(value, lastArgs[index])
  let lastArgs = null
  let lastResult = null
  return (...args) => {
    if (
      lastArgs === null ||
      lastArgs.length !== args.length ||
      !args.every(isEqual)
    ) {
      lastResult = func(...args)
    }
    lastArgs = args
    return lastResult
  }
}

function combine(a, b) {
  return { combined: a + b };
}

var combine_original = defaultMemoize_original(combine);
var combine_optimized = defaultMemoize_optimized(combine);

var NUM_REPEAT = 50000;

​x
 
function defaultEqualityCheck(a, b) {  return a === b}​function defaultMemoize_original(func, equalityCheck = defaultEqualityCheck) {  let lastArgs = null  let lastResult = null  return (...args) => {    if (      lastArgs === null ||      lastArgs.length !== args.length ||      !args.every((value, index) => equalityCheck(value, lastArgs[index]))    ) {      lastResult = func(...args)    }    lastArgs = args    return lastResult  }}​function defaultMemoize_optimized(func, equalityCheck = defaultEqualityCheck) {  const isEqual = (value, index) => equalityCheck(value, lastArgs[index])  let lastArgs = null  let lastResult = null  return (...args) => {    if (      lastArgs === null ||      lastArgs.length !== args.length ||      !args.every(isEqual)    ) {      lastResult = func(...args)    }    lastArgs = args    return lastResult  }}​function combine(a, b) {  return { combined: a + b };}​var combine_original = defaultMemoize_original(combine);var combine_optimized = defaultMemoize_optimized(combine);​var NUM_REPEAT = 50000;

Tests:

Original defaultMemoize
let result1 = 0; for (let i = 0; i < NUM_REPEAT; ++i) result1 += combine_original(1, 2).combined;
let result1 = 0;
for (let i = 0; i < NUM_REPEAT; ++i)
result1 += combine_original(1, 2).combined;
Optimized defaultMemoize
let result2 = 0; for (let i = 0; i < NUM_REPEAT; ++i) result2 += combine_optimized(1, 2).combined;
let result2 = 0;
for (let i = 0; i < NUM_REPEAT; ++i)
result2 += combine_optimized(1, 2).combined;

No memoization

let result3 = 0;
for (let i = 0; i < NUM_REPEAT; ++i) 
  result3 += combine(1, 2).combined;

 
let result3 = 0;for (let i = 0; i < NUM_REPEAT; ++i)   result3 += combine(1, 2).combined;

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
Original defaultMemoize
Optimized defaultMemoize
No memoization

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 121 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Original defaultMemoize	284.4 Ops/sec
Optimized defaultMemoize	292.6 Ops/sec
No memoization	321.6 Ops/sec

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

Let's break down what's being tested in this benchmark.

The test cases are designed to compare the performance of three different versions of a memoization function, which is a technique used to optimize repetitive computations by caching their results.

Memoization basics

In this context, memoization is a technique where the result of an expensive computation (in this case, a simple addition) is cached and reused when the same inputs occur again. This avoids redundant calculations, reducing the overall execution time.

The benchmark defines three different versions of a defaultMemoize function:

Original defaultMemoize: This version uses a simple approach to memoization, where it checks if the arguments are the same as in the previous call and returns the cached result if they are.
Optimized defaultMemoize: This version is optimized for performance by using a constant function isEqual that compares values at specific indices (in this case, the first value). It still uses the same basic approach to memoization but with some optimizations.

Test cases

There are three test cases:

Original defaultMemoize: This test case runs a simple addition operation (combine(1, 2)) repeated NUM_REPEAT times and measures the execution time.
Optimized defaultMemoize: Similar to the first test case, but uses the optimized version of defaultMemoize.
No memoization: This test case also runs the same simple addition operation repeatedly, without any memoization.

Pros and cons

Here are some pros and cons of each approach:

Original defaultMemoize:
- Pros: Easy to implement and understand.
- Cons: May have higher execution time due to repeated checks for equality.
Optimized defaultMemoize:
- Pros: Optimized performance with fewer checks for equality.
- Cons: Requires a separate constant function isEqual which may add complexity.

Other considerations:

The test cases use a simple addition operation (combine(1, 2)) to demonstrate the memoization technique. In real-world scenarios, this might not be as representative of actual usage.
The benchmark runs on Chrome 121 on a Mac with Intel CPU, which may affect the results due to differences in hardware and browser performance.

Alternatives

If you were to modify or extend these benchmarks, some alternatives to consider:

Use different types of computations (e.g., more complex functions, loops, or data structures).
Experiment with different browsers, operating systems, or devices.
Add more test cases to cover various edge cases or scenarios.
Investigate other optimization techniques for memoization, such as using a cache map or a library like lru-cache.

These considerations can help refine the benchmark and provide a more comprehensive understanding of the performance differences between these memoization approaches.

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

The test cases are designed to compare the performance of three different versions of a memoization function, which is a technique used to optimize repetitive computations by caching their results.

**Memoization basics**

The benchmark defines three different versions of a `defaultMemoize` function:

1. **Original defaultMemoize**: This version uses a simple approach to memoization, where it checks if the arguments are the same as in the previous call and returns the cached result if they are.
2. **Optimized defaultMemoize**: This version is optimized for performance by using a constant function `isEqual` that compares values at specific indices (in this case, the first value). It still uses the same basic approach to memoization but with some optimizations.

**Test cases**

There are three test cases:

1. **Original defaultMemoize**: This test case runs a simple addition operation (`combine(1, 2)`) repeated `NUM_REPEAT` times and measures the execution time.
2. **Optimized defaultMemoize**: Similar to the first test case, but uses the optimized version of `defaultMemoize`.
3. **No memoization**: This test case also runs the same simple addition operation repeatedly, without any memoization.

**Pros and cons**

Here are some pros and cons of each approach:

* **Original defaultMemoize**:
	+ Pros: Easy to implement and understand.
	+ Cons: May have higher execution time due to repeated checks for equality.
* **Optimized defaultMemoize**:
	+ Pros: Optimized performance with fewer checks for equality.
	+ Cons: Requires a separate constant function `isEqual` which may add complexity.

Other considerations:

* The test cases use a simple addition operation (`combine(1, 2)`) to demonstrate the memoization technique. In real-world scenarios, this might not be as representative of actual usage.
* The benchmark runs on Chrome 121 on a Mac with Intel CPU, which may affect the results due to differences in hardware and browser performance.

**Alternatives**

If you were to modify or extend these benchmarks, some alternatives to consider:

* Use different types of computations (e.g., more complex functions, loops, or data structures).
* Experiment with different browsers, operating systems, or devices.
* Add more test cases to cover various edge cases or scenarios.
* Investigate other optimization techniques for memoization, such as using a cache map or a library like `lru-cache`.

These considerations can help refine the benchmark and provide a more comprehensive understanding of the performance differences between these memoization approaches.

Related benchmarks:

Reselect defaultMemoize (version: 9)

Comparing performance of: Original defaultMemoize vs Optimized defaultMemoize vs No memoization

Created: 8 years ago by: Registered User

Jump to the latest result

Original defaultMemoize

Optimized defaultMemoize