Re: Caching where-is-internal

[Stefan Monnier]

> I think the problem was that `where-is-internal` can generate a lot of
> garbage memory.  In Marginalia we have this code:

It would be great if you could track it down further.
Maybe it's simply that the cache ends up flushed between invocations
(in your use case), defeating its purpose.

>     (mapatoms
>      (lambda (sym)
>        (when-let (key (and (commandp sym)
>                            (where-is-internal sym nil t)))
>          (puthash sym key marginalia--annotate-binding-hash)))))

`where-is-internal` has almost exactly this same hash-table internally, so
this basically copies the hash-table (in a somewhat inefficient way).
:-(

> But I cannot tell you much about the exact reasons. It just turned out
> that calling `where-is-internal` once on all symbols was faster than
> calling it occasionally.

I suspect a "spurious cache flush".  Maybe we should export the code
that turns a set of keymaps into a (reversed) hash-table.

> The funny thing here is that the initial (costly?) computation of the
> `marginalia--annotate-binding-hash` does not lead to a noticeable slowdown.

The first call to `where-is-internal` will traverse all the keymaps and
build the hash-table (which doesn't cost much more than just a plain
uncached `where-is-internal`), and the subsequent ones will hit the
hash-table instead.


        Stefan