This is an archive of the discontinued Mercurial Phabricator instance.

Differential D756

dirstate: move _copymap to dirstatemap
ClosedPublic

Authored by durham on Sep 20 2017, 8:03 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG0865d25e8a8a: dirstate: move _copymap to dirstatemap
rHG894cd88815ca: dirstate: move _copymap to dirstatemap
Summary

As part of moving all dirstate storage to a new class, let's move the copymap
onto that class. In a future patch this will let us move the read/write
functions to the dirstatemap class, and for extensions this lets us replace the
copy storage with alternative storage.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durham created this revision.Sep 20 2017, 8:03 PM
indygreg accepted this revision.Sep 24 2017, 11:14 AM
This revision is now accepted and ready to land.Sep 24 2017, 11:14 AM
durham updated this revision to Diff 2080.Sep 26 2017, 6:58 AM
Closed by commit rHG894cd88815ca: dirstate: move _copymap to dirstatemap (authored by durham). · Explain WhySep 29 2017, 2:43 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/dirstate.py (44 lines)

Diff 2080

mercurial/dirstate.py

@propertycache @propertycache
def _map(self): def _map(self):
'''Return the dirstate contents as a map from filename to '''Return the dirstate contents as a map from filename to
(state, mode, size, time).''' (state, mode, size, time).'''
self._read() self._read()
return self._map return self._map
@propertycache @propertycache
def _copymap(self):
self._read()
return self._copymap
@propertycache
def _identity(self): def _identity(self):
self._read() self._read()
return self._identity return self._identity
@propertycache @propertycache
def _nonnormalset(self): def _nonnormalset(self):
nonnorm, otherparents = self._map.nonnormalentries() nonnorm, otherparents = self._map.nonnormalentries()
self._otherparentset = otherparents self._otherparentset = otherparents
candidatefiles = self._nonnormalset.union(self._otherparentset) candidatefiles = self._nonnormalset.union(self._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._copymap.get(f) source = self._map.copymap.get(f)
if source: if source:
copies[f] = source copies[f] = source
self.normallookup(f) self.normallookup(f)
# Also fix up otherparent markers # Also fix up otherparent markers
elif s[0] == 'n' and s[2] == -2: elif s[0] == 'n' and s[2] == -2:
source = self._copymap.get(f) source = self._map.copymap.get(f)
if source: if source:
copies[f] = source copies[f] = source
self.add(f) self.add(f)
return copies return copies
def setbranch(self, branch): def setbranch(self, branch):
self._branch = encoding.fromlocal(branch) self._branch = encoding.fromlocal(branch)
f = self._opener('branch', 'w', atomictemp=True, checkambig=True) f = self._opener('branch', 'w', atomictemp=True, checkambig=True)
raise error.Abort(_('working directory state may be ' raise error.Abort(_('working directory state may be '
'changed parallelly')) 'changed parallelly'))
self._pendingmode = mode self._pendingmode = mode
return fp return fp
def _read(self): def _read(self):
self._map = dirstatemap() self._map = dirstatemap()
self._copymap = {}
# ignore HG_PENDING because identity is used only for writing # ignore HG_PENDING because identity is used only for writing
self._identity = util.filestat.frompath( self._identity = util.filestat.frompath(
self._opener.join(self._filename)) self._opener.join(self._filename))
try: try:
fp = self._opendirstatefile() fp = self._opendirstatefile()
try: try:
st = fp.read() st = fp.read()
finally: finally:
# effect on when GCs are triggered, only on what objects the GC looks # effect on when GCs are triggered, only on what objects the GC looks
# into. This means that O(number of files) GCs are unavoidable. # into. This means that O(number of files) GCs are unavoidable.
# Depending on when in the process's lifetime the dirstate is parsed, # Depending on when in the process's lifetime the dirstate is parsed,
# this can get very expensive. As a workaround, disable GC while # this can get very expensive. As a workaround, disable GC while
# parsing the dirstate. # parsing the dirstate.
# #
# (we cannot decorate the function directly since it is in a C module) # (we cannot decorate the function directly since it is in a C module)
parse_dirstate = util.nogc(parsers.parse_dirstate) parse_dirstate = util.nogc(parsers.parse_dirstate)
p = parse_dirstate(self._map._map, self._copymap, st) p = parse_dirstate(self._map._map, self._map.copymap, st)
if not self._dirtypl: if not self._dirtypl:
self._pl = p self._pl = p
def invalidate(self): def invalidate(self):
'''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", "_copymap", "_identity", for a in ("_map", "_identity",
"_filefoldmap", "_dirfoldmap", "_branch", "_filefoldmap", "_dirfoldmap", "_branch",
"_pl", "_dirs", "_ignore", "_nonnormalset", "_pl", "_dirs", "_ignore", "_nonnormalset",
"_otherparentset"): "_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
def copy(self, source, dest): def copy(self, source, dest):
"""Mark dest as a copy of source. Unmark dest if source is None.""" """Mark dest as a copy of source. Unmark dest if source is None."""
if source == dest: if source == dest:
return return
self._dirty = True self._dirty = True
if source is not None: if source is not None:
self._copymap[dest] = source self._map.copymap[dest] = source
self._updatedfiles.add(source) self._updatedfiles.add(source)
self._updatedfiles.add(dest) self._updatedfiles.add(dest)
elif self._copymap.pop(dest, None): elif self._map.copymap.pop(dest, None):
self._updatedfiles.add(dest) self._updatedfiles.add(dest)
def copied(self, file): def copied(self, file):
return self._copymap.get(file, None) return self._map.copymap.get(file, None)
def copies(self): def copies(self):
return self._copymap return self._map.copymap
def _droppath(self, f): def _droppath(self, f):
if self[f] not in "?r" and "_dirs" in self.__dict__: if self[f] not in "?r" and "_dirs" in self.__dict__:
self._dirs.delpath(f) self._dirs.delpath(f)
if "_filefoldmap" in self.__dict__: if "_filefoldmap" in self.__dict__:
normed = util.normcase(f) normed = util.normcase(f)
if normed in self._filefoldmap: if normed in self._filefoldmap:
self._otherparentset.add(f) self._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._copymap.pop(f, None) self._map.copymap.pop(f, None)
if f in self._nonnormalset: if f in self._nonnormalset:
self._nonnormalset.remove(f) self._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.'''
if self._pl[1] != nullid: if self._pl[1] != nullid:
# if there is a merge going on and the file was either # if there is a merge going on and the file was either
# in state 'm' (-1) or coming from other parent (-2) before # in state 'm' (-1) or coming from other parent (-2) before
# being removed, restore that state. # being removed, restore that state.
entry = self._map.get(f) entry = self._map.get(f)
if entry is not None: if entry is not None:
if entry[0] == 'r' and entry[2] in (-1, -2): if entry[0] == 'r' and entry[2] in (-1, -2):
source = self._copymap.get(f) source = self._map.copymap.get(f)
if entry[2] == -1: if entry[2] == -1:
self.merge(f) self.merge(f)
elif entry[2] == -2: elif entry[2] == -2:
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._copymap.pop(f, None) self._map.copymap.pop(f, None)
if f in self._nonnormalset: if f in self._nonnormalset:
self._nonnormalset.remove(f) self._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
self._addpath(f, 'm', 0, -2, -1) self._addpath(f, 'm', 0, -2, -1)
else: else:
# add-like # add-like
self._addpath(f, 'n', 0, -2, -1) self._addpath(f, 'n', 0, -2, -1)
self._copymap.pop(f, None) self._map.copymap.pop(f, None)
def add(self, f): def add(self, f):
'''Mark a file added.''' '''Mark a file added.'''
self._addpath(f, 'a', 0, -1, -1) self._addpath(f, 'a', 0, -1, -1)
self._copymap.pop(f, None) self._map.copymap.pop(f, None)
def remove(self, f): def remove(self, f):
'''Mark a file removed.''' '''Mark a file removed.'''
self._dirty = True self._dirty = True
self._droppath(f) self._droppath(f)
size = 0 size = 0
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._otherparentset.add(f)
self._map[f] = dirstatetuple('r', 0, size, 0) self._map[f] = dirstatetuple('r', 0, size, 0)
self._nonnormalset.add(f) self._nonnormalset.add(f)
if size == 0: if size == 0:
self._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._nonnormalset:
self._nonnormalset.remove(f) self._nonnormalset.remove(f)
self._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:
d, f = path.rsplit('/', 1) d, f = path.rsplit('/', 1)
return path return path
def clear(self): def clear(self):
self._map = dirstatemap() self._map = dirstatemap()
self._nonnormalset = set() self._nonnormalset = set()
self._otherparentset = set() self._otherparentset = set()
if "_dirs" in self.__dict__: if "_dirs" in self.__dict__:
delattr(self, "_dirs") delattr(self, "_dirs")
self._copymap = {}
self._pl = [nullid, nullid] self._pl = [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):
if changedfiles is None: if changedfiles is None:
# Rebuild entire dirstate # Rebuild entire dirstate
# multiple of n seconds # multiple of n seconds
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
st.write(parsers.pack_dirstate(self._map._map, self._copymap, self._pl, st.write(parsers.pack_dirstate(self._map._map, self._map.copymap,
now)) self._pl, now))
self._nonnormalset, self._otherparentset = self._map.nonnormalentries() self._nonnormalset, self._otherparentset = self._map.nonnormalentries()
st.close() st.close()
self._lastnormaltime = 0 self._lastnormaltime = 0
self._dirty = self._dirtypl = False self._dirty = self._dirtypl = False
def _dirignore(self, f): def _dirignore(self, f):
if f == '.': if f == '.':
return False return False
uadd = unknown.append uadd = unknown.append
iadd = ignored.append iadd = ignored.append
radd = removed.append radd = removed.append
dadd = deleted.append dadd = deleted.append
cadd = clean.append cadd = clean.append
mexact = match.exact mexact = match.exact
dirignore = self._dirignore dirignore = self._dirignore
checkexec = self._checkexec checkexec = self._checkexec
copymap = self._copymap copymap = self._map.copymap
lastnormaltime = self._lastnormaltime lastnormaltime = self._lastnormaltime
# We need to do full walks when either # We need to do full walks when either
# - we're listing all clean files, or # - we're listing all clean files, or
# - match.traversedir does something, because match.traversedir should # - match.traversedir does something, because match.traversedir should
# be called for every dir in the working dir # be called for every dir in the working dir
full = listclean or match.traversedir is not None full = listclean or match.traversedir is not None
for fn, st in self.walk(match, subrepos, listunknown, listignored, for fn, st in self.walk(match, subrepos, listunknown, listignored,
def clearbackup(self, tr, backupname): def clearbackup(self, tr, backupname):
'''Clear backup file''' '''Clear backup file'''
self._opener.unlink(backupname) self._opener.unlink(backupname)
class dirstatemap(object): class dirstatemap(object):
def __init__(self): def __init__(self):
self._map = {} self._map = {}
self.copymap = {}
def iteritems(self): def iteritems(self):
return self._map.iteritems() return self._map.iteritems()
def __iter__(self): def __iter__(self):
return iter(self._map) return iter(self._map)
def get(self, key, default=None): def get(self, key, default=None):