comparison mercurial/revlogutils/deltas.py @ 51356:701caeabbee7

delta-find: finish reworking the snapshot logic and drop more layer

The refining logic only applies to the snapshot logic, and this is now all
contained in a dedicated method.

Along the way, we drop the refined_groups // raw_groups layer as they no longer
make sense. The result is a more explicit `iter_groups` method.

This conclude the splitting and simplification of the groups generation.

We are now ready to dispatch this in more diverse classes.

51355:fac6038b11f5

    def _init_group(self):
        # Why search for delta base if we cannot use a delta base ?
        # also see issue6056
        assert self.revlog.delta_config.general_delta
        self._candidates_iterator = self._refined_groups()
        self._last_good = None
        if (
            self.cachedelta is not None
            and self.cachedelta[2] > DELTA_BASE_REUSE_NO
            and self._pre_filter_rev(self.cachedelta[0])

        self.current_stage = _STAGE_PREV
        yield (self.target_rev - 1,)

    def _iter_snapshots_base(self):
        assert self.revlog.delta_config.sparse_revlog
        prev = self.target_rev - 1
        deltachain = lambda rev: self.revlog._deltachain(rev)[0]

        parents = [p for p in (self.p1, self.p2) if p != nullrev]
        if not parents:
            return
        self.current_stage = _STAGE_SNAPSHOT
        # See if we can use an existing snapshot in the parent chains to
        # use as a base for a new intermediate-snapshot
        #
        # search for snapshot in parents delta chain map: snapshot-level:
        # snapshot-rev

        full = [
            r for r in self.snapshot_cache.snapshots[nullrev] if snapfloor <= r
        ]
        yield tuple(sorted(full))

    def _refined_groups(self):
        good = None
        groups = self._raw_groups()
        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
        if not self.revlog.delta_config.sparse_revlog:
            self.current_stage = _STAGE_FULL
            yield None
            return

        # if we have a refinable value, try to refine it
        if (
            good is not None
            and good not in (self.p1, self.p2)
            and self.revlog.issnapshot(good)

                previous = good
                children = tuple(
                    sorted(c for c in self.snapshot_cache.snapshots[good])
                )
                good = yield children

        self.current_stage = _STAGE_FULL
        yield None

    def _raw_groups(self):
        """Provides group of revision to be tested as delta base

        This lower level function focus on emitting delta theorically
        interresting without looking it any practical details.

        The group order aims at providing fast or small candidates first.
        """
        yield from self._iter_parents()
        if self.revlog.delta_config.sparse_revlog:
            yield from self._iter_snapshots_base()
        else:
            yield from self._iter_prev()


class SnapshotCache:
    __slots__ = ('snapshots', '_start_rev', '_end_rev')

51356:701caeabbee7

    def _init_group(self):
        # Why search for delta base if we cannot use a delta base ?
        # also see issue6056
        assert self.revlog.delta_config.general_delta
        self._candidates_iterator = self._iter_groups()
        self._last_good = None
        if (
            self.cachedelta is not None
            and self.cachedelta[2] > DELTA_BASE_REUSE_NO
            and self._pre_filter_rev(self.cachedelta[0])

        self.current_stage = _STAGE_PREV
        yield (self.target_rev - 1,)

    def _iter_snapshots_base(self):
        assert self.revlog.delta_config.sparse_revlog
        assert self.current_stage == _STAGE_SNAPSHOT
        prev = self.target_rev - 1
        deltachain = lambda rev: self.revlog._deltachain(rev)[0]

        parents = [p for p in (self.p1, self.p2) if p != nullrev]
        if not parents:
            return
        # See if we can use an existing snapshot in the parent chains to
        # use as a base for a new intermediate-snapshot
        #
        # search for snapshot in parents delta chain map: snapshot-level:
        # snapshot-rev

        full = [
            r for r in self.snapshot_cache.snapshots[nullrev] if snapfloor <= r
        ]
        yield tuple(sorted(full))

    def _iter_snapshots(self):
        assert self.revlog.delta_config.sparse_revlog
        self.current_stage = _STAGE_SNAPSHOT
        good = None
        groups = self._iter_snapshots_base()
        for candidates in groups:
            good = yield candidates
            if good is not None:
                break
        # if we have a refinable value, try to refine it
        if (
            good is not None
            and good not in (self.p1, self.p2)
            and self.revlog.issnapshot(good)

                previous = good
                children = tuple(
                    sorted(c for c in self.snapshot_cache.snapshots[good])
                )
                good = yield children
        yield None

    def _iter_groups(self):
        good = None
        for group in self._iter_parents():
            good = yield group
            if good is not None:
                break
        else:
            assert good is None
            if self.revlog.delta_config.sparse_revlog:
                # If sparse revlog is enabled, we can try to refine the
                # available deltas
                iter_snap = self._iter_snapshots()
                group = iter_snap.send(None)
                while group is not None:
                    good = yield group
                    group = iter_snap.send(good)
            else:
                yield from self._iter_prev()
        yield None


class SnapshotCache:
    __slots__ = ('snapshots', '_start_rev', '_end_rev')