( )⚙ D3993 linelog: add replacelines_vec for fastannotate

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3993

linelog: add replacelines_vec for fastannotate
ClosedPublic

Authored by durin42 on Aug 1 2018, 11:17 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG6fed8b323651: linelog: add replacelines_vec for fastannotate
Summary
  1. no-check-commit because we're conforming to an existing interface

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/linelog.py (11 lines)
Mtests/test-linelog.py (21 lines)

Diff 9684

mercurial/linelog.py

hdr = _jge(self._maxrev, len(self._program)).encode() hdr = _jge(self._maxrev, len(self._program)).encode()
return hdr + ''.join(i.encode() for i in self._program[1:]) return hdr + ''.join(i.encode() for i in self._program[1:])
def clear(self): def clear(self):
self._program = [] self._program = []
self._maxrev = 0 self._maxrev = 0
self._lastannotate = None self._lastannotate = None
def replacelines(self, rev, a1, a2, b1, b2): def replacelines_vec(self, rev, a1, a2, blines):
return self.replacelines(rev, a1, a2, 0, len(blines),
_internal_blines=blines)
def replacelines(self, rev, a1, a2, b1, b2, _internal_blines=None):
"""Replace lines [a1, a2) with lines [b1, b2).""" """Replace lines [a1, a2) with lines [b1, b2)."""
if self._lastannotate: if self._lastannotate:
# TODO(augie): make replacelines() accept a revision at # TODO(augie): make replacelines() accept a revision at
# which we're editing as well as a revision to mark # which we're editing as well as a revision to mark
# responsible for the edits. In hg-experimental it's # responsible for the edits. In hg-experimental it's
# stateful like this, so we're doing the same thing to # stateful like this, so we're doing the same thing to
# retain compatibility with absorb until that's imported. # retain compatibility with absorb until that's imported.
ar = self._lastannotate ar = self._lastannotate
# insert # insert
if b1 < b2: if b1 < b2:
# Determine the jump target for the JGE at the start of # Determine the jump target for the JGE at the start of
# the new block. # the new block.
tgt = oldproglen + (b2 - b1 + 1) tgt = oldproglen + (b2 - b1 + 1)
# Jump to skip the insert if we're at an older revision. # Jump to skip the insert if we're at an older revision.
appendinst(_jl(rev, tgt)) appendinst(_jl(rev, tgt))
for linenum in range(b1, b2): for linenum in range(b1, b2):
if _internal_blines is None:
appendinst(_line(rev, linenum)) appendinst(_line(rev, linenum))
else:
appendinst(_line(*_internal_blines[linenum]))
# delete # delete
if a1 < a2: if a1 < a2:
if a2 > len(ar.lines): if a2 > len(ar.lines):
raise LineLogError( raise LineLogError(
'%d contains %d lines, tried to access line %d' % ( '%d contains %d lines, tried to access line %d' % (
rev, len(ar.lines), a2)) rev, len(ar.lines), a2))
elif a2 == len(ar.lines): elif a2 == len(ar.lines):
endaddr = ar._eof endaddr = ar._eof

tests/test-linelog.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import difflib import difflib
import random import random
import unittest import unittest
from mercurial import linelog from mercurial import linelog
vecratio = 3 # number of replacelines / number of replacelines_vec
maxlinenum = 0xffffff maxlinenum = 0xffffff
maxb1 = 0xffffff maxb1 = 0xffffff
maxdeltaa = 10 maxdeltaa = 10
maxdeltab = 10 maxdeltab = 10
def _genedits(seed, endrev): def _genedits(seed, endrev):
lines = [] lines = []
random.seed(seed) random.seed(seed)
rev = 0 rev = 0
for rev in range(0, endrev): for rev in range(0, endrev):
n = len(lines) n = len(lines)
a1 = random.randint(0, n) a1 = random.randint(0, n)
a2 = random.randint(a1, min(n, a1 + maxdeltaa)) a2 = random.randint(a1, min(n, a1 + maxdeltaa))
b1 = random.randint(0, maxb1) b1 = random.randint(0, maxb1)
b2 = random.randint(b1, b1 + maxdeltab) b2 = random.randint(b1, b1 + maxdeltab)
blines = [(rev, idx) for idx in range(b1, b2)] usevec = not bool(random.randint(0, vecratio))
if usevec:
blines = [(random.randint(0, rev), random.randint(0, maxlinenum))
for _ in range(b1, b2)]
else:
blines = [(rev, bidx) for bidx in range(b1, b2)]
lines[a1:a2] = blines lines[a1:a2] = blines
yield lines, rev, a1, a2, b1, b2 yield lines, rev, a1, a2, b1, b2, blines, usevec
class linelogtests(unittest.TestCase): class linelogtests(unittest.TestCase):
def testlinelogencodedecode(self): def testlinelogencodedecode(self):
program = [linelog._eof(0, 0), program = [linelog._eof(0, 0),
linelog._jge(41, 42), linelog._jge(41, 42),
linelog._jump(0, 43), linelog._jump(0, 43),
linelog._eof(0, 0), linelog._eof(0, 0),
linelog._jl(44, 45), linelog._jl(44, 45),
[]) [])
def testrandomedits(self): def testrandomedits(self):
# Inspired by original linelog tests. # Inspired by original linelog tests.
seed = random.random() seed = random.random()
numrevs = 2000 numrevs = 2000
ll = linelog.linelog() ll = linelog.linelog()
# Populate linelog # Populate linelog
for lines, rev, a1, a2, b1, b2 in _genedits(seed, numrevs): for lines, rev, a1, a2, b1, b2, blines, usevec in _genedits(
seed, numrevs):
if usevec:
ll.replacelines_vec(rev, a1, a2, blines)
else:
ll.replacelines(rev, a1, a2, b1, b2) ll.replacelines(rev, a1, a2, b1, b2)
ar = ll.annotate(rev) ar = ll.annotate(rev)
self.assertEqual(ll.annotateresult, lines) self.assertEqual(ll.annotateresult, lines)
# Verify we can get back these states by annotating each rev # Verify we can get back these states by annotating each rev
for lines, rev, a1, a2, b1, b2 in _genedits(seed, numrevs): for lines, rev, a1, a2, b1, b2, blines, usevec in _genedits(
seed, numrevs):
ar = ll.annotate(rev) ar = ll.annotate(rev)
self.assertEqual([(l.rev, l.linenum) for l in ar], lines) self.assertEqual([(l.rev, l.linenum) for l in ar], lines)
if __name__ == '__main__': if __name__ == '__main__':
import silenttestrunner import silenttestrunner
silenttestrunner.main(__name__) silenttestrunner.main(__name__)