( )⚙ D1606 phases: drop the list with phase of each rev, always comput phase sets

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1606

phases: drop the list with phase of each rev, always comput phase sets
ClosedPublic

Authored by joerg.sonnenberger on Dec 6 2017, 9:47 AM.

Details

Reviewers
quark
yuja
Group Reviewers
hg-reviewers
Commits
rHGd13526333835: phases: drop the list with phase of each rev, always comput phase sets
Summary

Change the C implementation of phasecache.loadphaserevs to provide only
the sets for draft and secret phase as well as the number of revisions
seen.

Change the pure Python implementation of the same functino to compute
the sets instead of the list of phases for each revision.

Change phasecache.phase to check the phase sets and assume public if the
revision is in neither draft nor secret set. This is computationally
slightly more expensive.

Change phasecache.getrevset for public() based queries to compute the
set of non-matching revisions and return the result as filtered
fullreposet. A shortcut is taken when no draft or secret revision
exists.

Bump the module version for the changed interface contract.

Overall, this saves around 16 Bytes per revision whenever the phasecache
is used, for the test case in issue5691 it is around 3MB. getrevset()
for a large repository is around 13% slower here, that seems an
acceptable trade off. Performance impact for phase() should be similar.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

quark requested changes to this revision.EditedDec 6 2017, 9:02 PM
quark added a subscriber: quark.

I have been also wanting to remove this O(changelog) space usage for long. I noticed phasecache was the biggest memory consumer among all repo. components (dirstate, changelog, etc) when prototyping stateful chg early this year. So I'm excited about this change.

Requesting changes mainly because the if public in phases branch in getrevset has issues. Otherwise it looks good to me.

mercurial/cext/revlog.c
627

I guess the map here means a rev -> phase map, which was the list. Since we now return len(size). Maybe rename the function to compute_phases_len_sets.

1965

Also here, computephaseslensets

mercurial/phases.py
226

The assert is incorrect - repo could be "filtered". The old code support filtered repo implicitly by using for r in repo, the iterator of repo will remove filtered revisions.

226–237

Sorry - I made a mistake using repo.revs('public()') to test the logic here. Actually that exercises a different code path.

There are practically no users exercising this public in phases code path. So issues like fullreposet requires a repo argument is not exposed.

I think we can either:

  • Pass an optional subset here then replace the revset implementation to use it:
def getrevset(self, repo, phases, subset=None):
    if subset is None:
        subset = smartset.fullreposet(repo)
    if ...
        # fast path
        ...
        return subset & smartset.baseset(revs)
    else:
        ...
  • Remove support for calculating public() here by just raise error.ProgrammingError('public() is unsupported')

I guess the former is preferred eventually. But if you want to land this faster, the latter is easier. I can help writing a follow-up.

This revision now requires changes to proceed.Dec 6 2017, 9:02 PM
durin42 added a subscriber: durin42.Dec 6 2017, 9:24 PM
joerg.sonnenberger added inline comments.Dec 7 2017, 10:38 AM
mercurial/phases.py
226–237

I think this can just follow the logic of the other branch, i.e. short cut if len(phases) == 1 and repo.changelog.filteredrevs, otherwise, add repo.changelog.filteredrevs to the union as well.
I added the assert to make sure that the check wasn't necessary, missed the implicit dependency on repo here.

quark added inline comments.Dec 7 2017, 3:43 PM
mercurial/phases.py
226–237

Agree. The only real difference with revset.py:public is the subset argument.

quark accepted this revision.Dec 7 2017, 10:00 PM

I think this is good enough. We can migrate revset.py public() implementation later.

yuja accepted this revision.Dec 8 2017, 9:54 AM
yuja added a subscriber: yuja.

Queued, thanks. Can you send follow-up patches to address trivial issues?

mercurial/cext/revlog.c
692

Removed unused variable in flight.

mercurial/phases.py
205

Nit: this isn't the "max" revision, but the size. Perhaps the initial
value should be 0.

236

Nit: could be written as fullrepoest(repo) - baseset(revs).

265–280

Nice, no dependency on repo. As a follow-up, maybe we
can extract a pure function as truly drop-in replacement for
the native function.

267

s/map/pycompat.maplist/ for Python 3 compatibility. Fixed in flight.

296

s/_phaserevs/_phasesets/. Fixed in flight.

This revision is now accepted and ready to land.Dec 8 2017, 9:54 AM
Closed by commit rHGd13526333835: phases: drop the list with phase of each rev, always comput phase sets (authored by joerg.sonnenberger). · Explain WhyDec 8 2017, 10:28 AM
This revision was automatically updated to reflect the committed changes.
quark added inline comments.Dec 8 2017, 5:57 PM
mercurial/phases.py
236

baseset.__contains__ is slower than set.__contains__ so the current code is faster.

yuja added inline comments.Dec 8 2017, 7:58 PM
mercurial/phases.py
236

Really? It's aliased to self._set.__contains__.

Revision Contents
Changeset List

Diff 4155

mercurial/cext/parsers.c

{"fm1readmarkers", fm1readmarkers, METH_VARARGS, {"fm1readmarkers", fm1readmarkers, METH_VARARGS,
"parse v1 obsolete markers\n"}, "parse v1 obsolete markers\n"},
{NULL, NULL}}; {NULL, NULL}};
void dirs_module_init(PyObject *mod); void dirs_module_init(PyObject *mod);
void manifest_module_init(PyObject *mod); void manifest_module_init(PyObject *mod);
void revlog_module_init(PyObject *mod); void revlog_module_init(PyObject *mod);
static const int version = 3; static const int version = 4;
static void module_init(PyObject *mod) static void module_init(PyObject *mod)
{ {
PyModule_AddIntConstant(mod, "version", version); PyModule_AddIntConstant(mod, "version", version);
/* This module constant has two purposes. First, it lets us unit test /* This module constant has two purposes. First, it lets us unit test
* the ImportError raised without hard-coding any error text. This * the ImportError raised without hard-coding any error text. This
* means we can change the text in the future without breaking tests, * means we can change the text in the future without breaking tests,

mercurial/cext/revlog.c

return reachable; return reachable;
bail: bail:
Py_XDECREF(reachable); Py_XDECREF(reachable);
free(revstates); free(revstates);
free(tovisit); free(tovisit);
return NULL; return NULL;
} }
static PyObject *compute_phases_map_sets(indexObject *self, PyObject *args) static PyObject *compute_phases_map_sets(indexObject *self, PyObject *args)
quarkUnsubmitted
Not Done

I guess the map here means a rev -> phase map, which was the list. Since we now return len(size). Maybe rename the function to compute_phases_len_sets.

quark: I guess the `map` here means a `rev` -> `phase` map, which was the list. Since we now return…
{ {
PyObject *roots = Py_None; PyObject *roots = Py_None;
PyObject *ret = NULL; PyObject *ret = NULL;
PyObject *phaseslist = NULL; PyObject *phasessize = NULL;
PyObject *phaseroots = NULL; PyObject *phaseroots = NULL;
PyObject *phaseset = NULL; PyObject *phaseset = NULL;
PyObject *phasessetlist = NULL; PyObject *phasessetlist = NULL;
PyObject *rev = NULL; PyObject *rev = NULL;
Py_ssize_t len = index_length(self) - 1; Py_ssize_t len = index_length(self) - 1;
Py_ssize_t numphase = 0; Py_ssize_t numphase = 0;
Py_ssize_t minrevallphases = 0; Py_ssize_t minrevallphases = 0;
Py_ssize_t minrevphase = 0; Py_ssize_t minrevphase = 0;
for (i = minrevallphases; i < len; i++) { for (i = minrevallphases; i < len; i++) {
if (index_get_parents(self, i, parents, if (index_get_parents(self, i, parents,
(int)len - 1) < 0) (int)len - 1) < 0)
goto release; goto release;
set_phase_from_parents(phases, parents[0], parents[1], i); set_phase_from_parents(phases, parents[0], parents[1], i);
} }
} }
/* Transform phase list to a python list */ /* Transform phase list to a python list */
phaseslist = PyList_New(len); phasessize = PyInt_FromLong(len);
if (phaseslist == NULL) if (phasessize == NULL)
goto release; goto release;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
PyObject *phaseval; PyObject *phaseval;
yujaUnsubmitted
Not Done

Removed unused variable in flight.

yuja: Removed unused variable in flight.
phase = phases[i]; phase = phases[i];
/* We only store the sets of phase for non public phase, the public phase /* We only store the sets of phase for non public phase, the public phase
* is computed as a difference */ * is computed as a difference */
if (phase != 0) { if (phase != 0) {
phaseset = PyList_GET_ITEM(phasessetlist, phase); phaseset = PyList_GET_ITEM(phasessetlist, phase);
rev = PyInt_FromLong(i); rev = PyInt_FromLong(i);
if (rev == NULL) if (rev == NULL)
goto release; goto release;
PySet_Add(phaseset, rev); PySet_Add(phaseset, rev);
Py_XDECREF(rev); Py_XDECREF(rev);
} }
phaseval = PyInt_FromLong(phase);
if (phaseval == NULL)
goto release;
PyList_SET_ITEM(phaseslist, i, phaseval);
} }
ret = PyTuple_Pack(2, phaseslist, phasessetlist); ret = PyTuple_Pack(2, phasessize, phasessetlist);
release: release:
Py_XDECREF(phaseslist); Py_XDECREF(phasessize);
Py_XDECREF(phasessetlist); Py_XDECREF(phasessetlist);
done: done:
free(phases); free(phases);
return ret; return ret;
} }
static PyObject *index_headrevs(indexObject *self, PyObject *args) static PyObject *index_headrevs(indexObject *self, PyObject *args)
{ {
"return the gca set of the given revs"}, "return the gca set of the given revs"},
{"commonancestorsheads", (PyCFunction)index_commonancestorsheads, {"commonancestorsheads", (PyCFunction)index_commonancestorsheads,
METH_VARARGS, METH_VARARGS,
"return the heads of the common ancestors of the given revs"}, "return the heads of the common ancestors of the given revs"},
{"clearcaches", (PyCFunction)index_clearcaches, METH_NOARGS, {"clearcaches", (PyCFunction)index_clearcaches, METH_NOARGS,
"clear the index caches"}, "clear the index caches"},
{"get", (PyCFunction)index_m_get, METH_VARARGS, {"get", (PyCFunction)index_m_get, METH_VARARGS,
"get an index entry"}, "get an index entry"},
{"computephasesmapsets", (PyCFunction)compute_phases_map_sets, {"computephasesmapsets", (PyCFunction)compute_phases_map_sets,
quarkUnsubmitted
Not Done

Also here, computephaseslensets

quark: Also here, `computephaseslensets`
METH_VARARGS, "compute phases"}, METH_VARARGS, "compute phases"},
{"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS, {"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS,
"reachableroots"}, "reachableroots"},
{"headrevs", (PyCFunction)index_headrevs, METH_VARARGS, {"headrevs", (PyCFunction)index_headrevs, METH_VARARGS,
"get head revisions"}, /* Can do filtering since 3.2 */ "get head revisions"}, /* Can do filtering since 3.2 */
{"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS, {"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS,
"get filtered head revisions"}, /* Can always do filtering */ "get filtered head revisions"}, /* Can always do filtering */
{"deltachain", (PyCFunction)index_deltachain, METH_VARARGS, {"deltachain", (PyCFunction)index_deltachain, METH_VARARGS,

mercurial/localrepo.py

@repofilecache('bookmarks', 'bookmarks.current') @repofilecache('bookmarks', 'bookmarks.current')
def _bookmarks(self): def _bookmarks(self):
return bookmarks.bmstore(self) return bookmarks.bmstore(self)
@property @property
def _activebookmark(self): def _activebookmark(self):
return self._bookmarks.active return self._bookmarks.active
# _phaserevs and _phasesets depend on changelog. what we need is to # _phasesets depend on changelog. what we need is to call
# call _phasecache.invalidate() if '00changelog.i' was changed, but it # _phasecache.invalidate() if '00changelog.i' was changed, but it
# can't be easily expressed in filecache mechanism. # can't be easily expressed in filecache mechanism.
@storecache('phaseroots', '00changelog.i') @storecache('phaseroots', '00changelog.i')
def _phasecache(self): def _phasecache(self):
return phases.phasecache(self, self._phasedefaults) return phases.phasecache(self, self._phasedefaults)
@storecache('obsstore') @storecache('obsstore')
def obsstore(self): def obsstore(self):
return obsolete.makestore(self.ui, self) return obsolete.makestore(self.ui, self)

mercurial/phases.py

old = existing[0] old = existing[0]
data[rev] = (old, new) data[rev] = (old, new)
class phasecache(object): class phasecache(object):
def __init__(self, repo, phasedefaults, _load=True): def __init__(self, repo, phasedefaults, _load=True):
if _load: if _load:
# Cheap trick to allow shallow-copy without copy module # Cheap trick to allow shallow-copy without copy module
self.phaseroots, self.dirty = _readroots(repo, phasedefaults) self.phaseroots, self.dirty = _readroots(repo, phasedefaults)
self._phaserevs = None self._phasemaxrev = nullrev
yujaUnsubmitted
Not Done

Nit: this isn't the "max" revision, but the size. Perhaps the initial
value should be 0.

yuja: Nit: this isn't the "max" revision, but the size. Perhaps the initial value should be 0.
self._phasesets = None self._phasesets = None
self.filterunknown(repo) self.filterunknown(repo)
self.opener = repo.svfs self.opener = repo.svfs
def getrevset(self, repo, phases): def getrevset(self, repo, phases):
"""return a smartset for the given phases""" """return a smartset for the given phases"""
self.loadphaserevs(repo) # ensure phase's sets are loaded self.loadphaserevs(repo) # ensure phase's sets are loaded
phases = set(phases)
if self._phasesets and all(self._phasesets[p] is not None if public not in phases:
for p in phases): # fast path: _phasesets contains the interesting sets,
# fast path - use _phasesets # might only need a union and post-filtering.
revs = self._phasesets[phases[0]] if len(phases) == 1:
if len(phases) > 1: [p] = phases
revs = revs.copy() # only copy when needed revs = self._phasesets[p]
for p in phases[1:]: else:
revs.update(self._phasesets[p]) revs = set.union(*[self._phasesets[p] for p in phases])
if repo.changelog.filteredrevs: if repo.changelog.filteredrevs:
revs = revs - repo.changelog.filteredrevs revs = revs - repo.changelog.filteredrevs
return smartset.baseset(revs) return smartset.baseset(revs)
else: else:
# slow path - enumerate all revisions assert not repo.changelog.filteredrevs
quarkUnsubmitted
Not Done

The assert is incorrect - repo could be "filtered". The old code support filtered repo implicitly by using for r in repo, the iterator of repo will remove filtered revisions.

quark: The `assert` is incorrect - repo could be "filtered". The old code support filtered repo…
phase = self.phase phases = set(allphases).difference(phases)
revs = (r for r in repo if phase(repo, r) in phases) if not phases:
return smartset.generatorset(revs, iterasc=True) return smartset.fullreposet()
if len(phases) == 1:
[p] = phases
revs = self._phasesets[p]
else:
revs = set.union(*[self._phasesets[p] for p in phases])
if not revs:
return smartset.fullreposet()
yujaUnsubmitted
Not Done

Nit: could be written as fullrepoest(repo) - baseset(revs).

yuja: Nit: could be written as `fullrepoest(repo) - baseset(revs)`.
quarkUnsubmitted
Not Done

baseset.__contains__ is slower than set.__contains__ so the current code is faster.

quark: `baseset.__contains__` is slower than `set.__contains__` so the current code is faster.
yujaUnsubmitted
Not Done

Really? It's aliased to self._set.__contains__.

yuja: Really? It's aliased to `self._set.__contains__`.
return smartset.fullreposet().filter(lambda r: r not in revs)
quarkUnsubmitted
Not Done

Sorry - I made a mistake using repo.revs('public()') to test the logic here. Actually that exercises a different code path.

There are practically no users exercising this public in phases code path. So issues like fullreposet requires a repo argument is not exposed.

I think we can either:

  • Pass an optional subset here then replace the revset implementation to use it:
def getrevset(self, repo, phases, subset=None):
    if subset is None:
        subset = smartset.fullreposet(repo)
    if ...
        # fast path
        ...
        return subset & smartset.baseset(revs)
    else:
        ...
  • Remove support for calculating public() here by just raise error.ProgrammingError('public() is unsupported')

I guess the former is preferred eventually. But if you want to land this faster, the latter is easier. I can help writing a follow-up.

quark: Sorry - I made a mistake using `repo.revs('public()')` to test the logic here. Actually that…
joerg.sonnenbergerAuthorUnsubmitted
Not Done

I think this can just follow the logic of the other branch, i.e. short cut if len(phases) == 1 and repo.changelog.filteredrevs, otherwise, add repo.changelog.filteredrevs to the union as well.
I added the assert to make sure that the check wasn't necessary, missed the implicit dependency on repo here.

joerg.sonnenberger: I think this can just follow the logic of the other branch, i.e. short cut if `len(phases) == 1…
quarkUnsubmitted
Not Done

Agree. The only real difference with revset.py:public is the subset argument.

quark: Agree. The only real difference with `revset.py:public` is the `subset` argument.
def copy(self): def copy(self):
# Shallow copy meant to ensure isolation in # Shallow copy meant to ensure isolation in
# advance/retractboundary(), nothing more. # advance/retractboundary(), nothing more.
ph = self.__class__(None, None, _load=False) ph = self.__class__(None, None, _load=False)
ph.phaseroots = self.phaseroots[:] ph.phaseroots = self.phaseroots[:]
ph.dirty = self.dirty ph.dirty = self.dirty
ph.opener = self.opener ph.opener = self.opener
ph._phaserevs = self._phaserevs ph._phasemaxrev = self._phasemaxrev
ph._phasesets = self._phasesets ph._phasesets = self._phasesets
return ph return ph
def replace(self, phcache): def replace(self, phcache):
"""replace all values in 'self' with content of phcache""" """replace all values in 'self' with content of phcache"""
for a in ('phaseroots', 'dirty', 'opener', '_phaserevs', '_phasesets'): for a in ('phaseroots', 'dirty', 'opener', '_phasemaxrev',
'_phasesets'):
setattr(self, a, getattr(phcache, a)) setattr(self, a, getattr(phcache, a))
def _getphaserevsnative(self, repo): def _getphaserevsnative(self, repo):
repo = repo.unfiltered() repo = repo.unfiltered()
nativeroots = [] nativeroots = []
for phase in trackedphases: for phase in trackedphases:
nativeroots.append(map(repo.changelog.rev, self.phaseroots[phase])) nativeroots.append(map(repo.changelog.rev, self.phaseroots[phase]))
return repo.changelog.computephases(nativeroots) return repo.changelog.computephases(nativeroots)
def _computephaserevspure(self, repo): def _computephaserevspure(self, repo):
repo = repo.unfiltered() repo = repo.unfiltered()
revs = [public] * len(repo.changelog) cl = repo.changelog
self._phaserevs = revs self._phasesets = [set() for phase in allphases]
self._populatephaseroots(repo) roots = map(cl.rev, self.phaseroots[secret])
yujaUnsubmitted
Not Done

s/map/pycompat.maplist/ for Python 3 compatibility. Fixed in flight.

yuja: s/map/pycompat.maplist/ for Python 3 compatibility. Fixed in flight.
for phase in trackedphases: if roots:
roots = list(map(repo.changelog.rev, self.phaseroots[phase])) ps = set(cl.descendants(roots))
for root in roots:
ps.add(root)
self._phasesets[secret] = ps
roots = map(cl.rev, self.phaseroots[draft])
if roots: if roots:
for rev in roots: ps = set(cl.descendants(roots))
revs[rev] = phase for root in roots:
for rev in repo.changelog.descendants(roots): ps.add(root)
revs[rev] = phase ps.difference_update(self._phasesets[secret])
self._phasesets[draft] = ps
self._phasemaxrev = len(cl)
yujaUnsubmitted
Not Done

Nice, no dependency on repo. As a follow-up, maybe we
can extract a pure function as truly drop-in replacement for
the native function.

yuja: Nice, no dependency on repo. As a follow-up, maybe we can extract a pure function as truly drop…
def loadphaserevs(self, repo): def loadphaserevs(self, repo):
"""ensure phase information is loaded in the object""" """ensure phase information is loaded in the object"""
if self._phaserevs is None: if self._phasesets is None:
try: try:
res = self._getphaserevsnative(repo) res = self._getphaserevsnative(repo)
self._phaserevs, self._phasesets = res self._phasemaxrev, self._phasesets = res
except AttributeError: except AttributeError:
self._computephaserevspure(repo) self._computephaserevspure(repo)
def invalidate(self): def invalidate(self):
self._phaserevs = None self._phasemaxrev = nullrev
self._phasesets = None self._phasesets = None
def _populatephaseroots(self, repo):
"""Fills the _phaserevs cache with phases for the roots.
"""
cl = repo.changelog
phaserevs = self._phaserevs
for phase in trackedphases:
roots = map(cl.rev, self.phaseroots[phase])
for root in roots:
phaserevs[root] = phase
def phase(self, repo, rev): def phase(self, repo, rev):
# We need a repo argument here to be able to build _phaserevs # We need a repo argument here to be able to build _phaserevs
yujaUnsubmitted
Not Done

s/_phaserevs/_phasesets/. Fixed in flight.

yuja: s/_phaserevs/_phasesets/. Fixed in flight.
# if necessary. The repository instance is not stored in # if necessary. The repository instance is not stored in
# phasecache to avoid reference cycles. The changelog instance # phasecache to avoid reference cycles. The changelog instance
# is not stored because it is a filecache() property and can # is not stored because it is a filecache() property and can
# be replaced without us being notified. # be replaced without us being notified.
if rev == nullrev: if rev == nullrev:
return public return public
if rev < nullrev: if rev < nullrev:
raise ValueError(_('cannot lookup negative revision')) raise ValueError(_('cannot lookup negative revision'))
if self._phaserevs is None or rev >= len(self._phaserevs): if rev >= self._phasemaxrev:
self.invalidate() self.invalidate()
self.loadphaserevs(repo) self.loadphaserevs(repo)
return self._phaserevs[rev] for phase in trackedphases:
if rev in self._phasesets[phase]:
return phase
return public
def write(self): def write(self):
if not self.dirty: if not self.dirty:
return return
f = self.opener('phaseroots', 'w', atomictemp=True, checkambig=True) f = self.opener('phaseroots', 'w', atomictemp=True, checkambig=True)
try: try:
self._write(f) self._write(f)
finally: finally:
repo.ui.debug( repo.ui.debug(
'removing unknown node %s from %i-phase boundary\n' 'removing unknown node %s from %i-phase boundary\n'
% (short(mnode), phase)) % (short(mnode), phase))
nodes.symmetric_difference_update(missing) nodes.symmetric_difference_update(missing)
filtered = True filtered = True
if filtered: if filtered:
self.dirty = True self.dirty = True
# filterunknown is called by repo.destroyed, we may have no changes in # filterunknown is called by repo.destroyed, we may have no changes in
# root but phaserevs contents is certainly invalid (or at least we # root but _phasesets contents is certainly invalid (or at least we
# have not proper way to check that). related to issue 3858. # have not proper way to check that). related to issue 3858.
# #
# The other caller is __init__ that have no _phaserevs initialized # The other caller is __init__ that have no _phasesets initialized
# anyway. If this change we should consider adding a dedicated # anyway. If this change we should consider adding a dedicated
# "destroyed" function to phasecache or a proper cache key mechanism # "destroyed" function to phasecache or a proper cache key mechanism
# (see branchmap one) # (see branchmap one)
self.invalidate() self.invalidate()
def advanceboundary(repo, tr, targetphase, nodes): def advanceboundary(repo, tr, targetphase, nodes):
"""Add nodes to a phase changing other nodes phases if necessary. """Add nodes to a phase changing other nodes phases if necessary.

mercurial/policy.py

# keep in sync with "version" in C modules # keep in sync with "version" in C modules
_cextversions = { _cextversions = {
(r'cext', r'base85'): 1, (r'cext', r'base85'): 1,
(r'cext', r'bdiff'): 1, (r'cext', r'bdiff'): 1,
(r'cext', r'diffhelpers'): 1, (r'cext', r'diffhelpers'): 1,
(r'cext', r'mpatch'): 1, (r'cext', r'mpatch'): 1,
(r'cext', r'osutil'): 1, (r'cext', r'osutil'): 1,
(r'cext', r'parsers'): 3, (r'cext', r'parsers'): 4,
} }
# map import request to other package or module # map import request to other package or module
_modredirects = { _modredirects = {
(r'cext', r'charencode'): (r'cext', r'parsers'), (r'cext', r'charencode'): (r'cext', r'parsers'),
(r'cffi', r'base85'): (r'pure', r'base85'), (r'cffi', r'base85'): (r'pure', r'base85'),
(r'cffi', r'charencode'): (r'pure', r'charencode'), (r'cffi', r'charencode'): (r'pure', r'charencode'),
(r'cffi', r'diffhelpers'): (r'pure', r'diffhelpers'), (r'cffi', r'diffhelpers'): (r'pure', r'diffhelpers'),