This is an archive of the discontinued Mercurial Phabricator instance.

Differential D233

fastmanifest: move tree writing to memmanifestctx.write()
ClosedPublic

Authored by durham on Aug 4 2017, 5:59 PM.
Tags
None
Subscribers
None

Details

Reviewers
ryanmce
Group Reviewers
Restricted Project
Commits
rFBHGXeb521e5586c8: fastmanifest: move tree writing to memmanifestctx.write()
Summary

Previously fastmanifest hooked into manifestrevlog.add() to write the local tree
manifest when a flat manifest is written. In a future diff we'll be moving the
datastore objects off of the opener object and on to the manifestlog. Since we
need the datastore to write trees, and the datastore will soon be on the
manifestlog, and the manifestlog isn't accessible from manifestrevlog.add(), we
need to move our tree write up to the ctx level instead. This is probably
cleaner anyway since the ctx level is where we differentiate manifest types, not
at the revlog/storage level.

Test Plan

Ran the tests

Diff Detail

Repository
rFBHGX Facebook Mercurial Extensions
Branch
default
Lint
Lint OK
Unit
Unit Test Errors

Event Timeline

durham created this revision.Aug 4 2017, 5:59 PM
ryanmce accepted this revision.Aug 6 2017, 4:37 AM
This revision is now accepted and ready to land.Aug 6 2017, 4:37 AM
Closed by commit rFBHGXeb521e5586c8: fastmanifest: move tree writing to memmanifestctx.write() (authored by durham). · Explain WhyAug 9 2017, 3:49 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 564

fastmanifest/__init__.py

extensions.wrapfunction(manifest.manifestrevlog, 'rev', logger.revwrap) extensions.wrapfunction(manifest.manifestrevlog, 'rev', logger.revwrap)
factory = manifestfactory(ui) factory = manifestfactory(ui)
extensions.wrapfunction( extensions.wrapfunction(
manifest.manifestlog, '__getitem__', factory.newgetitem) manifest.manifestlog, '__getitem__', factory.newgetitem)
extensions.wrapfunction( extensions.wrapfunction(
manifest.manifestlog, 'get', factory.newgetdirmanifestctx) manifest.manifestlog, 'get', factory.newgetdirmanifestctx)
extensions.wrapfunction(
manifest.memmanifestctx, 'write', factory.ctxwrite)
extensions.wrapfunction(manifest.manifestrevlog, 'add', factory.add) extensions.wrapfunction(manifest.manifestrevlog, 'add', factory.add)
if ui.configbool('fastmanifest', 'usecache', True): if ui.configbool('fastmanifest', 'usecache', True):
revsetmod.symbols['fastmanifesttocache'] = ( revsetmod.symbols['fastmanifesttocache'] = (
cachemanager.fastmanifesttocache cachemanager.fastmanifesttocache
) )
revsetmod.safesymbols.add('fastmanifesttocache') revsetmod.safesymbols.add('fastmanifesttocache')
revsetmod.symbols['fastmanifestcached'] = ( revsetmod.symbols['fastmanifestcached'] = (

fastmanifest/implementation.py

cachedmf = m._cachedmanifest() cachedmf = m._cachedmanifest()
if cachedmf: if cachedmf:
fastcache.put_inmemory(hexnode, cachedmf) fastcache.put_inmemory(hexnode, cachedmf)
self.ui.debug("[FM] wrote manifest %s\n" % (hexnode,)) self.ui.debug("[FM] wrote manifest %s\n" % (hexnode,))
else: else:
# If neither cache could help, fallback to the normal add # If neither cache could help, fallback to the normal add
node = orig(*args, **kwargs) node = orig(*args, **kwargs)
# Add the new manifest to the tree return node
def ctxwrite(self, orig, mfctx, transaction, link, p1, p2, added, removed):
node = orig(mfctx, transaction, link, p1, p2, added, removed)
treeenabled = self.ui.configbool("fastmanifest", "usetree", False)
if supportsctree and treeenabled: if supportsctree and treeenabled:
mfl = mfctx._manifestlog
datastore = mfctx._revlog().opener.manifestdatastore
opener = mfctx._revlog().opener
m = mfctx._manifestdict
# hybridmanifest requires you provide either a value or loadflat.
# Let's give it a dummy value, since we know we'll only be calling
# _treemanifest()
def loadflat(): def loadflat():
# This should eventually be made lazy loaded, so consumers can raise RuntimeError("no-op loadflat should never be hit")
# access the node/p1/linkrev data without having to parse the tree = hybridmanifest(self.ui, opener, mfl, loadflat=loadflat,
# whole manifest.
data = origself.revision(p1)
arraytext = bytearray(data)
origself._fulltextcache[p1] = arraytext
return manifest.manifestdict(data)
tree = hybridmanifest(self.ui, origself.opener, loadflat=loadflat,
node=p1)._treemanifest() node=p1)._treemanifest()
if tree is not None: if tree is not None:
newtree = tree.copy() newtree = tree.copy()
for filename in removed: for filename in removed:
del newtree[filename] del newtree[filename]
for filename in added: for filename in added:
fnode = m[filename] fnode = m[filename]
fflag = m.flags(filename) fflag = m.flags(filename)
newtree.set(filename, fnode, fflag) newtree.set(filename, fnode, fflag)
if not util.safehasattr(transaction, 'treedatapack'): if not util.safehasattr(transaction, 'treedatapack'):
packpath = shallowutil.getlocalpackpath( packpath = shallowutil.getlocalpackpath(
origself.opener.vfs.base, opener.vfs.base,
'manifests') 'manifests')
transaction.treedatapack = datapack.mutabledatapack( transaction.treedatapack = datapack.mutabledatapack(
self.ui, self.ui,
packpath) packpath)
transaction.treehistpack = historypack.mutablehistorypack( transaction.treehistpack = historypack.mutablehistorypack(
self.ui, self.ui,
packpath) packpath)
def finalize(tr): def finalize(tr):
tr.treedatapack.close() tr.treedatapack.close()
tr.treehistpack.close() tr.treehistpack.close()
treemanifestcache.getinstance(origself.opener, treemanifestcache.getinstance(opener,
self.ui).clear() self.ui).clear()
origself.opener.manifestdatastore.markforrefresh() datastore.markforrefresh()
def abort(tr): def abort(tr):
tr.treedatapack.abort() tr.treedatapack.abort()
tr.treehistpack.abort() tr.treehistpack.abort()
transaction.addfinalize('treepack', finalize) transaction.addfinalize('treepack', finalize)
transaction.addabort('treepack', abort) transaction.addabort('treepack', abort)
dpack = treemanifest.InterceptedMutableDataPack( dpack = treemanifest.InterceptedMutableDataPack(
transaction.treedatapack, transaction.treedatapack,
node, p1) node, p1)
hpack = treemanifest.InterceptedMutableHistoryPack( hpack = treemanifest.InterceptedMutableHistoryPack(
transaction.treehistpack, node, p1) transaction.treehistpack, node, p1)
newtreeiter = newtree.finalize(tree) newtreeiter = newtree.finalize(tree)
for nname, nnode, ntext, np1text, np1, np2 in newtreeiter: for nname, nnode, ntext, np1text, np1, np2 in newtreeiter:
# Not using deltas, since there aren't any other trees in # Not using deltas, since there aren't any other trees in
# this pack it could delta against. # this pack it could delta against.
dpack.add(nname, nnode, revlog.nullid, ntext) dpack.add(nname, nnode, revlog.nullid, ntext)
hpack.add(nname, nnode, np1, np2, revlog.nullid, '') hpack.add(nname, nnode, np1, np2, revlog.nullid, '')
treemanifestcache.getinstance(origself.opener, treemanifestcache.getinstance(opener,
self.ui)[node] = newtree self.ui)[node] = newtree
return node return node
def _silent_debug(*args, **kwargs): def _silent_debug(*args, **kwargs):
"""Replacement for ui.debug that silently swallows the arguments. """Replacement for ui.debug that silently swallows the arguments.
Typically enabled when running the mercurial test suite by setting: Typically enabled when running the mercurial test suite by setting:
--extra-config-opt=fastmanifest.silent=True""" --extra-config-opt=fastmanifest.silent=True"""
pass pass