mercurial/unionrepo.py

hgdemandimport: apply lazy module loading to sys.meta_path finders

Python's `sys.meta_path` finders are the primary objects whose job it
is to find a module at import time. When `import` is called, Python
iterates objects in this list and calls `o.find_spec(...)` to find
a `ModuleSpec` (or None if the module couldn't be found by that
finder). If no meta path finder can find a module, import fails.

One of the default meta path finders is `PathFinder`. Its job is to
import modules from the filesystem and is probably the most important
importer. This finder looks at `sys.path` and `sys.path_hooks` to do
its job.

The `ModuleSpec` returned by `MetaPathImporter.find_spec()` has a
`loader` attribute, which defines the concrete module loader to use.
`sys.path_hooks` is a hook point for teaching `PathFinder` to
instantiate custom loader types.

Previously, we injected a custom `sys.path_hook` that told `PathFinder`
to wrap the default loaders with a loader that creates a module object
that is lazy.

This approach worked. But its main limitation was that it only applied
to the `PathFinder` meta path importer. There are other meta path
importers that are registered. And in the case of PyOxidizer loading
modules from memory, `PathFinder` doesn't come into play since
PyOxidizer's own meta path importer was handling all imports.

This commit changes our approach to lazy module loading by proxying
all meta path importers. Specifically, we overload the `find_spec()`
method to swap in a wrapped loader on the `ModuleSpec` before it
is returned. The end result of this is all meta path importers should
be lazy.

As much as I would have loved to utilize .__class__ manipulation to
achieve this, some meta path importers are implemented in C/Rust
in such a way that they cannot be monkeypatched. This is why we
use __getattribute__ to define a proxy.

Also, this change could theoretically open us up to regressions in
meta path importers whose loader is creating module objects which
can't be monkeypatched. But I'm not aware of any of these in the
wild. So I think we'll be safe.

According to hyperfine, this change yields a decent startup time win of
5-6ms:

```
Benchmark #1: ~/.pyenv/versions/3.6.10/bin/python ./hg version
  Time (mean ± σ):      86.8 ms ±   0.5 ms    [User: 78.0 ms, System: 8.7 ms]
  Range (min … max):    86.0 ms …  89.1 ms    50 runs

  Time (mean ± σ):      81.1 ms ±   2.7 ms    [User: 74.5 ms, System: 6.5 ms]
  Range (min … max):    77.8 ms …  90.5 ms    50 runs

Benchmark #2: ~/.pyenv/versions/3.7.6/bin/python ./hg version
  Time (mean ± σ):      78.9 ms ±   0.6 ms    [User: 70.2 ms, System: 8.7 ms]
  Range (min … max):    78.1 ms …  81.2 ms    50 runs

  Time (mean ± σ):      73.4 ms ±   0.6 ms    [User: 65.3 ms, System: 8.0 ms]
  Range (min … max):    72.4 ms …  75.7 ms    50 runs

Benchmark #3: ~/.pyenv/versions/3.8.1/bin/python ./hg version
  Time (mean ± σ):      78.1 ms ±   0.6 ms    [User: 70.2 ms, System: 7.9 ms]
  Range (min … max):    77.4 ms …  80.9 ms    50 runs

  Time (mean ± σ):      72.1 ms ±   0.4 ms    [User: 64.4 ms, System: 7.6 ms]
  Range (min … max):    71.4 ms …  74.1 ms    50 runs
```

Differential Revision: https://phab.mercurial-scm.org/D7954

# unionrepo.py - repository class for viewing union of repository changesets
#
# Derived from bundlerepo.py
# Copyright 2006, 2007 Benoit Boissinot <[e-mail]>
# Copyright 2013 Unity Technologies, Mads Kiilerich <[e-mail]>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.

"""Repository class for "in-memory pull" of one local repository to another,
allowing operations like diff and log with revsets.
"""

from __future__ import absolute_import

from .i18n import _
from .pycompat import getattr

from . import (
    changelog,
    cmdutil,
    encoding,
    error,
    filelog,
    localrepo,
    manifest,
    mdiff,
    pathutil,
    revlog,
    util,
    vfs as vfsmod,
)


class unionrevlog(revlog.revlog):
    def __init__(self, opener, indexfile, revlog2, linkmapper):
        # How it works:
        # To retrieve a revision, we just need to know the node id so we can
        # look it up in revlog2.
        #
        # To differentiate a rev in the second revlog from a rev in the revlog,
        # we check revision against repotiprev.
        opener = vfsmod.readonlyvfs(opener)
        revlog.revlog.__init__(self, opener, indexfile)
        self.revlog2 = revlog2

        n = len(self)
        self.repotiprev = n - 1
        self.bundlerevs = set()  # used by 'bundle()' revset expression
        for rev2 in self.revlog2:
            rev = self.revlog2.index[rev2]
            # rev numbers - in revlog2, very different from self.rev
            _start, _csize, rsize, base, linkrev, p1rev, p2rev, node = rev
            flags = _start & 0xFFFF

            if linkmapper is None:  # link is to same revlog
                assert linkrev == rev2  # we never link back
                link = n
            else:  # rev must be mapped from repo2 cl to unified cl by linkmapper
                link = linkmapper(linkrev)

            if linkmapper is not None:  # link is to same revlog
                base = linkmapper(base)

            this_rev = self.index.get_rev(node)
            if this_rev is not None:
                # this happens for the common revlog revisions
                self.bundlerevs.add(this_rev)
                continue

            p1node = self.revlog2.node(p1rev)
            p2node = self.revlog2.node(p2rev)

            # TODO: it's probably wrong to set compressed length to None, but
            # I have no idea if csize is valid in the base revlog context.
            e = (
                flags,
                None,
                rsize,
                base,
                link,
                self.rev(p1node),
                self.rev(p2node),
                node,
            )
            self.index.append(e)
            self.bundlerevs.add(n)
            n += 1

    def _chunk(self, rev):
        if rev <= self.repotiprev:
            return revlog.revlog._chunk(self, rev)
        return self.revlog2._chunk(self.node(rev))

    def revdiff(self, rev1, rev2):
        """return or calculate a delta between two revisions"""
        if rev1 > self.repotiprev and rev2 > self.repotiprev:
            return self.revlog2.revdiff(
                self.revlog2.rev(self.node(rev1)),
                self.revlog2.rev(self.node(rev2)),
            )
        elif rev1 <= self.repotiprev and rev2 <= self.repotiprev:
            return super(unionrevlog, self).revdiff(rev1, rev2)

        return mdiff.textdiff(self.rawdata(rev1), self.rawdata(rev2))

    def _revisiondata(self, nodeorrev, _df=None, raw=False):
        if isinstance(nodeorrev, int):
            rev = nodeorrev
            node = self.node(rev)
        else:
            node = nodeorrev
            rev = self.rev(node)

        if rev > self.repotiprev:
            # work around manifestrevlog NOT being a revlog
            revlog2 = getattr(self.revlog2, '_revlog', self.revlog2)
            func = revlog2._revisiondata
        else:
            func = super(unionrevlog, self)._revisiondata
        return func(node, _df=_df, raw=raw)

    def addrevision(self, text, transaction, link, p1=None, p2=None, d=None):
        raise NotImplementedError

    def addgroup(
        self,
        deltas,
        linkmapper,
        transaction,
        addrevisioncb=None,
        maybemissingparents=False,
    ):
        raise NotImplementedError

    def strip(self, minlink, transaction):
        raise NotImplementedError

    def checksize(self):
        raise NotImplementedError


class unionchangelog(unionrevlog, changelog.changelog):
    def __init__(self, opener, opener2):
        changelog.changelog.__init__(self, opener)
        linkmapper = None
        changelog2 = changelog.changelog(opener2)
        unionrevlog.__init__(
            self, opener, self.indexfile, changelog2, linkmapper
        )


class unionmanifest(unionrevlog, manifest.manifestrevlog):
    def __init__(self, opener, opener2, linkmapper):
        manifest.manifestrevlog.__init__(self, opener)
        manifest2 = manifest.manifestrevlog(opener2)
        unionrevlog.__init__(
            self, opener, self.indexfile, manifest2, linkmapper
        )


class unionfilelog(filelog.filelog):
    def __init__(self, opener, path, opener2, linkmapper, repo):
        filelog.filelog.__init__(self, opener, path)
        filelog2 = filelog.filelog(opener2, path)
        self._revlog = unionrevlog(
            opener, self.indexfile, filelog2._revlog, linkmapper
        )
        self._repo = repo
        self.repotiprev = self._revlog.repotiprev
        self.revlog2 = self._revlog.revlog2

    def iscensored(self, rev):
        """Check if a revision is censored."""
        if rev <= self.repotiprev:
            return filelog.filelog.iscensored(self, rev)
        node = self.node(rev)
        return self.revlog2.iscensored(self.revlog2.rev(node))


class unionpeer(localrepo.localpeer):
    def canpush(self):
        return False


class unionrepository(object):
    """Represents the union of data in 2 repositories.

    Instances are not usable if constructed directly. Use ``instance()``
    or ``makeunionrepository()`` to create a usable instance.
    """

    def __init__(self, repo2, url):
        self.repo2 = repo2
        self._url = url

        self.ui.setconfig(b'phases', b'publish', False, b'unionrepo')

    @localrepo.unfilteredpropertycache
    def changelog(self):
        return unionchangelog(self.svfs, self.repo2.svfs)

    @localrepo.unfilteredpropertycache
    def manifestlog(self):
        rootstore = unionmanifest(
            self.svfs, self.repo2.svfs, self.unfiltered()._clrev
        )
        return manifest.manifestlog(
            self.svfs, self, rootstore, self.narrowmatch()
        )

    def _clrev(self, rev2):
        """map from repo2 changelog rev to temporary rev in self.changelog"""
        node = self.repo2.changelog.node(rev2)
        return self.changelog.rev(node)

    def url(self):
        return self._url

    def file(self, f):
        return unionfilelog(
            self.svfs, f, self.repo2.svfs, self.unfiltered()._clrev, self
        )

    def close(self):
        self.repo2.close()

    def cancopy(self):
        return False

    def peer(self):
        return unionpeer(self)

    def getcwd(self):
        return encoding.getcwd()  # always outside the repo


def instance(ui, path, create, intents=None, createopts=None):
    if create:
        raise error.Abort(_(b'cannot create new union repository'))
    parentpath = ui.config(b"bundle", b"mainreporoot")
    if not parentpath:
        # try to find the correct path to the working directory repo
        parentpath = cmdutil.findrepo(encoding.getcwd())
        if parentpath is None:
            parentpath = b''
    if parentpath:
        # Try to make the full path relative so we get a nice, short URL.
        # In particular, we don't want temp dir names in test outputs.
        cwd = encoding.getcwd()
        if parentpath == cwd:
            parentpath = b''
        else:
            cwd = pathutil.normasprefix(cwd)
            if parentpath.startswith(cwd):
                parentpath = parentpath[len(cwd) :]
    if path.startswith(b'union:'):
        s = path.split(b":", 1)[1].split(b"+", 1)
        if len(s) == 1:
            repopath, repopath2 = parentpath, s[0]
        else:
            repopath, repopath2 = s
    else:
        repopath, repopath2 = parentpath, path

    return makeunionrepository(ui, repopath, repopath2)


def makeunionrepository(ui, repopath1, repopath2):
    """Make a union repository object from 2 local repo paths."""
    repo1 = localrepo.instance(ui, repopath1, create=False)
    repo2 = localrepo.instance(ui, repopath2, create=False)

    url = b'union:%s+%s' % (
        util.expandpath(repopath1),
        util.expandpath(repopath2),
    )

    class derivedunionrepository(unionrepository, repo1.__class__):
        pass

    repo = repo1
    repo.__class__ = derivedunionrepository
    unionrepository.__init__(repo1, repo2, url)

    return repo