This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8698

phases: sparsify phaseroots and phasesets
ClosedPublic

Authored by joerg.sonnenberger on Jul 7 2020, 6:38 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG61e7464477ac: phases: sparsify phaseroots and phasesets
Summary

As final step of dealing with the holes in the phase numbers, make
phaseroots and phasesets both dictionaries indexed by the phase number.
Further adjust the interface of the C module by pushing the node to
revision mapping down as it is cheaper on the C side to deal with
revision numbers.

Overall, the patch series improves a no-change "hg up" for my NetBSD test
repository from 4.7s to 1.3s.

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

durin42 accepted this revision.Jul 15 2020, 11:28 AM
durin42 added a subscriber: durin42.
durin42 added inline comments.
mercurial/cext/revlog.c
880–889

Possible improvement: _dict_new_presized could probably be used here since it looks like you know the possible dict size.

This revision is now accepted and ready to land.Jul 15 2020, 11:28 AM
joerg.sonnenberger added a commit: rHG61e7464477ac: phases: sparsify phaseroots and phasesets.Jul 16 2020, 12:51 PM
Closed by commit rHG61e7464477ac: phases: sparsify phaseroots and phasesets (authored by joerg.sonnenberger). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 21937

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 = 16; static const int version = 17;
static void module_init(PyObject *mod) static void module_init(PyObject *mod)
{ {
PyObject *capsule = NULL; PyObject *capsule = NULL;
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

mercurial/cext/revlog.c

} }
static PyObject *nullentry = NULL; static PyObject *nullentry = NULL;
static const char nullid[20] = {0}; static const char nullid[20] = {0};
static const Py_ssize_t nullrev = -1; static const Py_ssize_t nullrev = -1;
static Py_ssize_t inline_scan(indexObject *self, const char **offsets); static Py_ssize_t inline_scan(indexObject *self, const char **offsets);
static int index_find_node(indexObject *self, const char *node,
Py_ssize_t nodelen);
#if LONG_MAX == 0x7fffffffL #if LONG_MAX == 0x7fffffffL
static const char *const tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#"); static const char *const tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#");
#else #else
static const char *const tuple_format = PY23("kiiiiiis#", "kiiiiiiy#"); static const char *const tuple_format = PY23("kiiiiiis#", "kiiiiiiy#");
#endif #endif
/* A RevlogNG v1 index entry is 64 bytes long. */ /* A RevlogNG v1 index entry is 64 bytes long. */
static const long v1_hdrsize = 64; static const long v1_hdrsize = 64;
isfiltered = PyObject_IsTrue(result); isfiltered = PyObject_IsTrue(result);
Py_DECREF(result); Py_DECREF(result);
return isfiltered; return isfiltered;
} else { } else {
return 0; return 0;
} }
} }
static Py_ssize_t add_roots_get_min(indexObject *self, PyObject *list,
Py_ssize_t marker, char *phases)
{
PyObject *iter = NULL;
PyObject *iter_item = NULL;
Py_ssize_t min_idx = index_length(self) + 2;
long iter_item_long;
if (PyList_GET_SIZE(list) != 0) {
iter = PyObject_GetIter(list);
if (iter == NULL)
return -2;
while ((iter_item = PyIter_Next(iter))) {
if (!pylong_to_long(iter_item, &iter_item_long)) {
Py_DECREF(iter_item);
return -2;
}
Py_DECREF(iter_item);
if (iter_item_long < min_idx)
min_idx = iter_item_long;
phases[iter_item_long] = (char)marker;
}
Py_DECREF(iter);
}
return min_idx;
}
static inline void set_phase_from_parents(char *phases, int parent_1, static inline void set_phase_from_parents(char *phases, int parent_1,
int parent_2, Py_ssize_t i) int parent_2, Py_ssize_t i)
{ {
if (parent_1 >= 0 && phases[parent_1] > phases[i]) if (parent_1 >= 0 && phases[parent_1] > phases[i])
phases[i] = phases[parent_1]; phases[i] = phases[parent_1];
if (parent_2 >= 0 && phases[parent_2] > phases[i]) if (parent_2 >= 0 && phases[parent_2] > phases[i])
phases[i] = phases[parent_2]; phases[i] = phases[parent_2];
} }
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 int add_roots_get_min(indexObject *self, PyObject *roots, char *phases,
char phase)
{
Py_ssize_t len = index_length(self);
PyObject *iter;
PyObject *item;
PyObject *iterator;
int rev, minrev = -1;
char *node;
if (!PySet_Check(roots))
return -2;
iterator = PyObject_GetIter(roots);
if (iterator == NULL)
return -2;
while ((item = PyIter_Next(iterator))) {
if (node_check(item, &node) == -1)
goto failed;
rev = index_find_node(self, node, 20);
/* null is implicitly public, so negative is invalid */
if (rev < 0 || rev >= len)
goto failed;
phases[rev] = phase;
if (minrev == -1 || minrev > rev)
minrev = rev;
Py_DECREF(item);
}
Py_DECREF(iterator);
return minrev;
failed:
Py_DECREF(iterator);
Py_DECREF(item);
return -2;
}
static PyObject *compute_phases_map_sets(indexObject *self, PyObject *args) static PyObject *compute_phases_map_sets(indexObject *self, PyObject *args)
{ {
PyObject *roots = Py_None; /* 0: public (untracked), 1: draft, 2: secret, 32: archive,
96: internal */
static const char trackedphases[] = {1, 2, 32, 96};
PyObject *ret = NULL; PyObject *ret = NULL;
PyObject *phasessize = NULL; PyObject *roots = Py_None;
PyObject *idx = NULL;
PyObject *pyphase = NULL;
PyObject *pyrev = NULL;
PyObject *phaseroots = NULL; PyObject *phaseroots = NULL;
PyObject *phaseset = NULL; PyObject *phasessize = NULL;
PyObject *phasessetlist = NULL; PyObject *phasesets[4] = {NULL, NULL, NULL, NULL};
PyObject *rev = NULL;
Py_ssize_t len = index_length(self); Py_ssize_t len = index_length(self);
Py_ssize_t numphase = 0; const char *currentphase;
Py_ssize_t minrevallphases = 0;
Py_ssize_t minrevphase = 0;
Py_ssize_t i = 0;
char *phases = NULL; char *phases = NULL;
long phase; int minphaserev = -1, rev, i;
const int numphases = (int)(sizeof(phasesets) / sizeof(phasesets[0]));
if (!PyArg_ParseTuple(args, "O", &roots)) if (!PyArg_ParseTuple(args, "O", &roots))
goto done; return NULL;
if (roots == NULL || !PyList_Check(roots)) { if (roots == NULL || !PyDict_Check(roots)) {
PyErr_SetString(PyExc_TypeError, "roots must be a list"); PyErr_SetString(PyExc_TypeError, "roots must be a dictionary");
goto done; return NULL;
} }
phases = calloc( phases = calloc(len, 1);
len, 1); /* phase per rev: {0: public, 1: draft, 2: secret} */
if (phases == NULL) { if (phases == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
goto done; return NULL;
} }
/* Put the phase information of all the roots in phases */
numphase = PyList_GET_SIZE(roots) + 1;
minrevallphases = len + 1;
phasessetlist = PyList_New(numphase);
if (phasessetlist == NULL)
goto done;
PyList_SET_ITEM(phasessetlist, 0, Py_None); for (i = 0; i < numphases; ++i) {
Py_INCREF(Py_None); pyphase = PyInt_FromLong(trackedphases[i]);
if (pyphase == NULL)
for (i = 0; i < numphase - 1; i++) {
phaseroots = PyList_GET_ITEM(roots, i);
phaseset = PySet_New(NULL);
if (phaseset == NULL)
goto release; goto release;
PyList_SET_ITEM(phasessetlist, i + 1, phaseset); phaseroots = PyDict_GetItem(roots, pyphase);
if (!PyList_Check(phaseroots)) { Py_DECREF(pyphase);
PyErr_SetString(PyExc_TypeError, if (phaseroots == NULL)
"roots item must be a list"); continue;
rev = add_roots_get_min(self, phaseroots, phases, trackedphases[i]);
phaseroots = NULL;
if (rev == -2)
goto release; goto release;
if (rev != -1 && (minphaserev == -1 || rev < minphaserev))
minphaserev = rev;
} }
minrevphase =
add_roots_get_min(self, phaseroots, i + 1, phases); for (i = 0; i < numphases; ++i) {
if (minrevphase == -2) /* Error from add_roots_get_min */ phasesets[i] = PySet_New(NULL);
if (phasesets[i] == NULL)
goto release; goto release;
minrevallphases = MIN(minrevallphases, minrevphase);
} }
/* Propagate the phase information from the roots to the revs */
if (minrevallphases != -1) { if (minphaserev == -1)
minphaserev = len;
for (rev = minphaserev; rev < len; ++rev) {
int parents[2]; int parents[2];
for (i = minrevallphases; i < len; i++) { /*
if (index_get_parents(self, i, parents, (int)len - 1) < * The parent lookup could be skipped for phaseroots, but
0) * phase --force would historically not recompute them
* correctly, leaving descendents with a lower phase around.
* As such, unconditionally recompute the phase.
*/
if (index_get_parents(self, rev, parents, (int)len - 1) < 0)
goto release;
set_phase_from_parents(phases, parents[0], parents[1], rev);
switch (phases[rev]) {
case 0:
continue;
case 1:
pyphase = phasesets[0];
break;
case 2:
pyphase = phasesets[1];
break;
case 32:
pyphase = phasesets[2];
break;
case 96:
pyphase = phasesets[3];
break;
default:
goto release; goto release;
set_phase_from_parents(phases, parents[0], parents[1],
i);
} }
pyrev = PyInt_FromLong(rev);
if (pyrev == NULL)
goto release;
if (PySet_Add(pyphase, pyrev) == -1) {
Py_DECREF(pyrev);
goto release;
} }
/* Transform phase list to a python list */ Py_DECREF(pyrev);
phasessize = PyInt_FromSsize_t(len); }
if (phasessize == NULL) phaseroots = _dict_new_presized(numphases);
if (phaseroots == NULL)
goto release; goto release;
for (i = 0; i < len; i++) { for (int i = 0; i < numphases; ++i) {
phase = phases[i]; pyphase = PyInt_FromLong(trackedphases[i]);
/* We only store the sets of phase for non public phase, the if (pyphase == NULL)
* public phase is computed as a difference */ goto release;
if (phase != 0) { if (PyDict_SetItem(phaseroots, pyphase, phasesets[i]) == -1) {
phaseset = PyList_GET_ITEM(phasessetlist, phase); Py_DECREF(pyphase);
rev = PyInt_FromSsize_t(i);
if (rev == NULL)
goto release; goto release;
durin42Unsubmitted
Not Done

Possible improvement: _dict_new_presized could probably be used here since it looks like you know the possible dict size.

durin42: Possible improvement: `_dict_new_presized` could probably be used here since it looks like you…
PySet_Add(phaseset, rev);
Py_XDECREF(rev);
} }
Py_DECREF(phasesets[i]);
phasesets[i] = NULL;
} }
ret = PyTuple_Pack(2, phasessize, phasessetlist); phasessize = PyInt_FromSsize_t(len);
if (phasessize == NULL)
goto release;
ret = PyTuple_Pack(2, phasessize, phaseroots);
Py_DECREF(phasessize);
Py_DECREF(phaseroots);
return ret;
release: release:
Py_XDECREF(phasessize); for (i = 0; i < numphases; ++i)
Py_XDECREF(phasessetlist); Py_XDECREF(phasesets[i]);
done: Py_XDECREF(phaseroots);
free(phases); free(phases);
return ret; return NULL;
} }
static PyObject *index_headrevs(indexObject *self, PyObject *args) static PyObject *index_headrevs(indexObject *self, PyObject *args)
{ {
Py_ssize_t i, j, len; Py_ssize_t i, j, len;
char *nothead = NULL; char *nothead = NULL;
PyObject *heads = NULL; PyObject *heads = NULL;
PyObject *filter = NULL; PyObject *filter = NULL;

mercurial/phases.py

being initialized on an existing repository, this could be used to being initialized on an existing repository, this could be used to
set selected changesets phase to something else than public. set selected changesets phase to something else than public.
Return (roots, dirty) where dirty is true if roots differ from Return (roots, dirty) where dirty is true if roots differ from
what is being stored. what is being stored.
""" """
repo = repo.unfiltered() repo = repo.unfiltered()
dirty = False dirty = False
roots = [set() for i in range(max(allphases) + 1)] roots = {i: set() for i in allphases}
try: try:
f, pending = txnutil.trypending(repo.root, repo.svfs, b'phaseroots') f, pending = txnutil.trypending(repo.root, repo.svfs, b'phaseroots')
try: try:
for line in f: for line in f:
phase, nh = line.split() phase, nh = line.split()
roots[int(phase)].add(bin(nh)) roots[int(phase)].add(bin(nh))
finally: finally:
f.close() f.close()
def hasnonpublicphases(self, repo): def hasnonpublicphases(self, repo):
"""detect if there are revisions with non-public phase""" """detect if there are revisions with non-public phase"""
repo = repo.unfiltered() repo = repo.unfiltered()
cl = repo.changelog cl = repo.changelog
if len(cl) >= self._loadedrevslen: if len(cl) >= self._loadedrevslen:
self.invalidate() self.invalidate()
self.loadphaserevs(repo) self.loadphaserevs(repo)
return any(self.phaseroots[1:]) return any(
revs
for phase, revs in pycompat.iteritems(self.phaseroots)
if phase != public
)
def nonpublicphaseroots(self, repo): def nonpublicphaseroots(self, repo):
"""returns the roots of all non-public phases """returns the roots of all non-public phases
The roots are not minimized, so if the secret revisions are The roots are not minimized, so if the secret revisions are
descendants of draft revisions, their roots will still be present. descendants of draft revisions, their roots will still be present.
""" """
repo = repo.unfiltered() repo = repo.unfiltered()
cl = repo.changelog cl = repo.changelog
if len(cl) >= self._loadedrevslen: if len(cl) >= self._loadedrevslen:
self.invalidate() self.invalidate()
self.loadphaserevs(repo) self.loadphaserevs(repo)
return set().union(*[roots for roots in self.phaseroots[1:] if roots]) return set().union(
*[
revs
for phase, revs in pycompat.iteritems(self.phaseroots)
if phase != public
]
)
def getrevset(self, repo, phases, subset=None): def getrevset(self, repo, phases, subset=None):
"""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) phases = set(phases)
publicphase = public in phases publicphase = public in phases
if publicphase: if publicphase:
if not revs: if not revs:
return subset return subset
return subset.filter(lambda r: r not in revs) return subset.filter(lambda r: r not in revs)
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.copy()
ph.dirty = self.dirty ph.dirty = self.dirty
ph.opener = self.opener ph.opener = self.opener
ph._loadedrevslen = self._loadedrevslen ph._loadedrevslen = self._loadedrevslen
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 ( for a in (
b'phaseroots', b'phaseroots',
b'dirty', b'dirty',
b'opener', b'opener',
b'_loadedrevslen', b'_loadedrevslen',
b'_phasesets', b'_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 = [] return repo.changelog.computephases(self.phaseroots)
for phase in trackedphases:
nativeroots.append(
pycompat.maplist(repo.changelog.rev, self.phaseroots[phase])
)
revslen, phasesets = repo.changelog.computephases(nativeroots)
phasesets2 = [set() for phase in range(max(allphases) + 1)]
for phase, phaseset in zip(allphases, phasesets):
phasesets2[phase] = phaseset
return revslen, phasesets2
def _computephaserevspure(self, repo): def _computephaserevspure(self, repo):
repo = repo.unfiltered() repo = repo.unfiltered()
cl = repo.changelog cl = repo.changelog
self._phasesets = [set() for phase in range(max(allphases) + 1)] self._phasesets = {phase: set() for phase in allphases}
lowerroots = set() lowerroots = set()
for phase in reversed(trackedphases): for phase in reversed(trackedphases):
roots = pycompat.maplist(cl.rev, self.phaseroots[phase]) roots = pycompat.maplist(cl.rev, self.phaseroots[phase])
if roots: if roots:
ps = set(cl.descendants(roots)) ps = set(cl.descendants(roots))
for root in roots: for root in roots:
ps.add(root) ps.add(root)
ps.difference_update(lowerroots) ps.difference_update(lowerroots)
return return
f = self.opener(b'phaseroots', b'w', atomictemp=True, checkambig=True) f = self.opener(b'phaseroots', b'w', atomictemp=True, checkambig=True)
try: try:
self._write(f) self._write(f)
finally: finally:
f.close() f.close()
def _write(self, fp): def _write(self, fp):
for phase, roots in enumerate(self.phaseroots): for phase, roots in pycompat.iteritems(self.phaseroots):
for h in sorted(roots): for h in sorted(roots):
fp.write(b'%i %s\n' % (phase, hex(h))) fp.write(b'%i %s\n' % (phase, hex(h)))
self.dirty = False self.dirty = False
def _updateroots(self, phase, newroots, tr): def _updateroots(self, phase, newroots, tr):
self.phaseroots[phase] = newroots self.phaseroots[phase] = newroots
self.invalidate() self.invalidate()
self.dirty = True self.dirty = True
if not dryrun: if not dryrun:
# declare deleted root in the target phase # declare deleted root in the target phase
if targetphase != 0: if targetphase != 0:
self._retractboundary(repo, tr, targetphase, delroots) self._retractboundary(repo, tr, targetphase, delroots)
repo.invalidatevolatilesets() repo.invalidatevolatilesets()
return changes return changes
def retractboundary(self, repo, tr, targetphase, nodes): def retractboundary(self, repo, tr, targetphase, nodes):
oldroots = self.phaseroots[: targetphase + 1] oldroots = {
phase: revs
for phase, revs in pycompat.iteritems(self.phaseroots)
if phase <= targetphase
}
if tr is None: if tr is None:
phasetracking = None phasetracking = None
else: else:
phasetracking = tr.changes.get(b'phases') phasetracking = tr.changes.get(b'phases')
repo = repo.unfiltered() repo = repo.unfiltered()
if ( if (
self._retractboundary(repo, tr, targetphase, nodes) self._retractboundary(repo, tr, targetphase, nodes)
and phasetracking is not None and phasetracking is not None
): ):
# find the affected revisions # find the affected revisions
new = self.phaseroots[targetphase] new = self.phaseroots[targetphase]
old = oldroots[targetphase] old = oldroots[targetphase]
affected = set(repo.revs(b'(%ln::) - (%ln::)', new, old)) affected = set(repo.revs(b'(%ln::) - (%ln::)', new, old))
# find the phase of the affected revision # find the phase of the affected revision
for phase in pycompat.xrange(targetphase, -1, -1): for phase in pycompat.xrange(targetphase, -1, -1):
if phase: if phase:
roots = oldroots[phase] roots = oldroots.get(phase, [])
revs = set(repo.revs(b'%ln::%ld', roots, affected)) revs = set(repo.revs(b'%ln::%ld', roots, affected))
affected -= revs affected -= revs
else: # public phase else: # public phase
revs = affected revs = affected
for r in sorted(revs): for r in sorted(revs):
_trackphasechange(phasetracking, r, phase, targetphase) _trackphasechange(phasetracking, r, phase, targetphase)
repo.invalidatevolatilesets() repo.invalidatevolatilesets()
def filterunknown(self, repo): def filterunknown(self, repo):
"""remove unknown nodes from the phase boundary """remove unknown nodes from the phase boundary
Nothing is lost as unknown nodes only hold data for their descendants. Nothing is lost as unknown nodes only hold data for their descendants.
""" """
filtered = False filtered = False
has_node = repo.changelog.index.has_node # to filter unknown nodes has_node = repo.changelog.index.has_node # to filter unknown nodes
for phase, nodes in enumerate(self.phaseroots): for phase, nodes in pycompat.iteritems(self.phaseroots):
missing = sorted(node for node in nodes if not has_node(node)) missing = sorted(node for node in nodes if not has_node(node))
if missing: if missing:
for mnode in missing: for mnode in missing:
repo.ui.debug( repo.ui.debug(
b'removing unknown node %s from %i-phase boundary\n' b'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)

mercurial/policy.py

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

tests/test-parseindex.t

> from __future__ import print_function > from __future__ import print_function
> import sys > import sys
> from mercurial import changelog, pycompat, vfs > from mercurial import changelog, pycompat, vfs
> cl = changelog.changelog(vfs.vfs(pycompat.fsencode(sys.argv[1]))) > cl = changelog.changelog(vfs.vfs(pycompat.fsencode(sys.argv[1])))
> n0, n1 = cl.node(0), cl.node(1) > n0, n1 = cl.node(0), cl.node(1)
> ops = [ > ops = [
> ('reachableroots', > ('reachableroots',
> lambda: cl.index.reachableroots2(0, [1], [0], False)), > lambda: cl.index.reachableroots2(0, [1], [0], False)),
> ('compute_phases_map_sets', lambda: cl.computephases([[0], []])), > ('compute_phases_map_sets', lambda: cl.computephases({1: {cl.node(0)}})),
> ('index_headrevs', lambda: cl.headrevs()), > ('index_headrevs', lambda: cl.headrevs()),
> ('find_gca_candidates', lambda: cl.commonancestorsheads(n0, n1)), > ('find_gca_candidates', lambda: cl.commonancestorsheads(n0, n1)),
> ('find_deepest', lambda: cl.ancestor(n0, n1)), > ('find_deepest', lambda: cl.ancestor(n0, n1)),
> ] > ]
> for l, f in ops: > for l, f in ops:
> print(l + ':', end=' ') > print(l + ':', end=' ')
> try: > try:
> f() > f()