mercurial-scm/evolve: hgext3rd/pullbundle.py comparison

comparison hgext3rd/pullbundle.py @ 4138:cfdc6f55599b

pullbundle: improve slicing of the lower part of range The previous method could get confuse by merge and overslice. The new method is better at using sticking on power of two boundaries.

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Tue, 25 Sep 2018 12:20:26 +0200
parents	be3a94d3105f
children	2bd652bece97

comparison

equal deleted inserted replaced

-:21a3c051ca6c
+:cfdc6f55599b
 nodes.reverse()
 for rangeid in subranges:
 size = rangelength(rangeid)
 slices.append((rangeid, nodes[idx:idx + size]))
 idx += size
+### slow code block to validate ranges content
+# rev = repo.changelog.nodemap.get
+# for ri, ns in slices:
+#     a = set(rev(n) for n in ns)
+#     b = set(repo.stablerange.revsfromrange(repo, ri))
+#     l = repo.stablerange.rangelength(repo, ri)
+#     repo.ui.write('range-length: %d-%d %s %s\n' % (ri[0], ri[1], l, len(a)))
+#     if a != b:
+#         d =  (ri[0], ri[1], b - a, a - b)
+#         repo.ui.write("mismatching content: %d-%d -%s +%s\n" % d)
 return slices
 def canonicalsubranges(repo, stablerange, rangeid):
 """slice a size of nodes into most reusable subranges
 break
 cursor //= 2
 # 2. optimise, bottom part
 if skip != cut:
-tailranges = []
+currentsize = tailsize = cut - skip
-tailsize = cut - skip
 assert 0 < tailsize, tailsize
+# we need to take several "standard cut" in the bottom part
+#
+# This is similar to what we will do for the top part, we reusing the
+# existing structure is a bit more complex.
+allcuts = list(reversed(standardcut(tailsize)))
 prerange = (headrev, precut)
-size = stablerange.rangelength(repo, prerange)
+### slow code block to check we operate on the right data
-sub = stablerange.subranges(repo, prerange)[:-1]
+# rev = repo.changelog.nodemap.get
-# This power of two check is too simplistic and misbehave when too many
+# allrevs = [rev(n) for n in nodes]
-# merge are involved. because de merge, there can be "canonical" range
+# allrevs.reverse()
-# with various size.
+# prerevs = repo.stablerange.revsfromrange(repo, prerange)
-while not poweroftwo(tailsize):
+# assert allrevs == prerevs[(len(prerevs) - len(allrevs)):]
-for prerange in reversed(sub):
+# end of check
-if tailsize <= 0:
+sub = list(stablerange.subranges(repo, prerange)[:-1])
-break
+bottomranges = []
-assert stablerange.depthrev(repo, prerange[0]) != prerange[1], prerange
+# XXX we might be able to reuse core stable-range logic instead of
-tailrev, tailskip = prerange
+# redoing this manually
-size = stablerange.rangelength(repo, (tailrev, tailskip))
+currentrange = sub.pop()
-if tailsize < size:
+currentsize = stablerange.rangelength(repo, currentrange)
-tailskip += size - tailsize
+currentcut = None
-size = tailsize
+while allcuts or currentcut is not None:
-tailranges.append((tailrev, tailskip))
+# get the next cut if needed
-tailsize -= size
+if currentcut is None:
-else:
+currentcut = allcuts.pop()
-# size of the last block
+# deal attemp a cut
-tailsize = stablerange.rangelength(repo, tailranges[-1])
+if currentsize == currentcut:
-if poweroftwo(tailsize):
+bottomranges.append(currentrange)
-continue # exit the loop
+currentcut = None
-prerange = tailranges.pop()
+elif currentsize < currentcut:
-sub = stablerange.subranges(repo, prerange)
+bottomranges.append(currentrange)
+currentcut -= currentsize
-tailranges.reverse()
+else: # currentsize > currentcut
-canonicals.extend(tailranges)
+newskip = currentrange[1] + (currentsize - currentcut)
+currentsub = stablerange._slicesrangeat(repo, currentrange, newskip)
+bottomranges.append(currentsub.pop())
+sub.extend(currentsub)
+currentcut = None
+currentrange = sub.pop()
+currentsize = stablerange.rangelength(repo, currentrange)
+bottomranges.reverse()
+canonicals.extend(bottomranges)
 # 3. take recursive subrange until we get to a power of two size?
 current = (headrev, cut)
 while not poweroftwo(stablerange.rangelength(repo, current)):
 sub = stablerange.subranges(repo, current)
 canonicals.extend(sub[:-1])
 current = sub[-1]
 canonicals.append(current)
 return canonicals
+def standardcut(size):
+assert 0 < size
+# 0. find the first power of 2 higher than this range depth
+cut = 1
+while cut <= size:
+cut *= 2
+allcuts = []
+# 1. find all standard expected cut
+while 1 < cut and size:
+cut //= 2
+if cut <= size:
+allcuts.append(cut)
+size -= cut
+return allcuts
 def poweroftwo(num):
 return num and not num & (num - 1)
 def outgoingfromnodes(repo, nodes):

Mercurial > public > mercurial-scm > evolve

comparison hgext3rd/pullbundle.py @ 4138:cfdc6f55599b