This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2288

pvec: delete module
AbandonedPublic

Authored by pulkit on Feb 16 2018, 2:40 PM.

Details

Reviewers
martinvonz
Group Reviewers
hg-reviewers
Summary

The pvec module was introduced in 0d175ac527c1 (pvec: introduce pvecs,
2012-03-12), but it seems it was never used. Let's delete it to avoid
wasting time cleaning it up in the future.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

martinvonz created this revision.Feb 16 2018, 2:40 PM
durin42 added a subscriber: durin42.Feb 16 2018, 4:52 PM

So....I actually have an idea involving pvec and obsmarker metadata in hg export output. I'll work on fixing any problems in pvec, can we keep it around a little longer?

martinvonz added a comment.Feb 16 2018, 5:02 PM
In D2288#37819, @durin42 wrote:

So....I actually have an idea involving pvec and obsmarker metadata in hg export output. I'll work on fixing any problems in pvec, can we keep it around a little longer?

Definitely. It hasn't bothered me at all personally. I just saw it in the list of files and wondered what it was.

The first two patches in this series should still make sense.

martinvonz updated this revision to Diff 5789.Feb 16 2018, 5:16 PM
pulkit added a reviewer: martinvonz.Mar 15 2018, 3:17 PM
pulkit commandeered this revision.
pulkit abandoned this revision.

This is not required as @durin42 will like to use pvec.

Revision Contents
Changeset List

PathPackages
Mmercurial/debugcommands.py (22 lines)
DMmercurial/pvec.py (214 lines)
Mtests/test-completion.t (2 lines)
Mtests/test-help.t (1 line)

Diff 5789

mercurial/debugcommands.py

localrepo, localrepo,
lock as lockmod, lock as lockmod,
logcmdutil, logcmdutil,
merge as mergemod, merge as mergemod,
obsolete, obsolete,
obsutil, obsutil,
phases, phases,
policy, policy,
pvec,
pycompat, pycompat,
registrar, registrar,
repair, repair,
revlog, revlog,
revset, revset,
revsetlang, revsetlang,
scmutil, scmutil,
setdiscovery, setdiscovery,
r = target.pushkey(namespace, key, old, new) r = target.pushkey(namespace, key, old, new)
ui.status(str(r) + '\n') ui.status(str(r) + '\n')
return not r return not r
else: else:
for k, v in sorted(target.listkeys(namespace).iteritems()): for k, v in sorted(target.listkeys(namespace).iteritems()):
ui.write("%s\t%s\n" % (util.escapestr(k), ui.write("%s\t%s\n" % (util.escapestr(k),
util.escapestr(v))) util.escapestr(v)))
@command('debugpvec', [], _('A B'))
def debugpvec(ui, repo, a, b=None):
ca = scmutil.revsingle(repo, a)
cb = scmutil.revsingle(repo, b)
pa = pvec.ctxpvec(ca)
pb = pvec.ctxpvec(cb)
if pa == pb:
rel = "="
elif pa > pb:
rel = ">"
elif pa < pb:
rel = "<"
elif pa | pb:
rel = "|"
ui.write(_("a: %s\n") % pa)
ui.write(_("b: %s\n") % pb)
ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
(abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
pa.distance(pb), rel))
@command('debugrebuilddirstate|debugrebuildstate', @command('debugrebuilddirstate|debugrebuildstate',
[('r', 'rev', '', _('revision to rebuild to'), _('REV')), [('r', 'rev', '', _('revision to rebuild to'), _('REV')),
('', 'minimal', None, _('only rebuild files that are inconsistent with ' ('', 'minimal', None, _('only rebuild files that are inconsistent with '
'the working copy parent')), 'the working copy parent')),
], ],
_('[-r REV]')) _('[-r REV]'))
def debugrebuilddirstate(ui, repo, rev, **opts): def debugrebuilddirstate(ui, repo, rev, **opts):
"""rebuild the dirstate as it would look like for the given revision """rebuild the dirstate as it would look like for the given revision

mercurial/pvec.py

  • This file was deleted.
# pvec.py - probabilistic vector clocks for Mercurial
#
# Copyright 2012 Matt Mackall <mpm@selenic.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
'''
A "pvec" is a changeset property based on the theory of vector clocks
that can be compared to discover relatedness without consulting a
graph. This can be useful for tasks like determining how a
disconnected patch relates to a repository.
Currently a pvec consist of 448 bits, of which 24 are 'depth' and the
remainder are a bit vector. It is represented as a 70-character base85
string.
Construction:
- a root changeset has a depth of 0 and a bit vector based on its hash
- a normal commit has a changeset where depth is increased by one and
one bit vector bit is flipped based on its hash
- a merge changeset pvec is constructed by copying changes from one pvec into
the other to balance its depth
Properties:
- for linear changes, difference in depth is always <= hamming distance
- otherwise, changes are probably divergent
- when hamming distance is < 200, we can reliably detect when pvecs are near
Issues:
- hamming distance ceases to work over distances of ~ 200
- detecting divergence is less accurate when the common ancestor is very close
to either revision or total distance is high
- this could probably be improved by modeling the relation between
delta and hdist
Uses:
- a patch pvec can be used to locate the nearest available common ancestor for
resolving conflicts
- ordering of patches can be established without a DAG
- two head pvecs can be compared to determine whether push/pull/merge is needed
and approximately how many changesets are involved
- can be used to find a heuristic divergence measure between changesets on
different branches
'''
from __future__ import absolute_import
from .node import nullrev
from . import (
util,
)
_size = 448 # 70 chars b85-encoded
_bytes = _size / 8
_depthbits = 24
_depthbytes = _depthbits / 8
_vecbytes = _bytes - _depthbytes
_vecbits = _vecbytes * 8
_radius = (_vecbits - 30) / 2 # high probability vectors are related
def _bin(bs):
'''convert a bytestring to a long'''
v = 0
for b in bs:
v = v * 256 + ord(b)
return v
def _str(v, l):
bs = ""
for p in xrange(l):
bs = chr(v & 255) + bs
v >>= 8
return bs
def _split(b):
'''depth and bitvec'''
return _bin(b[:_depthbytes]), _bin(b[_depthbytes:])
def _join(depth, bitvec):
return _str(depth, _depthbytes) + _str(bitvec, _vecbytes)
def _hweight(x):
c = 0
while x:
if x & 1:
c += 1
x >>= 1
return c
_htab = [_hweight(x) for x in xrange(256)]
def _hamming(a, b):
'''find the hamming distance between two longs'''
d = a ^ b
c = 0
while d:
c += _htab[d & 0xff]
d >>= 8
return c
def _mergevec(x, y, c):
# Ideally, this function would be x ^ y ^ ancestor, but finding
# ancestors is a nuisance. So instead we find the minimal number
# of changes to balance the depth and hamming distance
d1, v1 = x
d2, v2 = y
if d1 < d2:
d1, d2, v1, v2 = d2, d1, v2, v1
hdist = _hamming(v1, v2)
ddist = d1 - d2
v = v1
m = v1 ^ v2 # mask of different bits
i = 1
if hdist > ddist:
# if delta = 10 and hdist = 100, then we need to go up 55 steps
# to the ancestor and down 45
changes = (hdist - ddist + 1) / 2
else:
# must make at least one change
changes = 1
depth = d1 + changes
# copy changes from v2
if m:
while changes:
if m & i:
v ^= i
changes -= 1
i <<= 1
else:
v = _flipbit(v, c)
return depth, v
def _flipbit(v, node):
# converting bit strings to longs is slow
bit = (hash(node) & 0xffffffff) % _vecbits
return v ^ (1<<bit)
def ctxpvec(ctx):
'''construct a pvec for ctx while filling in the cache'''
r = ctx.repo()
if not util.safehasattr(r, "_pveccache"):
r._pveccache = {}
pvc = r._pveccache
if ctx.rev() not in pvc:
cl = r.changelog
for n in xrange(ctx.rev() + 1):
if n not in pvc:
node = cl.node(n)
p1, p2 = cl.parentrevs(n)
if p1 == nullrev:
# start with a 'random' vector at root
pvc[n] = (0, _bin((node * 3)[:_vecbytes]))
elif p2 == nullrev:
d, v = pvc[p1]
pvc[n] = (d + 1, _flipbit(v, node))
else:
pvc[n] = _mergevec(pvc[p1], pvc[p2], node)
bs = _join(*pvc[ctx.rev()])
return pvec(util.b85encode(bs))
class pvec(object):
def __init__(self, hashorctx):
if isinstance(hashorctx, str):
self._bs = hashorctx
self._depth, self._vec = _split(util.b85decode(hashorctx))
else:
self._vec = ctxpvec(hashorctx)
def __str__(self):
return self._bs
def __eq__(self, b):
return self._vec == b._vec and self._depth == b._depth
def __lt__(self, b):
delta = b._depth - self._depth
if delta < 0:
return False # always correct
if _hamming(self._vec, b._vec) > delta:
return False
return True
def __gt__(self, b):
return b < self
def __or__(self, b):
delta = abs(b._depth - self._depth)
if _hamming(self._vec, b._vec) <= delta:
return False
return True
def __sub__(self, b):
if self | b:
raise ValueError("concurrent pvecs")
return self._depth - b._depth
def distance(self, b):
d = abs(b._depth - self._depth)
h = _hamming(self._vec, b._vec)
return max(d, h)
def near(self, b):
dist = abs(b.depth - self._depth)
if dist > _radius or _hamming(self._vec, b._vec) > _radius:
return False

tests/test-completion.t

debuglocks debuglocks
debugmergestate debugmergestate
debugnamecomplete debugnamecomplete
debugobsolete debugobsolete
debugpathcomplete debugpathcomplete
debugpeer debugpeer
debugpickmergetool debugpickmergetool
debugpushkey debugpushkey
debugpvec
debugrebuilddirstate debugrebuilddirstate
debugrebuildfncache debugrebuildfncache
debugrename debugrename
debugrevlog debugrevlog
debugrevspec debugrevspec
debugsetparents debugsetparents
debugssl debugssl
debugsub debugsub
debuglocks: force-lock, force-wlock, set-lock, set-wlock debuglocks: force-lock, force-wlock, set-lock, set-wlock
debugmergestate: debugmergestate:
debugnamecomplete: debugnamecomplete:
debugobsolete: flags, record-parents, rev, exclusive, index, delete, date, user, template debugobsolete: flags, record-parents, rev, exclusive, index, delete, date, user, template
debugpathcomplete: full, normal, added, removed debugpathcomplete: full, normal, added, removed
debugpeer: debugpeer:
debugpickmergetool: rev, changedelete, include, exclude, tool debugpickmergetool: rev, changedelete, include, exclude, tool
debugpushkey: debugpushkey:
debugpvec:
debugrebuilddirstate: rev, minimal debugrebuilddirstate: rev, minimal
debugrebuildfncache: debugrebuildfncache:
debugrename: rev debugrename: rev
debugrevlog: changelog, manifest, dir, dump debugrevlog: changelog, manifest, dir, dump
debugrevspec: optimize, show-revs, show-set, show-stage, no-optimized, verify-optimized debugrevspec: optimize, show-revs, show-set, show-stage, no-optimized, verify-optimized
debugsetparents: debugsetparents:
debugssl: debugssl:
debugsub: rev debugsub: rev

tests/test-help.t

debugoptDEP (no help text available) debugoptDEP (no help text available)
debugoptEXP (no help text available) debugoptEXP (no help text available)
debugpathcomplete debugpathcomplete
complete part or all of a tracked path complete part or all of a tracked path
debugpeer establish a connection to a peer repository debugpeer establish a connection to a peer repository
debugpickmergetool debugpickmergetool
examine which merge tool is chosen for specified file examine which merge tool is chosen for specified file
debugpushkey access the pushkey key/value protocol debugpushkey access the pushkey key/value protocol
debugpvec (no help text available)
debugrebuilddirstate debugrebuilddirstate
rebuild the dirstate as it would look like for the given rebuild the dirstate as it would look like for the given
revision revision
debugrebuildfncache debugrebuildfncache
rebuild the fncache file rebuild the fncache file
debugrename dump rename information debugrename dump rename information
debugrevlog show data and statistics about a revlog debugrevlog show data and statistics about a revlog
debugrevspec parse and apply a revision specification debugrevspec parse and apply a revision specification
mercurial/debugcommands.py