annotate mercurial/node.py @ 39640:039bf1eddc2e

exchangev2: fetch file revisions

Now that the server has an API for fetching file data, we can call into
it to fetch file revisions.

The implementation is relatively straightforward: we examine the
manifests that we fetched and find all new file revisions referenced
by them. We build up a mapping from file path to file nodes to
manifest node. (The mapping to first manifest node allows us to
map back to first changelog node/revision, which is used for the
linkrev.)

Once that map is built up, we iterate over it in a deterministic
manner and fetch and store file data. The code is very similar
to manifest fetching. So similar that we could probably extract the
common bits into a generic function.

With file data retrieval implemented, `hg clone` and `hg pull` are
effectively feature complete, at least as far as the completeness
of data transfer for essential repository data (changesets, manifests,
files, phases, and bookmarks). We're still missing support for
obsolescence markers, the hgtags fnodes cache, and the branchmap
cache. But these are non-essential for the moment (and will be
implemented later).

This is a good point to assess the state of exchangev2 in terms of
performance. I ran a local `hg clone` for the mozilla-unified
repository using both version 1 and version 2 of the wire protocols
and exchange methods. This is effectively comparing the performance
of the wire protocol overhead and "getbundle" versus domain-specific
commands. Wire protocol version 2 doesn't have compression implemented
yet. So I tested version 1 with `server.compressionengines=none` to
remove compression overhead from the equation.

server
before: user 220.420+0.000 sys 14.420+0.000
after:  user 321.980+0.000 sys 18.990+0.000

client
before: real 561.650 secs (user 497.670+0.000 sys 28.160+0.000)
after:  real 1226.260 secs (user 944.240+0.000 sys 354.150+0.000)

We have substantial regressions on both client and server. This
is obviously not desirable. I'm aware of some reasons:

* Lack of hgtagsfnodes transfer (contributes significant CPU to
  client).
* Lack of branch cache transfer (contributes significant CPU to
  client).
* Little to no profiling / optimization performed on wire protocol
  version 2 code.
* There appears to be a memory leak on the client and that is likely
  causing swapping on my machine.
* Using multiple threads on the client may be counter-productive because
  Python.
* We're not compressing on the server.
* We're tracking file nodes on the client via manifest diffing
  rather than using linkrev shortcuts on the server.

I'm pretty confident that most of these issues are addressable.

But even if we can't get wire protocol version 2 on performance parity
with "getbundle," I still think it is important to have the set of low
level data-specific retrieval commands that we have implemented so
far. This is because the existence of such commands allows flexibility
in how clients access server data.

Differential Revision: https://phab.mercurial-scm.org/D4491

# node.py - basic nodeid manipulation for mercurial
#
# Copyright 2005, 2006 Matt Mackall <[e-mail]>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

import binascii

# This ugly style has a noticeable effect in manifest parsing
hex = binascii.hexlify
# Adapt to Python 3 API changes. If this ends up showing up in
# profiles, we can use this version only on Python 3, and forward
# binascii.unhexlify like we used to on Python 2.
def bin(s):
    try:
        return binascii.unhexlify(s)
    except binascii.Error as e:
        raise TypeError(e)

nullrev = -1
# In hex, this is '0000000000000000000000000000000000000000'
nullid = b"\0" * 20
nullhex = hex(nullid)

# Phony node value to stand-in for new files in some uses of
# manifests.
# In hex, this is '2121212121212121212121212121212121212121'
newnodeid = '!!!!!!!!!!!!!!!!!!!!'
# In hex, this is '3030303030303030303030303030306164646564'
addednodeid = '000000000000000added'
# In hex, this is '3030303030303030303030306d6f646966696564'
modifiednodeid = '000000000000modified'

wdirfilenodeids = {newnodeid, addednodeid, modifiednodeid}

# pseudo identifiers for working directory
# (they are experimental, so don't add too many dependencies on them)
wdirrev = 0x7fffffff
# In hex, this is 'ffffffffffffffffffffffffffffffffffffffff'
wdirid = b"\xff" * 20
wdirhex = hex(wdirid)

def short(node):
    return hex(node[:6])