ancestor.missingancestors: turn into a state-keeping class

This allows multiple efficient missing ancestor queries against the same set of
bases. In upcoming patches we'll also define ways to grow the set of bases.

The fact that the test output hasn't changed establishes this patch's
correctness.

mercurial/ancestor.py

@@ -1,312 +1,324
 # ancestor.py - generic DAG ancestor algorithm for mercurial
 #
 # Copyright 2006 Matt Mackall <[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.
 
 import heapq
 import util
 from node import nullrev
 
 def commonancestorsheads(pfunc, *nodes):
     """Returns a set with the heads of all common ancestors of all nodes,
     heads(::nodes[0] and ::nodes[1] and ...) .
 
     pfunc must return a list of parent vertices for a given vertex.
     """
     if not isinstance(nodes, set):
         nodes = set(nodes)
     if nullrev in nodes:
         return set()
     if len(nodes) <= 1:
         return nodes
 
     allseen = (1 << len(nodes)) - 1
     seen = [0] * (max(nodes) + 1)
     for i, n in enumerate(nodes):
         seen[n] = 1 << i
     poison = 1 << (i + 1)
 
     gca = set()
     interesting = len(nodes)
     nv = len(seen) - 1
     while nv >= 0 and interesting:
         v = nv
         nv -= 1
         if not seen[v]:
             continue
         sv = seen[v]
         if sv < poison:
             interesting -= 1
             if sv == allseen:
                 gca.add(v)
                 sv |= poison
                 if v in nodes:
                     # history is linear
                     return set([v])
         if sv < poison:
             for p in pfunc(v):
                 sp = seen[p]
                 if p == nullrev:
                     continue
                 if sp == 0:
                     seen[p] = sv
                     interesting += 1
                 elif sp != sv:
                     seen[p] |= sv
         else:
             for p in pfunc(v):
                 if p == nullrev:
                     continue
                 sp = seen[p]
                 if sp and sp < poison:
                     interesting -= 1
                 seen[p] = sv
     return gca
 
 def ancestors(pfunc, *orignodes):
     """
     Returns the common ancestors of a and b that are furthest from a
     root (as measured by longest path).
 
     pfunc must return a list of parent vertices for a given vertex.
     """
     def deepest(nodes):
         interesting = {}
         count = max(nodes) + 1
         depth = [0] * count
         seen = [0] * count
         mapping = []
         for (i, n) in enumerate(sorted(nodes)):
             depth[n] = 1
             b = 1 << i
             seen[n] = b
             interesting[b] = 1
             mapping.append((b, n))
         nv = count - 1
         while nv >= 0 and len(interesting) > 1:
             v = nv
             nv -= 1
             dv = depth[v]
             if dv == 0:
                 continue
             sv = seen[v]
             for p in pfunc(v):
                 if p == nullrev:
                     continue
                 dp = depth[p]
                 nsp = sp = seen[p]
                 if dp <= dv:
                     depth[p] = dv + 1
                     if sp != sv:
                         interesting[sv] += 1
                         nsp = seen[p] = sv
                         if sp:
                             interesting[sp] -= 1
                             if interesting[sp] == 0:
                                 del interesting[sp]
                 elif dv == dp - 1:
                     nsp = sp | sv
                     if nsp == sp:
                         continue
                     seen[p] = nsp
                     interesting.setdefault(nsp, 0)
                     interesting[nsp] += 1
                     interesting[sp] -= 1
                     if interesting[sp] == 0:
                         del interesting[sp]
             interesting[sv] -= 1
             if interesting[sv] == 0:
                 del interesting[sv]
 
         if len(interesting) != 1:
             return []
 
         k = 0
         for i in interesting:
             k |= i
         return set(n for (i, n) in mapping if k & i)
 
     gca = commonancestorsheads(pfunc, *orignodes)
 
     if len(gca) <= 1:
         return gca
     return deepest(gca)
 
-def missingancestors(revs, bases, pfunc):
-    """Return all the ancestors of revs that are not ancestors of bases.
+class incrementalmissingancestors(object):
+    '''persistent state used to calculate missing ancestors incrementally
+
+    Although similar in spirit to lazyancestors below, this is a separate class
+    because trying to support contains and missingancestors operations with the
+    same internal data structures adds needless complexity.'''
+    def __init__(self, pfunc, bases):
+        self.bases = set(bases)
+        if not self.bases:
+            self.bases.add(nullrev)
+        self.pfunc = pfunc
+
+    def missingancestors(self, revs):
+        '''return all the ancestors of revs that are not ancestors of self.bases
 
     This may include elements from revs.
 
-    Equivalent to the revset (::revs - ::bases). Revs are returned in
-    revision number order, which is a topological order.
-
-    revs and bases should both be iterables. pfunc must return a list of
-    parent revs for a given revs.
-    """
-
+        Equivalent to the revset (::revs - ::self.bases). Revs are returned in
+        revision number order, which is a topological order.'''
     revsvisit = set(revs)
-    basesvisit = set(bases)
-    if not basesvisit:
-        basesvisit.add(nullrev)
+        basesvisit = self.bases
+        pfunc = self.pfunc
     bothvisit = revsvisit.intersection(basesvisit)
     revsvisit.difference_update(bothvisit)
     if not revsvisit:
         return []
+
     start = max(max(revsvisit), max(basesvisit))
     # At this point, we hold the invariants that:
-    # - revsvisit is the set of nodes we know are an ancestor of at least one
-    #   of the nodes in revs
+        # - revsvisit is the set of nodes we know are an ancestor of at least
+        #   one of the nodes in revs
     # - basesvisit is the same for bases
-    # - bothvisit is the set of nodes we know are ancestors of at least one of
-    #   the nodes in revs and one of the nodes in bases, and that are smaller
-    #   than curr. bothvisit and revsvisit are mutually exclusive, but bothvisit
-    #   is a subset of basesvisit.
-    # Now we walk down in reverse topo order, adding parents of nodes already
-    # visited to the sets while maintaining the invariants. When a node is found
-    # in both revsvisit and basesvisit, it is removed from revsvisit and added
-    # to bothvisit. When revsvisit becomes empty, there are no more ancestors of
-    # revs that aren't also ancestors of bases, so exit.
+        # - bothvisit is the set of nodes we know are ancestors of at least one
+        #   of the nodes in revs and one of the nodes in bases. bothvisit and
+        #   revsvisit are mutually exclusive, but bothvisit is a subset of
+        #   basesvisit.
+        # Now we walk down in reverse topo order, adding parents of nodes
+        # already visited to the sets while maintaining the invariants. When a
+        # node is found in both revsvisit and basesvisit, it is removed from
+        # revsvisit and added to bothvisit. When revsvisit becomes empty, there
+        # are no more ancestors of revs that aren't also ancestors of bases, so
+        # exit.
 
     missing = []
     for curr in xrange(start, nullrev, -1):
         if not revsvisit:
             break
 
         if curr in bothvisit:
             bothvisit.remove(curr)
-            # curr's parents might have made it into revsvisit through another
-            # path
+                # curr's parents might have made it into revsvisit through
+                # another path
             for p in pfunc(curr):
                 revsvisit.discard(p)
                 basesvisit.add(p)
                 bothvisit.add(p)
             continue
 
         if curr in revsvisit:
             missing.append(curr)
             revsvisit.remove(curr)
             thisvisit = revsvisit
             othervisit = basesvisit
         elif curr in basesvisit:
             thisvisit = basesvisit
             othervisit = revsvisit
         else:
             # not an ancestor of revs or bases: ignore
             continue
 
         for p in pfunc(curr):
             if p == nullrev:
                 pass
             elif p in othervisit or p in bothvisit:
                 # p is implicitly in thisvisit. This means p is or should be
                 # in bothvisit
                 revsvisit.discard(p)
                 basesvisit.add(p)
                 bothvisit.add(p)
             else:
                 # visit later
                 thisvisit.add(p)
 
     missing.reverse()
     return missing
 
+def missingancestors(revs, bases, pfunc):
+    inc = incrementalmissingancestors(pfunc, bases)
+    return inc.missingancestors(revs)
+
 class lazyancestors(object):
     def __init__(self, pfunc, revs, stoprev=0, inclusive=False):
         """Create a new object generating ancestors for the given revs. Does
         not generate revs lower than stoprev.
 
         This is computed lazily starting from revs. The object supports
         iteration and membership.
 
         cl should be a changelog and revs should be an iterable. inclusive is
         a boolean that indicates whether revs should be included. Revs lower
         than stoprev will not be generated.
 
         Result does not include the null revision."""
         self._parentrevs = pfunc
         self._initrevs = revs
         self._stoprev = stoprev
         self._inclusive = inclusive
 
         # Initialize data structures for __contains__.
         # For __contains__, we use a heap rather than a deque because
         # (a) it minimizes the number of parentrevs calls made
         # (b) it makes the loop termination condition obvious
         # Python's heap is a min-heap. Multiply all values by -1 to convert it
         # into a max-heap.
         self._containsvisit = [-rev for rev in revs]
         heapq.heapify(self._containsvisit)
         if inclusive:
             self._containsseen = set(revs)
         else:
             self._containsseen = set()
 
     def __nonzero__(self):
         """False if the set is empty, True otherwise."""
         try:
             iter(self).next()
             return True
         except StopIteration:
             return False
 
     def __iter__(self):
         """Generate the ancestors of _initrevs in reverse topological order.
 
         If inclusive is False, yield a sequence of revision numbers starting
         with the parents of each revision in revs, i.e., each revision is *not*
         considered an ancestor of itself.  Results are in breadth-first order:
         parents of each rev in revs, then parents of those, etc.
 
         If inclusive is True, yield all the revs first (ignoring stoprev),
         then yield all the ancestors of revs as when inclusive is False.
         If an element in revs is an ancestor of a different rev it is not
         yielded again."""
         seen = set()
         revs = self._initrevs
         if self._inclusive:
             for rev in revs:
                 yield rev
             seen.update(revs)
 
         parentrevs = self._parentrevs
         stoprev = self._stoprev
         visit = util.deque(revs)
 
         while visit:
             for parent in parentrevs(visit.popleft()):
                 if parent >= stoprev and parent not in seen:
                     visit.append(parent)
                     seen.add(parent)
                     yield parent
 
     def __contains__(self, target):
         """Test whether target is an ancestor of self._initrevs."""
         # Trying to do both __iter__ and __contains__ using the same visit
         # heap and seen set is complex enough that it slows down both. Keep
         # them separate.
         seen = self._containsseen
         if target in seen:
             return True
 
         parentrevs = self._parentrevs
         visit = self._containsvisit
         stoprev = self._stoprev
         heappop = heapq.heappop
         heappush = heapq.heappush
 
         targetseen = False
 
         while visit and -visit[0] > target and not targetseen:
             for parent in parentrevs(-heappop(visit)):
                 if parent < stoprev or parent in seen:
                     continue
                 # We need to make sure we push all parents into the heap so
                 # that we leave it in a consistent state for future calls.
                 heappush(visit, -parent)
                 seen.add(parent)
                 if parent == target:
                     targetseen = True
 
         return targetseen

tests/test-ancestor.py

@@ -1,211 +1,212
 from mercurial import ancestor, commands, hg, ui, util
 from mercurial.node import nullrev
 import binascii, getopt, math, os, random, sys, time
 
 def buildgraph(rng, nodes=100, rootprob=0.05, mergeprob=0.2, prevprob=0.7):
     '''nodes: total number of nodes in the graph
     rootprob: probability that a new node (not 0) will be a root
     mergeprob: probability that, excluding a root a node will be a merge
     prevprob: probability that p1 will be the previous node
 
     return value is a graph represented as an adjacency list.
     '''
     graph = [None] * nodes
     for i in xrange(nodes):
         if i == 0 or rng.random() < rootprob:
             graph[i] = [nullrev]
         elif i == 1:
             graph[i] = [0]
         elif rng.random() < mergeprob:
             if i == 2 or rng.random() < prevprob:
                 # p1 is prev
                 p1 = i - 1
             else:
                 p1 = rng.randrange(i - 1)
             p2 = rng.choice(range(0, p1) + range(p1 + 1, i))
             graph[i] = [p1, p2]
         elif rng.random() < prevprob:
             graph[i] = [i - 1]
         else:
             graph[i] = [rng.randrange(i - 1)]
 
     return graph
 
 def buildancestorsets(graph):
     ancs = [None] * len(graph)
     for i in xrange(len(graph)):
         ancs[i] = set([i])
         if graph[i] == [nullrev]:
             continue
         for p in graph[i]:
             ancs[i].update(ancs[p])
     return ancs
 
 def naivemissingancestors(ancs, revs, bases):
     res = set()
     for rev in revs:
         if rev != nullrev:
             res.update(ancs[rev])
     for base in bases:
         if base != nullrev:
             res.difference_update(ancs[base])
     return sorted(res)
 
 def test_missingancestors(seed, rng):
     # empirically observed to take around 1 second
     graphcount = 100
     testcount = 100
     nerrs = [0]
     # the default mu and sigma give us a nice distribution of mostly
     # single-digit counts (including 0) with some higher ones
     def lognormrandom(mu, sigma):
         return int(math.floor(rng.lognormvariate(mu, sigma)))
 
     def samplerevs(nodes, mu=1.1, sigma=0.8):
         count = min(lognormrandom(mu, sigma), len(nodes))
         return rng.sample(nodes, count)
 
     def err(seed, graph, bases, revs, output, expected):
         if nerrs[0] == 0:
             print >> sys.stderr, 'seed:', hex(seed)[:-1]
         if gerrs[0] == 0:
             print >> sys.stderr, 'graph:', graph
         print >> sys.stderr, '* bases:', bases
         print >> sys.stderr, '* revs: ', revs
         print >> sys.stderr, '*  output:  ', output
         print >> sys.stderr, '*  expected:', expected
         nerrs[0] += 1
         gerrs[0] += 1
 
     for g in xrange(graphcount):
         graph = buildgraph(rng)
         ancs = buildancestorsets(graph)
         gerrs = [0]
         for _ in xrange(testcount):
             # start from nullrev to include it as a possibility
             graphnodes = range(nullrev, len(graph))
             bases = samplerevs(graphnodes)
             revs = samplerevs(graphnodes)
 
             # fast algorithm
-            h = ancestor.missingancestors(revs, bases, graph.__getitem__)
+            inc = ancestor.incrementalmissingancestors(graph.__getitem__, bases)
+            h = inc.missingancestors(revs)
             # reference slow algorithm
             r = naivemissingancestors(ancs, revs, bases)
             if h != r:
                 err(seed, graph, bases, revs, h, r)
 
 # graph is a dict of child->parent adjacency lists for this graph:
 # o  13
 # |
 # | o  12
 # | |
 # | | o    11
 # | | |\
 # | | | | o  10
 # | | | | |
 # | o---+ |  9
 # | | | | |
 # o | | | |  8
 #  / / / /
 # | | o |  7
 # | | | |
 # o---+ |  6
 #  / / /
 # | | o  5
 # | |/
 # | o  4
 # | |
 # o |  3
 # | |
 # | o  2
 # |/
 # o  1
 # |
 # o  0
 
 graph = {0: [-1], 1: [0], 2: [1], 3: [1], 4: [2], 5: [4], 6: [4],
          7: [4], 8: [-1], 9: [6, 7], 10: [5], 11: [3, 7], 12: [9],
          13: [8]}
 
 def genlazyancestors(revs, stoprev=0, inclusive=False):
     print ("%% lazy ancestor set for %s, stoprev = %s, inclusive = %s" %
            (revs, stoprev, inclusive))
     return ancestor.lazyancestors(graph.get, revs, stoprev=stoprev,
                                   inclusive=inclusive)
 
 def printlazyancestors(s, l):
     print 'membership: %r' % [n for n in l if n in s]
     print 'iteration:  %r' % list(s)
 
 def test_lazyancestors():
     # Empty revs
     s = genlazyancestors([])
     printlazyancestors(s, [3, 0, -1])
 
     # Standard example
     s = genlazyancestors([11, 13])
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
 
     # Standard with ancestry in the initial set (1 is ancestor of 3)
     s = genlazyancestors([1, 3])
     printlazyancestors(s, [1, -1, 0])
 
     # Including revs
     s = genlazyancestors([11, 13], inclusive=True)
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
 
     # Test with stoprev
     s = genlazyancestors([11, 13], stoprev=6)
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
     s = genlazyancestors([11, 13], stoprev=6, inclusive=True)
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
 
 
 # The C gca algorithm requires a real repo. These are textual descriptions of
 # DAGs that have been known to be problematic.
 dagtests = [
     '+2*2*2/*3/2',
     '+3*3/*2*2/*4*4/*4/2*4/2*2',
 ]
 def test_gca():
     u = ui.ui()
     for i, dag in enumerate(dagtests):
         repo = hg.repository(u, 'gca%d' % i, create=1)
         cl = repo.changelog
         if not util.safehasattr(cl.index, 'ancestors'):
             # C version not available
             return
 
         commands.debugbuilddag(u, repo, dag)
         # Compare the results of the Python and C versions. This does not
         # include choosing a winner when more than one gca exists -- we make
         # sure both return exactly the same set of gcas.
         for a in cl:
             for b in cl:
                 cgcas = sorted(cl.index.ancestors(a, b))
                 pygcas = sorted(ancestor.ancestors(cl.parentrevs, a, b))
                 if cgcas != pygcas:
                     print "test_gca: for dag %s, gcas for %d, %d:" % (dag, a, b)
                     print "  C returned:      %s" % cgcas
                     print "  Python returned: %s" % pygcas
 
 def main():
     seed = None
     opts, args = getopt.getopt(sys.argv[1:], 's:', ['seed='])
     for o, a in opts:
         if o in ('-s', '--seed'):
             seed = long(a, base=0) # accepts base 10 or 16 strings
 
     if seed is None:
         try:
             seed = long(binascii.hexlify(os.urandom(16)), 16)
         except AttributeError:
             seed = long(time.time() * 1000)
 
     rng = random.Random(seed)
     test_missingancestors(seed, rng)
     test_lazyancestors()
     test_gca()
 
 if __name__ == '__main__':
     main()