comparison hgext/convert/hg.py @ 24395:216fa1ba9993

convert: optimize convert of files that are unmodified from p2 in merges

Conversion of a merge starts with p1 and re-adds the files that were changed in
the merge or came unmodified from p2. Files that are unmodified from p1 will
thus not be touched and take no time. Files that are unmodified from p2 would be
retrieved and rehashed. They would end up getting the same hash as in p2 and end
up reusing the filelog entry and look like the p1 case ... but it was slow.

Instead, make getchanges also return 'files that are unmodified from p2' so the
sink can reuse the existing p2 entry instead of calling getfile.

Reuse of filelog entries can make a big difference when files are big and with
long revlong chains so they take time to retrieve and hash, or when using an
expensive custom getfile function (think
http://mercurial.selenic.com/wiki/ConvertExtension#Customization with a code
reformatter).

This in combination with changes to reuse filectx entries in
localrepo._filecommit make 'unchanged from p2' almost as fast as 'unchanged
from p1'.

This is so far only implemented for the combination of hg source and hg sink.

This is a refactoring/optimization. It is covered by existing tests and show no
changes - which is a good thing.

24394:03163826b4e6

            if not revid:
                continue
            fp.write('%s %s\n' % (revid, s[1]))
        return fp.getvalue()

    def putcommit(self, files, copies, parents, commit, source, revmap, full):
        files = dict(files)
        def getfilectx(repo, memctx, f):
            try:
                v = files[f]
            except KeyError:
                return None
            data, mode = source.getfile(f, v)

            extra['convert_revision'] = commit.rev

        while parents:
            p1 = p2
            p2 = parents.pop(0)
            fileset = set(files)
            if full:
                fileset.update(self.repo[p1])
                fileset.update(self.repo[p2])
            ctx = context.memctx(self.repo, (p1, p2), text, fileset,

                files = m + a + r
            copyfiles = m + a
        # getcopies() is also run for roots and before filtering so missing
        # revlogs are detected early
        copies = self.getcopies(ctx, parents, copyfiles)
        changes = [(f, rev) for f in files if f not in self.ignored]
        changes.sort()
        return changes, copies

    def getcopies(self, ctx, parents, files):
        copies = {}
        for name in files:
            if name in self.ignored:

24395:216fa1ba9993

            if not revid:
                continue
            fp.write('%s %s\n' % (revid, s[1]))
        return fp.getvalue()

    def putcommit(self, files, copies, parents, commit, source, revmap, full,
                  cleanp2):
        files = dict(files)

        def getfilectx(repo, memctx, f):
            if p2ctx and f in cleanp2 and f not in copies:
                self.ui.debug('reusing %s from p2\n' % f)
                return p2ctx[f]
            try:
                v = files[f]
            except KeyError:
                return None
            data, mode = source.getfile(f, v)

            extra['convert_revision'] = commit.rev

        while parents:
            p1 = p2
            p2 = parents.pop(0)
            p2ctx = None
            if p2 != nullid:
                p2ctx = self.repo[p2]
            fileset = set(files)
            if full:
                fileset.update(self.repo[p1])
                fileset.update(self.repo[p2])
            ctx = context.memctx(self.repo, (p1, p2), text, fileset,

                files = m + a + r
            copyfiles = m + a
        # getcopies() is also run for roots and before filtering so missing
        # revlogs are detected early
        copies = self.getcopies(ctx, parents, copyfiles)
        cleanp2 = set()
        if len(parents) == 2:
            cleanp2.update(self.repo.status(parents[1].node(), ctx.node(),
                                            clean=True).clean)
        changes = [(f, rev) for f in files if f not in self.ignored]
        changes.sort()
        return changes, copies, cleanp2

    def getcopies(self, ctx, parents, files):
        copies = {}
        for name in files:
            if name in self.ignored: