MeasureThat.net

 Fib Now2 (version: 0)

Comparing performance of: Fib Base vs Fib memoized 1 vs Fib memoized Tommy vs Fib fast-memoize

Created: 5 years ago by: Guest
Jump to the latest result
HTML Preparation code:
AخA
 
1
<script src="https://www.jsdelivr.com/package/npm/memoizee"></script>
Tests:

  • Fib Base

    ​x
     
    const fibonacci = (n) => {
        if (n <= 1) return 1;
        return fibonacci(n - 1) + fibonacci(n - 2);
    };
    ​
    fibonacci(20);
    ​

  • Fib memoized 1

     
    const memoize = function(func) {
        var stringifyJson = JSON.stringify,
            cache = {};
    ​
        var cachedfun = function() {
            var hash = stringifyJson(arguments);
            return hash in cache ? cache[hash] : (cache[hash] = func.apply(this, arguments));
        };
    ​
        cachedfun.__cache = function() {
            cache.remove ||
                (cache.remove = function() {
                    var hash = stringifyJson(arguments);
                    return delete cache[hash];
                });
            return cache;
        }.call(this);
    ​
        return cachedfun;
    };
    ​
    const fibonacci = memoize((n) => {
        if (n <= 1) return 1;
        return fibonacci(n - 1) + fibonacci(n - 2);
    });
    ​
    fibonacci(20);
    ​

  • Fib memoized Tommy

     
    const memoize = function(func) {
        const cache= {}
        return (...args) => {
          const n = args[0]
          if (n in cache) {
            return cache[n];
          } else {
            const result = func(n)
            cache[n] = result
            return result
          }
        }
    };
    ​
    const fibonacci = memoize((n) => {
        if (n <= 1) return 1;
        return fibonacci(n - 1) + fibonacci(n - 2);
    });
    ​
    fibonacci(20);
    ​

  • Fib fast-memoize

     
    //
    // Main
    //
    ​
    function memoize (fn, options) {
      var cache = options && options.cache
        ? options.cache
        : cacheDefault
    ​
      var serializer = options && options.serializer
        ? options.serializer
        : serializerDefault
    ​
      var strategy = options && options.strategy
        ? options.strategy
        : strategyDefault
    ​
      return strategy(fn, {
        cache: cache,
        serializer: serializer
      })
    }
    ​
    //
    // Strategy
    //
    ​
    function isPrimitive (value) {
      return value == null || typeof value === 'number' || typeof value === 'boolean' // || typeof value === "string" 'unsafe' primitive for our needs
    }
    ​
    function monadic (fn, cache, serializer, arg) {
      var cacheKey = isPrimitive(arg) ? arg : serializer(arg)
    ​
      var computedValue = cache.get(cacheKey)
      if (typeof computedValue === 'undefined') {
        computedValue = fn.call(this, arg)
        cache.set(cacheKey, computedValue)
      }
    ​
      return computedValue
    }
    ​
    function variadic (fn, cache, serializer) {
      var args = Array.prototype.slice.call(arguments, 3)
      var cacheKey = serializer(args)
    ​
      var computedValue = cache.get(cacheKey)
      if (typeof computedValue === 'undefined') {
        computedValue = fn.apply(this, args)
        cache.set(cacheKey, computedValue)
      }
    ​
      return computedValue
    }
    ​
    function assemble (fn, context, strategy, cache, serialize) {
      return strategy.bind(
        context,
        fn,
        cache,
        serialize
      )
    }
    ​
    function strategyDefault (fn, options) {
      var strategy = fn.length === 1 ? monadic : variadic
    ​
      return assemble(
        fn,
        this,
        strategy,
        options.cache.create(),
        options.serializer
      )
    }
    ​
    function strategyVariadic (fn, options) {
      var strategy = variadic
    ​
      return assemble(
        fn,
        this,
        strategy,
        options.cache.create(),
        options.serializer
      )
    }
    ​
    function strategyMonadic (fn, options) {
      var strategy = monadic
    ​
      return assemble(
        fn,
        this,
        strategy,
        options.cache.create(),
        options.serializer
      )
    }
    ​
    //
    // Serializer
    //
    ​
    function serializerDefault () {
      return JSON.stringify(arguments)
    }
    ​
    //
    // Cache
    //
    ​
    function ObjectWithoutPrototypeCache () {
      this.cache = Object.create(null)
    }
    ​
    ObjectWithoutPrototypeCache.prototype.has = function (key) {
      return (key in this.cache)
    }
    ​
    ObjectWithoutPrototypeCache.prototype.get = function (key) {
      return this.cache[key]
    }
    ​
    ObjectWithoutPrototypeCache.prototype.set = function (key, value) {
      this.cache[key] = value
    }
    ​
    var cacheDefault = {
      create: function create () {
        return new ObjectWithoutPrototypeCache()
      }
    }
    ​
    ​
    const fibonacci = memoize((n) => {
        if (n <= 1) return 1;
        return fibonacci(n - 1) + fibonacci(n - 2);
    });
    ​
    fibonacci(20);
    ​
Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

  • Test case name Result
    Fib Base
    Fib memoized 1
    Fib memoized Tommy
    Fib fast-memoize

    Fastest: N/A

    Slowest: N/A

Latest run results:
Run details: (Test run date: 5 years ago)
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.87 Safari/537.36
Chrome 78 on Mac OS X 10.14.5
View result in a separate tab
Test name Executions per second
Fib Base 8871.8 Ops/sec
Fib memoized 1 48123.4 Ops/sec
Fib memoized Tommy 685801.1 Ops/sec
Fib fast-memoize 110624.3 Ops/sec
LLMs can make mistakes. Check important info.
Related benchmarks: