( )⚙ D979 dirstate: move nonnormal and otherparent sets to dirstatemap

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D979

dirstate: move nonnormal and otherparent sets to dirstatemap
ClosedPublic

Authored by durham on Oct 6 2017, 1:19 PM.

Details

Reviewers
quark
durin42
Group Reviewers
hg-reviewers
Commits
rHG60927b19ed65: dirstate: move nonnormal and otherparent sets to dirstatemap
Summary

As part of separating dirstate business logic from storage, let's move the
nonnormal and otherparent storage to the dirstatemap class. This will allow
alternative dirstate storage to persist these sets instead of recomputing them.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durham created this revision.Oct 6 2017, 1:19 PM
quark accepted this revision.Oct 10 2017, 3:36 PM
durin42 accepted this revision.Oct 14 2017, 12:28 AM
This revision is now accepted and ready to land.Oct 14 2017, 12:28 AM
Closed by commit rHG60927b19ed65: dirstate: move nonnormal and otherparent sets to dirstatemap (authored by durham). · Explain WhyOct 14 2017, 12:54 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 2509

contrib/dirstatenonnormalcheck.py

if _nonnormalset != nonnormalcomputedmap: if _nonnormalset != nonnormalcomputedmap:
ui.develwarn("%s call to %s\n" % (label, orig), config='dirstate') ui.develwarn("%s call to %s\n" % (label, orig), config='dirstate')
ui.develwarn("inconsistency in nonnormalset\n", config='dirstate') ui.develwarn("inconsistency in nonnormalset\n", config='dirstate')
ui.develwarn("[nonnormalset] %s\n" % _nonnormalset, config='dirstate') ui.develwarn("[nonnormalset] %s\n" % _nonnormalset, config='dirstate')
ui.develwarn("[map] %s\n" % nonnormalcomputedmap, config='dirstate') ui.develwarn("[map] %s\n" % nonnormalcomputedmap, config='dirstate')
def _checkdirstate(orig, self, arg): def _checkdirstate(orig, self, arg):
"""Check nonnormal set consistency before and after the call to orig""" """Check nonnormal set consistency before and after the call to orig"""
checkconsistency(self._ui, orig, self._map, self._nonnormalset, "before") checkconsistency(self._ui, orig, self._map, self._map.nonnormalset,
"before")
r = orig(self, arg) r = orig(self, arg)
checkconsistency(self._ui, orig, self._map, self._nonnormalset, "after") checkconsistency(self._ui, orig, self._map, self._map.nonnormalset, "after")
return r return r
def extsetup(ui): def extsetup(ui):
"""Wrap functions modifying dirstate to check nonnormalset consistency""" """Wrap functions modifying dirstate to check nonnormalset consistency"""
dirstatecl = dirstate.dirstate dirstatecl = dirstate.dirstate
devel = ui.configbool('devel', 'all-warnings') devel = ui.configbool('devel', 'all-warnings')
paranoid = ui.configbool('experimental', 'nonnormalparanoidcheck') paranoid = ui.configbool('experimental', 'nonnormalparanoidcheck')
if devel: if devel:

mercurial/dirstate.py

return self._map return self._map
@propertycache @propertycache
def _identity(self): def _identity(self):
self._read() self._read()
return self._identity return self._identity
@propertycache @propertycache
def _nonnormalset(self):
nonnorm, otherparents = self._map.nonnormalentries()
self._otherparentset = otherparents
return nonnorm
@propertycache
def _otherparentset(self):
nonnorm, otherparents = self._map.nonnormalentries()
self._nonnormalset = nonnorm
return otherparents
@propertycache
def _filefoldmap(self): def _filefoldmap(self):
return self._map.filefoldmap() return self._map.filefoldmap()
@propertycache @propertycache
def _dirfoldmap(self): def _dirfoldmap(self):
f = {} f = {}
normcase = util.normcase normcase = util.normcase
for name in self._dirs: for name in self._dirs:
self._dirty = True self._dirty = True
oldp2 = self._pl[1] oldp2 = self._pl[1]
if self._origpl is None: if self._origpl is None:
self._origpl = self._pl self._origpl = self._pl
self._map.setparents(p1, p2) self._map.setparents(p1, p2)
copies = {} copies = {}
if oldp2 != nullid and p2 == nullid: if oldp2 != nullid and p2 == nullid:
candidatefiles = self._nonnormalset.union(self._otherparentset) candidatefiles = self._map.nonnormalset.union(
self._map.otherparentset)
for f in candidatefiles: for f in candidatefiles:
s = self._map.get(f) s = self._map.get(f)
if s is None: if s is None:
continue continue
# Discard 'm' markers when moving away from a merge state # Discard 'm' markers when moving away from a merge state
if s[0] == 'm': if s[0] == 'm':
source = self._map.copymap.get(f) source = self._map.copymap.get(f)
'''Causes the next access to reread the dirstate. '''Causes the next access to reread the dirstate.
This is different from localrepo.invalidatedirstate() because it always This is different from localrepo.invalidatedirstate() because it always
rereads the dirstate. Use localrepo.invalidatedirstate() if you want to rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
check whether the dirstate has changed before rereading it.''' check whether the dirstate has changed before rereading it.'''
for a in ("_map", "_identity", for a in ("_map", "_identity",
"_filefoldmap", "_dirfoldmap", "_branch", "_filefoldmap", "_dirfoldmap", "_branch",
"_dirs", "_ignore", "_nonnormalset", "_dirs", "_ignore"):
"_otherparentset"):
if a in self.__dict__: if a in self.__dict__:
delattr(self, a) delattr(self, a)
self._lastnormaltime = 0 self._lastnormaltime = 0
self._dirty = False self._dirty = False
self._updatedfiles.clear() self._updatedfiles.clear()
self._parentwriters = 0 self._parentwriters = 0
self._origpl = None self._origpl = None
raise error.Abort( raise error.Abort(
_('file %r in dirstate clashes with %r') % (d, f)) _('file %r in dirstate clashes with %r') % (d, f))
if oldstate in "?r" and "_dirs" in self.__dict__: if oldstate in "?r" and "_dirs" in self.__dict__:
self._dirs.addpath(f) self._dirs.addpath(f)
self._dirty = True self._dirty = True
self._updatedfiles.add(f) self._updatedfiles.add(f)
self._map[f] = dirstatetuple(state, mode, size, mtime) self._map[f] = dirstatetuple(state, mode, size, mtime)
if state != 'n' or mtime == -1: if state != 'n' or mtime == -1:
self._nonnormalset.add(f) self._map.nonnormalset.add(f)
if size == -2: if size == -2:
self._otherparentset.add(f) self._map.otherparentset.add(f)
def normal(self, f): def normal(self, f):
'''Mark a file normal and clean.''' '''Mark a file normal and clean.'''
s = os.lstat(self._join(f)) s = os.lstat(self._join(f))
mtime = s.st_mtime mtime = s.st_mtime
self._addpath(f, 'n', s.st_mode, self._addpath(f, 'n', s.st_mode,
s.st_size & _rangemask, mtime & _rangemask) s.st_size & _rangemask, mtime & _rangemask)
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
if f in self._nonnormalset: if f in self._map.nonnormalset:
self._nonnormalset.remove(f) self._map.nonnormalset.remove(f)
if mtime > self._lastnormaltime: if mtime > self._lastnormaltime:
# Remember the most recent modification timeslot for status(), # Remember the most recent modification timeslot for status(),
# to make sure we won't miss future size-preserving file content # to make sure we won't miss future size-preserving file content
# modifications that happen within the same timeslot. # modifications that happen within the same timeslot.
self._lastnormaltime = mtime self._lastnormaltime = mtime
def normallookup(self, f): def normallookup(self, f):
'''Mark a file normal, but possibly dirty.''' '''Mark a file normal, but possibly dirty.'''
self.otherparent(f) self.otherparent(f)
if source: if source:
self.copy(source, f) self.copy(source, f)
return return
if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2: if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2:
return return
self._addpath(f, 'n', 0, -1, -1) self._addpath(f, 'n', 0, -1, -1)
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
if f in self._nonnormalset: if f in self._map.nonnormalset:
self._nonnormalset.remove(f) self._map.nonnormalset.remove(f)
def otherparent(self, f): def otherparent(self, f):
'''Mark as coming from the other parent, always dirty.''' '''Mark as coming from the other parent, always dirty.'''
if self._pl[1] == nullid: if self._pl[1] == nullid:
raise error.Abort(_("setting %r to other parent " raise error.Abort(_("setting %r to other parent "
"only allowed in merges") % f) "only allowed in merges") % f)
if f in self and self[f] == 'n': if f in self and self[f] == 'n':
# merge-like # merge-like
if self._pl[1] != nullid: if self._pl[1] != nullid:
entry = self._map.get(f) entry = self._map.get(f)
if entry is not None: if entry is not None:
# backup the previous state # backup the previous state
if entry[0] == 'm': # merge if entry[0] == 'm': # merge
size = -1 size = -1
elif entry[0] == 'n' and entry[2] == -2: # other parent elif entry[0] == 'n' and entry[2] == -2: # other parent
size = -2 size = -2
self._otherparentset.add(f) self._map.otherparentset.add(f)
self._map[f] = dirstatetuple('r', 0, size, 0) self._map[f] = dirstatetuple('r', 0, size, 0)
self._nonnormalset.add(f) self._map.nonnormalset.add(f)
if size == 0: if size == 0:
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
def merge(self, f): def merge(self, f):
'''Mark a file merged.''' '''Mark a file merged.'''
if self._pl[1] == nullid: if self._pl[1] == nullid:
return self.normallookup(f) return self.normallookup(f)
return self.otherparent(f) return self.otherparent(f)
def drop(self, f): def drop(self, f):
'''Drop a file from the dirstate''' '''Drop a file from the dirstate'''
if f in self._map: if f in self._map:
self._dirty = True self._dirty = True
self._droppath(f) self._droppath(f)
del self._map[f] del self._map[f]
if f in self._nonnormalset: if f in self._map.nonnormalset:
self._nonnormalset.remove(f) self._map.nonnormalset.remove(f)
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
def _discoverpath(self, path, normed, ignoremissing, exists, storemap): def _discoverpath(self, path, normed, ignoremissing, exists, storemap):
if exists is None: if exists is None:
exists = os.path.lexists(os.path.join(self._root, path)) exists = os.path.lexists(os.path.join(self._root, path))
if not exists: if not exists:
# Maybe a path component exists # Maybe a path component exists
if not ignoremissing and '/' in path: if not ignoremissing and '/' in path:
''' '''
if self._checkcase: if self._checkcase:
return self._normalize(path, isknown, ignoremissing) return self._normalize(path, isknown, ignoremissing)
return path return path
def clear(self): def clear(self):
self._map = dirstatemap(self._ui, self._opener, self._root) self._map = dirstatemap(self._ui, self._opener, self._root)
self._nonnormalset = set()
self._otherparentset = set()
if "_dirs" in self.__dict__: if "_dirs" in self.__dict__:
delattr(self, "_dirs") delattr(self, "_dirs")
self._map.setparents(nullid, nullid) self._map.setparents(nullid, nullid)
self._lastnormaltime = 0 self._lastnormaltime = 0
self._updatedfiles.clear() self._updatedfiles.clear()
self._dirty = True self._dirty = True
def rebuild(self, parent, allfiles, changedfiles=None): def rebuild(self, parent, allfiles, changedfiles=None):
# emulate dropping timestamp in 'parsers.pack_dirstate' # emulate dropping timestamp in 'parsers.pack_dirstate'
now = _getfsnow(self._opener) now = _getfsnow(self._opener)
dmap = self._map dmap = self._map
for f in self._updatedfiles: for f in self._updatedfiles:
e = dmap.get(f) e = dmap.get(f)
if e is not None and e[0] == 'n' and e[3] == now: if e is not None and e[0] == 'n' and e[3] == now:
dmap[f] = dirstatetuple(e[0], e[1], e[2], -1) dmap[f] = dirstatetuple(e[0], e[1], e[2], -1)
self._nonnormalset.add(f) self._map.nonnormalset.add(f)
# emulate that all 'dirstate.normal' results are written out # emulate that all 'dirstate.normal' results are written out
self._lastnormaltime = 0 self._lastnormaltime = 0
self._updatedfiles.clear() self._updatedfiles.clear()
# delay writing in-memory changes out # delay writing in-memory changes out
tr.addfilegenerator('dirstate', (self._filename,), tr.addfilegenerator('dirstate', (self._filename,),
self._writedirstate, location='plain') self._writedirstate, location='plain')
clock = time.time() clock = time.time()
start = int(clock) - (int(clock) % delaywrite) start = int(clock) - (int(clock) % delaywrite)
end = start + delaywrite end = start + delaywrite
time.sleep(end - clock) time.sleep(end - clock)
now = end # trust our estimate that the end is near now now = end # trust our estimate that the end is near now
break break
self._map.write(st, now) self._map.write(st, now)
self._nonnormalset, self._otherparentset = self._map.nonnormalentries()
self._lastnormaltime = 0 self._lastnormaltime = 0
self._dirty = False self._dirty = False
def _dirignore(self, f): def _dirignore(self, f):
if f == '.': if f == '.':
return False return False
if self._ignore(f): if self._ignore(f):
return True return True
if not self._dirtyparents: if not self._dirtyparents:
self.setparents(*p) self.setparents(*p)
def write(self, st, now): def write(self, st, now):
st.write(parsers.pack_dirstate(self._map, self.copymap, st.write(parsers.pack_dirstate(self._map, self.copymap,
self.parents(), now)) self.parents(), now))
st.close() st.close()
self._dirtyparents = False self._dirtyparents = False
self.nonnormalset, self.otherparentset = self.nonnormalentries()
@propertycache
def nonnormalset(self):
nonnorm, otherparents = self.nonnormalentries()
self.otherparentset = otherparents
return nonnorm
@propertycache
def otherparentset(self):
nonnorm, otherparents = self.nonnormalentries()
self.nonnormalset = nonnorm
return otherparents