mercurial-scm/hg: comparison mercurial/revlogutils/deltas.py

equal deleted inserted replaced

-:9cac281eb9c0
+:35d4c2124073
 good = None
 deltas_limit = textlen * LIMIT_DELTA2TEXT
 tested = {nullrev}
-candidates = _refinedgroups(revlog, p1, p2, cachedelta)
+candidates = _refinedgroups(
+revlog,
+p1,
+p2,
+cachedelta,
+)
 while True:
 temptative = candidates.send(good)
 if temptative is None:
 break
 group = []
 if sparse and revlog.rawsize(rev) < (textlen // LIMIT_BASE2TEXT):
 continue
 # no delta for rawtext-changing revs (see "candelta" for why)
 if revlog.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS:
 continue
 # If we reach here, we are about to build and test a delta.
 # The delta building process will compute the chaininfo in all
 # case, since that computation is cached, it is fine to access it
 # here too.
 chainlen, chainsize = revlog._chaininfo(rev)
 # (or from the source revlog)
 #
 # This logic only applies to general delta repositories and can be disabled
 # through configuration. Disabling reuse source delta is useful when
 # we want to make sure we recomputed "optimal" deltas.
+debug_info = None
 if cachedelta and revlog._generaldelta and revlog._lazydeltabase:
 # Assume what we received from the server is a good choice
 # build delta will reuse the cache
+if debug_info is not None:
+debug_info['cached-delta.tested'] += 1
 good = yield (cachedelta[0],)
 if good is not None:
+if debug_info is not None:
+debug_info['cached-delta.accepted'] += 1
 yield None
 return
+# XXX cache me higher
 snapshots = collections.defaultdict(list)
-for candidates in _rawgroups(revlog, p1, p2, cachedelta, snapshots):
+groups = _rawgroups(
+revlog,
+p1,
+p2,
+cachedelta,
+snapshots,
+)
+for candidates in groups:
 good = yield candidates
 if good is not None:
 break
 # If sparse revlog is enabled, we can try to refine the available deltas
 while good != previous:
 previous = good
 children = tuple(sorted(c for c in snapshots[good]))
 good = yield children
-# we have found nothing
+if debug_info is not None:
+if good is None:
+debug_info['no-solution'] += 1
 yield None
 def _rawgroups(revlog, p1, p2, cachedelta, snapshots=None):
 """Provides group of revision to be tested as delta base
 # fulltext.
 yield (prev,)
 class deltacomputer:
-def __init__(self, revlog, write_debug=None, debug_search=False):
+def __init__(
+self,
+revlog,
+write_debug=None,
+debug_search=False,
+debug_info=None,
+):
 self.revlog = revlog
 self._write_debug = write_debug
 self._debug_search = debug_search
+self._debug_info = debug_info
 def buildtext(self, revinfo, fh):
 """Builds a fulltext version of a revision
 revinfo: revisioninfo instance that contains all needed info
 # not calling candelta since only one revision needs test, also to
 # avoid overhead fetching flags again.
 if revinfo.flags & REVIDX_RAWTEXT_CHANGING_FLAGS:
 return self._fullsnapshotinfo(fh, revinfo, target_rev)
-if self._write_debug is not None:
+gather_debug = (
+self._write_debug is not None or self._debug_info is not None
+)
+debug_search = self._write_debug is not None and self._debug_search
+if gather_debug:
 start = util.timer()
-debug_search = self._write_debug is not None and self._debug_search
 # count the number of different delta we tried (for debug purpose)
 dbg_try_count = 0
 # count the number of "search round" we did. (for debug purpose)
 dbg_try_rounds = 0
 revlog = self.revlog
 deltainfo = None
 p1r, p2r = revlog.rev(p1), revlog.rev(p2)
-if self._write_debug is not None:
+if gather_debug:
 if p1r != nullrev:
 p1_chain_len = revlog._chaininfo(p1r)[0]
 else:
 p1_chain_len = -1
 if p2r != nullrev:
 elif deltainfo.snapshotdepth:  # pytype: disable=attribute-error
 dbg_type = b"snapshot"
 else:
 dbg_type = b"delta"
-if self._write_debug is not None:
+if gather_debug:
 end = util.timer()
-assert deltainfo is not None  # please pytype
 used_cached = (
 cachedelta is not None
 and dbg_try_rounds == 1
 and dbg_try_count == 1
 and deltainfo.base == cachedelta[0]
 )
 dbg = {
 'duration': end - start,
 'revision': target_rev,
-'delta-base': deltainfo.base,
+'delta-base': deltainfo.base,  # pytype: disable=attribute-error
 'search_round_count': dbg_try_rounds,
 'using-cached-base': used_cached,
 'delta_try_count': dbg_try_count,
 'type': dbg_type,
 'p1-chain-len': p1_chain_len,
 target_revlog = b'FILELOG:'
 if target_key:
 target_revlog += b'%s:' % target_key
 dbg['target-revlog'] = target_revlog
-msg = (
+if self._debug_info is not None:
-b"DBG-DELTAS:"
+self._debug_info.append(dbg)
-b" %-12s"
-b" rev=%d:"
+if self._write_debug is not None:
-b" delta-base=%d"
+msg = (
-b" is-cached=%d"
+b"DBG-DELTAS:"
-b" - search-rounds=%d"
+b" %-12s"
-b" try-count=%d"
+b" rev=%d:"
-b" - delta-type=%-6s"
+b" delta-base=%d"
-b" snap-depth=%d"
+b" is-cached=%d"
-b" - p1-chain-length=%d"
+b" - search-rounds=%d"
-b" p2-chain-length=%d"
+b" try-count=%d"
-b" - duration=%f"
+b" - delta-type=%-6s"
-b"\n"
+b" snap-depth=%d"
-)
+b" - p1-chain-length=%d"
-msg %= (
+b" p2-chain-length=%d"
-dbg["target-revlog"],
+b" - duration=%f"
-dbg["revision"],
+b"\n"
-dbg["delta-base"],
+)
-dbg["using-cached-base"],
+msg %= (
-dbg["search_round_count"],
+dbg["target-revlog"],
-dbg["delta_try_count"],
+dbg["revision"],
-dbg["type"],
+dbg["delta-base"],
-dbg["snapshot-depth"],
+dbg["using-cached-base"],
-dbg["p1-chain-len"],
+dbg["search_round_count"],
-dbg["p2-chain-len"],
+dbg["delta_try_count"],
-dbg["duration"],
+dbg["type"],
-)
+dbg["snapshot-depth"],
-self._write_debug(msg)
+dbg["p1-chain-len"],
+dbg["p2-chain-len"],
+dbg["duration"],
+)
+self._write_debug(msg)
 return deltainfo
 def delta_compression(default_compression_header, deltainfo):
 """return (COMPRESSION_MODE, deltainfo)

changeset 49610	35d4c2124073
parent 49608	78ba41878f2e
child 49611	2afee2176775