sonic-memoize

Ultra fast, zero config memoization of functions.

npm install sonic-memoize

Usage

import memoize from "sonic-memoize";

const memoized = memoize(function (arg1, arg2, arg3) {
  // expensive computation here
});

memoized(3, 4, 5); // First call with these arguments is expensive
memoized(3, 4, 5); // Cache hit, the value was returned instantly

sonic-memoize is zero config and will memoize your function calls out of the box without limitation on how many calls with different arguments will be cached. If you need to set a max size on the cache that is being used by sonic-memoize, see the section on setting a size limit on the cache

Benchmarks

We implemented benchmarking with realistic test cases that should give you a good impression on how well the memoization will perform in real life situations.

Benchmarking memoization with one function parameter without Cache size limit:

Results for function with single parameter of type string:

Task Name	Average Time (ps)
sonic-memoize	8.5
mem	11.2
lodash.memoize	22.2
nano-memoize	43.8
fast-memoize	279.3
memoizee	410.5

Results for function with single parameter of type number:

Task Name	Average Time (ps)
nano-memoize	4.4
sonic-memoize	4.4
fast-memoize	4.7
mem	5.1
lodash.memoize	29.3
memoizee	385.3

Results for function with single non primitive parameter:

Task Name	Average Time (ps)
sonic-memoize	4.4
mem	6.7
lodash.memoize	19.6
nano-memoize	40.2
memoizee	193.7
fast-memoize	372.1

The benchmarks were being run on sample sets of 1000 different arguments repeatedly. That makes for a realistic scenario.
benchmarking code

Benchmarking memoization with multiple function parameters without Cache size limit:

Results for function with multiple primitive parameters:

Task Name	Average Time (ps)
sonic-memoize	41.0
memoizee	84.5
fast-memoize	464.5
nano-memoize	1550.5

Results for function with multiple non primitive parameters:

Task Name	Average Time (ps)
sonic-memoize	46.2
memoizee	242.6
fast-memoize	788.2
nano-memoize	3049.0

The benchmarks were being run on sample sets of 1000 different arguments repeatedly. That makes for a realistic scenario. We excluded memoization libraries that cannot memoize functions with multiple arguments at all or without further configuration.
benchmarking code

Setting a size limit on the cache

You can use sonic-memoize with the option of limiting the internal cache size to a specific number of cached results. sonic-memoize will use an LRU caching strategy, which means that the least recently used function call will be deleted from the cache if the max size is reached. Note that limiting the size of the cache comes at a (small) performance cost and is probably unnecessary if you dont have tough memory usage restrictions or call your memoized functions with many millions of different arguments.

import { memoizeWithLimit } from "sonic-memoize";

const memoized = memoizeWithLimit(function (arg1, arg2, arg3) {
  // expensive computation here
}, 50000); // The second argument (50000 in this case) specifies the cache size limit

// After 50000 calls with different arguments sonic-memoize will start
// deleting the least recently used function call from cache

memoized(3, 4, 5); // First call with these arguments is expensive
memoized(3, 4, 5); // Cache hit, the value was returned instantly

Benchmarks on LRU memoization

See below benchmarks with different memoization libraries that use LRU caching strategies.

Benchmarking memoization with one function parameter with LRU Cache size limit:

Results for function with single parameter of type string:

Task Name	Average Time (ps)
sonic-memoize (lru)	30.1
memoizerific	1236.1
memoizee (lru)	1754.9
moize	7598.9
micro	8030.6

Results for function with single parameter of type number:

Task Name	Average Time (ps)
sonic-memoize (lru)	16.0
memoizee (lru)	692.3
memoizerific	1257.8
moize	4978.3
micro	8117.5

Results for function with single non primitive parameter:

Task Name	Average Time (ps)
sonic-memoize (lru)	16.0
memoizee (lru)	501.6
memoizerific	1172.7
micro	8872.3
moize	8897.8

The benchmarks were being run on sample sets of 1000 different arguments repeatedly, while the size limits of the caches were set to 1000 as well. That makes for a realistic scenario in which the cache size is big enough to handle most function calls.
benchmarking code

Benchmarking memoization with multiple function parameters with LRU Cache size limit:

Results for function with multiple primitive parameters:

Task Name	Average Time (ps)
sonic-memoize (lru)	51.5
memoizee (lru)	419.2
memoizerific	1129.6
moize	6083.2
micro	10822.4

Results for function with multiple non primitive parameters:

Task Name	Average Time (ps)
sonic-memoize (lru)	56.2
memoizee (lru)	563.9
memoizerific	1122.1
micro	9310.0
moize	9521.1

The benchmarks were being run on sample sets of 1000 different arguments repeatedly, while the size limits of the caches were set to 1000 as well. That makes for a realistic scenario in which the cache size is big enough to handle most function calls.
benchmarking code

License

MIT