Discussion: Memoization solution

As @SamyPesse and I are investigating performances issues, we are having a look at the current memoization implementation.

We have noticed for example that the sole memoization of findDescendantDeep is taking up to 30% of the execution time during normalization calls. Several reasons:

1. findDescendantDeep is recursive, and gets called many times
2. its argument is a function, and we always pass an arrow function to it (unique reference every time), which prevent any cache hit
3. the cache grows indefinitely, and a lot of time is spent looking for cached results in the underlying Immutable.Map with no benefit (the calls to hasIn and setIn account for the mentioned 30%).

Of course, we are going to improve the case of findDescendantDeep (and similarly findDescendant). But this also opens up a new topic: the way we memoize methods. Currently, we use an in-house solution using an Immutable.Map cache. But should we consider using a popular implementation, like memoizee and such? It can bring:

• Better performances
• Cache management, with LRU limits for example

@ianstormtaylor what’s your opinion?

[Soreine]

Tying caches to each Node instance is a good idea, I had not realized that.

For arrows, it’s not that easy. Take for example the case of getDescendant (which is itself memoized). Its implementation is simply return this.findDescendantDeep(node => node.key == key). We can’t make the arrow a static function because we need the key value in the closure.

For now, I will keep the iterator methods unmemoized. And I’ll make sure we have specific memoized methods for cases like this. Continuing on the example of getDescendant, I will rewrite getDescendant to be recursively memoized on its own:

  /**
   * Get a descendant node by `key`.
   *
   * @param {String} key
   * @return {Node or Null} node
   */

  getDescendant(key) {
    key = Normalize.key(key)
    return this._getDescendant(key)
  },

  // This one is memoized
  _getDescendant(key) {
    let descendantFound = null

    const found = this.nodes.find(node => {
      if (node.key === key) {
        return node
      } else if (node.kind !== 'text') {
        descendantFound = node._getDescendant(key)
        return descendantFound
      } else {
        return false
      }
    })

    return descendantFound || found
  }

[ianstormtaylor]

Closing, since I think we came to a solution here.