This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5442

rust-cpython: using the new bindings from Python
ClosedPublic

Authored by gracinet on Dec 15 2018, 6:42 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG536c83535cbd: rust-cpython: using the new bindings from Python
Summary

The Python callers detect if we have cpython or
direct-ffi bindings and fallback to the Python
implementation if none is present.

This intermediate state allows to compare the
three possibilities.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

gracinet created this revision.Dec 15 2018, 6:42 AM
yuja added a subscriber: yuja.Dec 15 2018, 11:46 PM

+try:
+ from . import rustext
+except ImportError:
+ rustext = None

Need to access to e.g. rustext.doc to trigger ImportError here.

yuja added a comment.Dec 23 2018, 11:57 PM

+try:
+ from . import rustext

Touch e.g. rustext.doc here to get around the lazy importer.

gracinet added a comment.Dec 27 2018, 2:49 PM

@yuja about the lazy importer, and just to clarify: so you're saying it's not worth it to delay until rustext is actually used. I'm fine with that, will do it.
I didn't amend that patch yet, but you might have received notifications due to evolve of the whole stack.

gracinet updated this revision to Diff 13008.Jan 4 2019, 1:30 PM
Closed by commit rHG536c83535cbd: rust-cpython: using the new bindings from Python (authored by gracinet). · Explain WhyJan 5 2019, 8:55 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/revlog.py (22 lines)

Diff 13015

mercurial/revlog.py

REVIDX_ELLIPSIS REVIDX_ELLIPSIS
REVIDX_EXTSTORED REVIDX_EXTSTORED
REVIDX_DEFAULT_FLAGS REVIDX_DEFAULT_FLAGS
REVIDX_FLAGS_ORDER REVIDX_FLAGS_ORDER
REVIDX_KNOWN_FLAGS REVIDX_KNOWN_FLAGS
REVIDX_RAWTEXT_CHANGING_FLAGS REVIDX_RAWTEXT_CHANGING_FLAGS
parsers = policy.importmod(r'parsers') parsers = policy.importmod(r'parsers')
try:
from . import rustext
rustext.__name__ # force actual import (see hgdemandimport)
except ImportError:
rustext = None
# Aliased for performance. # Aliased for performance.
_zlibdecompress = zlib.decompress _zlibdecompress = zlib.decompress
# max size of revlog with inline data # max size of revlog with inline data
_maxinline = 131072 _maxinline = 131072
_chunksize = 1048576 _chunksize = 1048576
See the documentation for ancestor.lazyancestors for more details.""" See the documentation for ancestor.lazyancestors for more details."""
# first, make sure start revisions aren't filtered # first, make sure start revisions aren't filtered
revs = list(revs) revs = list(revs)
checkrev = self.node checkrev = self.node
for r in revs: for r in revs:
checkrev(r) checkrev(r)
# and we're sure ancestors aren't filtered as well # and we're sure ancestors aren't filtered as well
if util.safehasattr(parsers, 'rustlazyancestors'):
return ancestor.rustlazyancestors( if rustext is not None:
self.index, revs, lazyancestors = rustext.ancestor.LazyAncestors
stoprev=stoprev, inclusive=inclusive) arg = self.index
return ancestor.lazyancestors(self._uncheckedparentrevs, revs, elif util.safehasattr(parsers, 'rustlazyancestors'):
stoprev=stoprev, inclusive=inclusive) lazyancestors = ancestor.rustlazyancestors
arg = self.index
else:
lazyancestors = ancestor.lazyancestors
arg = self._uncheckedparentrevs
return lazyancestors(arg, revs, stoprev=stoprev, inclusive=inclusive)
def descendants(self, revs): def descendants(self, revs):
return dagop.descendantrevs(revs, self.revs, self.parentrevs) return dagop.descendantrevs(revs, self.revs, self.parentrevs)
def findcommonmissing(self, common=None, heads=None): def findcommonmissing(self, common=None, heads=None):
"""Return a tuple of the ancestors of common and the ancestors of heads """Return a tuple of the ancestors of common and the ancestors of heads
that are not ancestors of common. In revset terminology, we return the that are not ancestors of common. In revset terminology, we return the
tuple: tuple: