mercurial/revlogutils/deltas.py
branchstable
changeset 50378 c84cc0ac77e4
parent 50377 5d210ff4b657
child 50379 4d84b6d52e93
equal deleted inserted replaced
50377:5d210ff4b657 50378:c84cc0ac77e4
  1085         debug_search=False,
  1085         debug_search=False,
  1086         debug_info=None,
  1086         debug_info=None,
  1087     ):
  1087     ):
  1088         self.revlog = revlog
  1088         self.revlog = revlog
  1089         self._write_debug = write_debug
  1089         self._write_debug = write_debug
  1090         self._debug_search = debug_search
  1090         if write_debug is None:
       
  1091             self._debug_search = False
       
  1092         else:
       
  1093             self._debug_search = debug_search
  1091         self._debug_info = debug_info
  1094         self._debug_info = debug_info
  1092         self._snapshot_cache = SnapshotCache()
  1095         self._snapshot_cache = SnapshotCache()
  1093 
  1096 
  1094     @property
  1097     @property
  1095     def _gather_debug(self):
  1098     def _gather_debug(self):
  1138         return delta
  1141         return delta
  1139 
  1142 
  1140     def _builddeltainfo(self, revinfo, base, fh, target_rev=None):
  1143     def _builddeltainfo(self, revinfo, base, fh, target_rev=None):
  1141         # can we use the cached delta?
  1144         # can we use the cached delta?
  1142         revlog = self.revlog
  1145         revlog = self.revlog
  1143         debug_search = self._write_debug is not None and self._debug_search
       
  1144         chainbase = revlog.chainbase(base)
  1146         chainbase = revlog.chainbase(base)
  1145         if revlog._generaldelta:
  1147         if revlog._generaldelta:
  1146             deltabase = base
  1148             deltabase = base
  1147         else:
  1149         else:
  1148             if target_rev is not None and base != target_rev - 1:
  1150             if target_rev is not None and base != target_rev - 1:
  1175                 currentbase = self.revlog.deltaparent(currentbase)
  1177                 currentbase = self.revlog.deltaparent(currentbase)
  1176             if self.revlog._lazydelta and currentbase == base:
  1178             if self.revlog._lazydelta and currentbase == base:
  1177                 delta = revinfo.cachedelta[1]
  1179                 delta = revinfo.cachedelta[1]
  1178         if delta is None:
  1180         if delta is None:
  1179             delta = self._builddeltadiff(base, revinfo, fh)
  1181             delta = self._builddeltadiff(base, revinfo, fh)
  1180         if debug_search:
  1182         if self._debug_search:
  1181             msg = b"DBG-DELTAS-SEARCH:     uncompressed-delta-size=%d\n"
  1183             msg = b"DBG-DELTAS-SEARCH:     uncompressed-delta-size=%d\n"
  1182             msg %= len(delta)
  1184             msg %= len(delta)
  1183             self._write_debug(msg)
  1185             self._write_debug(msg)
  1184         # snapshotdept need to be neither None nor 0 level snapshot
  1186         # snapshotdept need to be neither None nor 0 level snapshot
  1185         if revlog.upperboundcomp is not None and snapshotdepth:
  1187         if revlog.upperboundcomp is not None and snapshotdepth:
  1186             lowestrealisticdeltalen = len(delta) // revlog.upperboundcomp
  1188             lowestrealisticdeltalen = len(delta) // revlog.upperboundcomp
  1187             snapshotlimit = revinfo.textlen >> snapshotdepth
  1189             snapshotlimit = revinfo.textlen >> snapshotdepth
  1188             if debug_search:
  1190             if self._debug_search:
  1189                 msg = b"DBG-DELTAS-SEARCH:     projected-lower-size=%d\n"
  1191                 msg = b"DBG-DELTAS-SEARCH:     projected-lower-size=%d\n"
  1190                 msg %= lowestrealisticdeltalen
  1192                 msg %= lowestrealisticdeltalen
  1191                 self._write_debug(msg)
  1193                 self._write_debug(msg)
  1192             if snapshotlimit < lowestrealisticdeltalen:
  1194             if snapshotlimit < lowestrealisticdeltalen:
  1193                 if debug_search:
  1195                 if self._debug_search:
  1194                     msg = b"DBG-DELTAS-SEARCH:     DISCARDED (snapshot limit)\n"
  1196                     msg = b"DBG-DELTAS-SEARCH:     DISCARDED (snapshot limit)\n"
  1195                     self._write_debug(msg)
  1197                     self._write_debug(msg)
  1196                 return None
  1198                 return None
  1197             if revlog.length(base) < lowestrealisticdeltalen:
  1199             if revlog.length(base) < lowestrealisticdeltalen:
  1198                 if debug_search:
  1200                 if self._debug_search:
  1199                     msg = b"DBG-DELTAS-SEARCH:     DISCARDED (prev size)\n"
  1201                     msg = b"DBG-DELTAS-SEARCH:     DISCARDED (prev size)\n"
  1200                     self._write_debug(msg)
  1202                     self._write_debug(msg)
  1201                 return None
  1203                 return None
  1202         header, data = revlog.compress(delta)
  1204         header, data = revlog.compress(delta)
  1203         deltalen = len(header) + len(data)
  1205         deltalen = len(header) + len(data)
  1267         # not calling candelta since only one revision needs test, also to
  1269         # not calling candelta since only one revision needs test, also to
  1268         # avoid overhead fetching flags again.
  1270         # avoid overhead fetching flags again.
  1269         if revinfo.flags & REVIDX_RAWTEXT_CHANGING_FLAGS:
  1271         if revinfo.flags & REVIDX_RAWTEXT_CHANGING_FLAGS:
  1270             return self._fullsnapshotinfo(fh, revinfo, target_rev)
  1272             return self._fullsnapshotinfo(fh, revinfo, target_rev)
  1271 
  1273 
  1272         debug_search = self._write_debug is not None and self._debug_search
       
  1273         gather_debug = self._gather_debug
  1274         gather_debug = self._gather_debug
  1274 
  1275 
  1275         if gather_debug:
  1276         if gather_debug:
  1276             start = util.timer()
  1277             start = util.timer()
  1277 
  1278 
  1296                 p1_chain_len = -1
  1297                 p1_chain_len = -1
  1297             if p2r != nullrev:
  1298             if p2r != nullrev:
  1298                 p2_chain_len = revlog._chaininfo(p2r)[0]
  1299                 p2_chain_len = revlog._chaininfo(p2r)[0]
  1299             else:
  1300             else:
  1300                 p2_chain_len = -1
  1301                 p2_chain_len = -1
  1301         if debug_search:
  1302         if self._debug_search:
  1302             msg = b"DBG-DELTAS-SEARCH: SEARCH rev=%d\n"
  1303             msg = b"DBG-DELTAS-SEARCH: SEARCH rev=%d\n"
  1303             msg %= target_rev
  1304             msg %= target_rev
  1304             self._write_debug(msg)
  1305             self._write_debug(msg)
  1305 
  1306 
  1306         groups = _candidategroups(
  1307         groups = _candidategroups(
  1314             snapshot_cache=self._snapshot_cache,
  1315             snapshot_cache=self._snapshot_cache,
  1315         )
  1316         )
  1316         candidaterevs = next(groups)
  1317         candidaterevs = next(groups)
  1317         while candidaterevs is not None:
  1318         while candidaterevs is not None:
  1318             dbg_try_rounds += 1
  1319             dbg_try_rounds += 1
  1319             if debug_search:
  1320             if self._debug_search:
  1320                 prev = None
  1321                 prev = None
  1321                 if deltainfo is not None:
  1322                 if deltainfo is not None:
  1322                     prev = deltainfo.base
  1323                     prev = deltainfo.base
  1323 
  1324 
  1324                 if (
  1325                 if (
  1338                 msg = b"DBG-DELTAS-SEARCH: ROUND #%d - %d candidates - %s\n"
  1339                 msg = b"DBG-DELTAS-SEARCH: ROUND #%d - %d candidates - %s\n"
  1339                 msg %= (dbg_try_rounds, len(candidaterevs), round_type)
  1340                 msg %= (dbg_try_rounds, len(candidaterevs), round_type)
  1340                 self._write_debug(msg)
  1341                 self._write_debug(msg)
  1341             nominateddeltas = []
  1342             nominateddeltas = []
  1342             if deltainfo is not None:
  1343             if deltainfo is not None:
  1343                 if debug_search:
  1344                 if self._debug_search:
  1344                     msg = (
  1345                     msg = (
  1345                         b"DBG-DELTAS-SEARCH:   CONTENDER: rev=%d - length=%d\n"
  1346                         b"DBG-DELTAS-SEARCH:   CONTENDER: rev=%d - length=%d\n"
  1346                     )
  1347                     )
  1347                     msg %= (deltainfo.base, deltainfo.deltalen)
  1348                     msg %= (deltainfo.base, deltainfo.deltalen)
  1348                     self._write_debug(msg)
  1349                     self._write_debug(msg)
  1349                 # if we already found a good delta,
  1350                 # if we already found a good delta,
  1350                 # challenge it against refined candidates
  1351                 # challenge it against refined candidates
  1351                 nominateddeltas.append(deltainfo)
  1352                 nominateddeltas.append(deltainfo)
  1352             for candidaterev in candidaterevs:
  1353             for candidaterev in candidaterevs:
  1353                 if debug_search:
  1354                 if self._debug_search:
  1354                     msg = b"DBG-DELTAS-SEARCH:   CANDIDATE: rev=%d\n"
  1355                     msg = b"DBG-DELTAS-SEARCH:   CANDIDATE: rev=%d\n"
  1355                     msg %= candidaterev
  1356                     msg %= candidaterev
  1356                     self._write_debug(msg)
  1357                     self._write_debug(msg)
  1357                     candidate_type = None
  1358                     candidate_type = None
  1358                     if candidaterev == p1:
  1359                     if candidaterev == p1:
  1376                     msg %= self.revlog.deltaparent(candidaterev)
  1377                     msg %= self.revlog.deltaparent(candidaterev)
  1377                     self._write_debug(msg)
  1378                     self._write_debug(msg)
  1378 
  1379 
  1379                 dbg_try_count += 1
  1380                 dbg_try_count += 1
  1380 
  1381 
  1381                 if debug_search:
  1382                 if self._debug_search:
  1382                     delta_start = util.timer()
  1383                     delta_start = util.timer()
  1383                 candidatedelta = self._builddeltainfo(
  1384                 candidatedelta = self._builddeltainfo(
  1384                     revinfo,
  1385                     revinfo,
  1385                     candidaterev,
  1386                     candidaterev,
  1386                     fh,
  1387                     fh,
  1387                     target_rev=target_rev,
  1388                     target_rev=target_rev,
  1388                 )
  1389                 )
  1389                 if debug_search:
  1390                 if self._debug_search:
  1390                     delta_end = util.timer()
  1391                     delta_end = util.timer()
  1391                     msg = b"DBG-DELTAS-SEARCH:     delta-search-time=%f\n"
  1392                     msg = b"DBG-DELTAS-SEARCH:     delta-search-time=%f\n"
  1392                     msg %= delta_end - delta_start
  1393                     msg %= delta_end - delta_start
  1393                     self._write_debug(msg)
  1394                     self._write_debug(msg)
  1394                 if candidatedelta is not None:
  1395                 if candidatedelta is not None:
  1395                     if is_good_delta_info(self.revlog, candidatedelta, revinfo):
  1396                     if is_good_delta_info(self.revlog, candidatedelta, revinfo):
  1396                         if debug_search:
  1397                         if self._debug_search:
  1397                             msg = b"DBG-DELTAS-SEARCH:     DELTA: length=%d (GOOD)\n"
  1398                             msg = b"DBG-DELTAS-SEARCH:     DELTA: length=%d (GOOD)\n"
  1398                             msg %= candidatedelta.deltalen
  1399                             msg %= candidatedelta.deltalen
  1399                             self._write_debug(msg)
  1400                             self._write_debug(msg)
  1400                         nominateddeltas.append(candidatedelta)
  1401                         nominateddeltas.append(candidatedelta)
  1401                     elif debug_search:
  1402                     elif self._debug_search:
  1402                         msg = b"DBG-DELTAS-SEARCH:     DELTA: length=%d (BAD)\n"
  1403                         msg = b"DBG-DELTAS-SEARCH:     DELTA: length=%d (BAD)\n"
  1403                         msg %= candidatedelta.deltalen
  1404                         msg %= candidatedelta.deltalen
  1404                         self._write_debug(msg)
  1405                         self._write_debug(msg)
  1405                 elif debug_search:
  1406                 elif self._debug_search:
  1406                     msg = b"DBG-DELTAS-SEARCH:     NO-DELTA\n"
  1407                     msg = b"DBG-DELTAS-SEARCH:     NO-DELTA\n"
  1407                     self._write_debug(msg)
  1408                     self._write_debug(msg)
  1408             if nominateddeltas:
  1409             if nominateddeltas:
  1409                 deltainfo = min(nominateddeltas, key=lambda x: x.deltalen)
  1410                 deltainfo = min(nominateddeltas, key=lambda x: x.deltalen)
  1410             if deltainfo is not None:
  1411             if deltainfo is not None: