This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10309

revlog: replace revlog._io.size with a new revlog.index.entry_size
ClosedPublic

Authored by marmoute on Apr 5 2021, 11:49 AM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHG3c9208702db3: revlog: replace revlog._io.size with a new revlog.index.entry_size
Summary

The revlogio class is mostly a relic from the past. Once in charge of the full
revlog related Input/Output code, that class gradually lost responsibilities to
the point where more IO are now done by revlog.index objects or revlog objects
themself. I would like to ultimately remove the revlogio class, to do so I
start simple with move the "entry size" information on the index. (The index is
already responsible of the binary unpacking, so it knows the size.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Apr 5 2021, 11:49 AM
Alphare accepted this revision.Apr 8 2021, 5:58 AM
baymax updated this revision to Diff 26709.Apr 8 2021, 10:29 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 26737.Apr 8 2021, 8:38 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 26772.Apr 9 2021, 8:34 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision.Apr 19 2021, 9:38 AM
marmoute added a commit: rHG3c9208702db3: revlog: replace revlog._io.size with a new revlog.index.entry_size.Apr 19 2021, 9:38 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG3c9208702db3: revlog: replace revlog._io.size with a new revlog.index.entry_size (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27045

contrib/perf.py

node = r.lookup(rev) node = r.lookup(rev)
rev = r.rev(node) rev = r.rev(node)
def getrawchunks(data, chain): def getrawchunks(data, chain):
start = r.start start = r.start
length = r.length length = r.length
inline = r._inline inline = r._inline
try:
iosize = r.index.entry_size
except AttributeError:
iosize = r._io.size iosize = r._io.size
buffer = util.buffer buffer = util.buffer
chunks = [] chunks = []
ladd = chunks.append ladd = chunks.append
for idx, item in enumerate(chain): for idx, item in enumerate(chain):
offset = start(item[0]) offset = start(item[0])
bits = data[idx] bits = data[idx]
for rev in item: for rev in item:

mercurial/cext/revlog.c

#define PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN
#include <Python.h> #include <Python.h>
#include <assert.h> #include <assert.h>
#include <ctype.h> #include <ctype.h>
#include <limits.h> #include <limits.h>
#include <stddef.h> #include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <structmember.h>
#include "bitmanipulation.h" #include "bitmanipulation.h"
#include "charencode.h" #include "charencode.h"
#include "compat.h" #include "compat.h"
#include "revlog.h" #include "revlog.h"
#include "util.h" #include "util.h"
#ifdef IS_PY3K #ifdef IS_PY3K
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyGetSetDef index_getset[] = { static PyGetSetDef index_getset[] = {
{"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL}, {"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyMemberDef index_members[] = {
{"entry_size", T_LONG, offsetof(indexObject, hdrsize), 0,
"size of an index entry"},
{NULL} /* Sentinel */
};
PyTypeObject HgRevlogIndex_Type = { PyTypeObject HgRevlogIndex_Type = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"parsers.index", /* tp_name */ "parsers.index", /* tp_name */
sizeof(indexObject), /* tp_basicsize */ sizeof(indexObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)index_dealloc, /* tp_dealloc */ (destructor)index_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
"revlog index", /* tp_doc */ "revlog index", /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
index_methods, /* tp_methods */ index_methods, /* tp_methods */
0, /* tp_members */ index_members, /* tp_members */
index_getset, /* tp_getset */ index_getset, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)index_init, /* tp_init */ (initproc)index_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */

mercurial/pure/parsers.py

class BaseIndexObject(object): class BaseIndexObject(object):
# Format of an index entry according to Python's `struct` language # Format of an index entry according to Python's `struct` language
index_format = revlog_constants.INDEX_ENTRY_V1 index_format = revlog_constants.INDEX_ENTRY_V1
# Size of a C unsigned long long int, platform independent # Size of a C unsigned long long int, platform independent
big_int_size = struct.calcsize(b'>Q') big_int_size = struct.calcsize(b'>Q')
# Size of a C long int, platform independent # Size of a C long int, platform independent
int_size = struct.calcsize(b'>i') int_size = struct.calcsize(b'>i')
# Size of the entire index format
index_size = revlog_constants.INDEX_ENTRY_V1.size
# An empty index entry, used as a default value to be overridden, or nullrev # An empty index entry, used as a default value to be overridden, or nullrev
null_item = (0, 0, 0, -1, -1, -1, -1, nullid) null_item = (0, 0, 0, -1, -1, -1, -1, nullid)
@util.propertycache
def entry_size(self):
return self.index_format.size
@property @property
def nodemap(self): def nodemap(self):
msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]"
util.nouideprecwarn(msg, b'5.3', stacklevel=2) util.nouideprecwarn(msg, b'5.3', stacklevel=2)
return self._nodemap return self._nodemap
@util.propertycache @util.propertycache
def _nodemap(self): def _nodemap(self):
def __getitem__(self, i): def __getitem__(self, i):
if i == -1: if i == -1:
return self.null_item return self.null_item
self._check_index(i) self._check_index(i)
if i >= self._lgt: if i >= self._lgt:
data = self._extra[i - self._lgt] data = self._extra[i - self._lgt]
else: else:
index = self._calculate_index(i) index = self._calculate_index(i)
data = self._data[index : index + self.index_size] data = self._data[index : index + self.entry_size]
r = self.index_format.unpack(data) r = self.index_format.unpack(data)
if self._lgt and i == 0: if self._lgt and i == 0:
r = (offset_type(0, gettype(r[0])),) + r[1:] r = (offset_type(0, gettype(r[0])),) + r[1:]
return r return r
class IndexObject(BaseIndexObject): class IndexObject(BaseIndexObject):
def __init__(self, data): def __init__(self, data):
assert len(data) % self.index_size == 0 assert len(data) % self.entry_size == 0
self._data = data self._data = data
self._lgt = len(data) // self.index_size self._lgt = len(data) // self.entry_size
self._extra = [] self._extra = []
def _calculate_index(self, i): def _calculate_index(self, i):
return i * self.index_size return i * self.entry_size
def __delitem__(self, i): def __delitem__(self, i):
if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
raise ValueError(b"deleting slices only supports a:-1 with step 1") raise ValueError(b"deleting slices only supports a:-1 with step 1")
i = i.start i = i.start
self._check_index(i) self._check_index(i)
self._stripnodes(i) self._stripnodes(i)
if i < self._lgt: if i < self._lgt:
self._data = self._data[: i * self.index_size] self._data = self._data[: i * self.entry_size]
self._lgt = i self._lgt = i
self._extra = [] self._extra = []
else: else:
self._extra = self._extra[: i - self._lgt] self._extra = self._extra[: i - self._lgt]
class PersistentNodeMapIndexObject(IndexObject): class PersistentNodeMapIndexObject(IndexObject):
"""a Debug oriented class to test persistent nodemap """a Debug oriented class to test persistent nodemap
self._inline_scan(self._lgt) self._inline_scan(self._lgt)
self._extra = [] self._extra = []
def _inline_scan(self, lgt): def _inline_scan(self, lgt):
off = 0 off = 0
if lgt is not None: if lgt is not None:
self._offsets = [0] * lgt self._offsets = [0] * lgt
count = 0 count = 0
while off <= len(self._data) - self.index_size: while off <= len(self._data) - self.entry_size:
start = off + self.big_int_size start = off + self.big_int_size
(s,) = struct.unpack( (s,) = struct.unpack(
b'>i', b'>i',
self._data[start : start + self.int_size], self._data[start : start + self.int_size],
) )
if lgt is not None: if lgt is not None:
self._offsets[count] = off self._offsets[count] = off
count += 1 count += 1
off += self.index_size + s off += self.entry_size + s
if off != len(self._data): if off != len(self._data):
raise ValueError(b"corrupted data") raise ValueError(b"corrupted data")
return count return count
def __delitem__(self, i): def __delitem__(self, i):
if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
raise ValueError(b"deleting slices only supports a:-1 with step 1") raise ValueError(b"deleting slices only supports a:-1 with step 1")
i = i.start i = i.start
cls = IndexObject2 if revlogv2 else IndexObject cls = IndexObject2 if revlogv2 else IndexObject
return cls(data), None return cls(data), None
cls = InlinedIndexObject2 if revlogv2 else InlinedIndexObject cls = InlinedIndexObject2 if revlogv2 else InlinedIndexObject
return cls(data, inline), (0, data) return cls(data, inline), (0, data)
class Index2Mixin(object): class Index2Mixin(object):
index_format = revlog_constants.INDEX_ENTRY_V2 index_format = revlog_constants.INDEX_ENTRY_V2
index_size = revlog_constants.INDEX_ENTRY_V2.size
null_item = (0, 0, 0, -1, -1, -1, -1, nullid, 0, 0) null_item = (0, 0, 0, -1, -1, -1, -1, nullid, 0, 0)
def replace_sidedata_info(self, i, sidedata_offset, sidedata_length): def replace_sidedata_info(self, i, sidedata_offset, sidedata_length):
""" """
Replace an existing index entry's sidedata offset and length with new Replace an existing index entry's sidedata offset and length with new
ones. ones.
This cannot be used outside of the context of sidedata rewriting, This cannot be used outside of the context of sidedata rewriting,
inside the transaction that creates the revision `i`. inside the transaction that creates the revision `i`.
class InlinedIndexObject2(Index2Mixin, InlinedIndexObject): class InlinedIndexObject2(Index2Mixin, InlinedIndexObject):
def _inline_scan(self, lgt): def _inline_scan(self, lgt):
sidedata_length_pos = 72 sidedata_length_pos = 72
off = 0 off = 0
if lgt is not None: if lgt is not None:
self._offsets = [0] * lgt self._offsets = [0] * lgt
count = 0 count = 0
while off <= len(self._data) - self.index_size: while off <= len(self._data) - self.entry_size:
start = off + self.big_int_size start = off + self.big_int_size
(data_size,) = struct.unpack( (data_size,) = struct.unpack(
b'>i', b'>i',
self._data[start : start + self.int_size], self._data[start : start + self.int_size],
) )
start = off + sidedata_length_pos start = off + sidedata_length_pos
(side_data_size,) = struct.unpack( (side_data_size,) = struct.unpack(
b'>i', self._data[start : start + self.int_size] b'>i', self._data[start : start + self.int_size]
) )
if lgt is not None: if lgt is not None:
self._offsets[count] = off self._offsets[count] = off
count += 1 count += 1
off += self.index_size + data_size + side_data_size off += self.entry_size + data_size + side_data_size
if off != len(self._data): if off != len(self._data):
raise ValueError(b"corrupted data") raise ValueError(b"corrupted data")
return count return count
def parse_index_devel_nodemap(data, inline): def parse_index_devel_nodemap(data, inline):
"""like parse_index2, but alway return a PersistentNodeMapIndexObject""" """like parse_index2, but alway return a PersistentNodeMapIndexObject"""
return PersistentNodeMapIndexObject(data), None return PersistentNodeMapIndexObject(data), None

mercurial/revlog.py

@attr.s(frozen=True) @attr.s(frozen=True)
class revlogproblem(object): class revlogproblem(object):
warning = attr.ib(default=None) warning = attr.ib(default=None)
error = attr.ib(default=None) error = attr.ib(default=None)
node = attr.ib(default=None) node = attr.ib(default=None)
class revlogoldindex(list): class revlogoldindex(list):
entry_size = INDEX_ENTRY_V0.size
@property @property
def nodemap(self): def nodemap(self):
msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]"
util.nouideprecwarn(msg, b'5.3', stacklevel=2) util.nouideprecwarn(msg, b'5.3', stacklevel=2)
return self._nodemap return self._nodemap
@util.propertycache @util.propertycache
def _nodemap(self): def _nodemap(self):
def __getitem__(self, i): def __getitem__(self, i):
if i == -1: if i == -1:
return (0, 0, 0, -1, -1, -1, -1, nullid) return (0, 0, 0, -1, -1, -1, -1, nullid)
return list.__getitem__(self, i) return list.__getitem__(self, i)
class revlogoldio(object): class revlogoldio(object):
def __init__(self):
self.size = INDEX_ENTRY_V0.size
def parseindex(self, data, inline): def parseindex(self, data, inline):
s = self.size s = INDEX_ENTRY_V0.size
index = [] index = []
nodemap = nodemaputil.NodeMap({nullid: nullrev}) nodemap = nodemaputil.NodeMap({nullid: nullrev})
n = off = 0 n = off = 0
l = len(data) l = len(data)
while off + s <= l: while off + s <= l:
cur = data[off : off + s] cur = data[off : off + s]
off += s off += s
e = INDEX_ENTRY_V0.unpack(cur) e = INDEX_ENTRY_V0.unpack(cur)
# corresponds to uncompressed length of indexformatng (2 gigs, 4-byte # corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
# signed integer) # signed integer)
_maxentrysize = 0x7FFFFFFF _maxentrysize = 0x7FFFFFFF
class revlogio(object): class revlogio(object):
def __init__(self):
self.size = INDEX_ENTRY_V1.size
def parseindex(self, data, inline): def parseindex(self, data, inline):
# call the C implementation to parse the index data # call the C implementation to parse the index data
index, cache = parsers.parse_index2(data, inline) index, cache = parsers.parse_index2(data, inline)
return index, cache return index, cache
def packentry(self, entry, node, version, rev): def packentry(self, entry, node, version, rev):
p = INDEX_ENTRY_V1.pack(*entry) p = INDEX_ENTRY_V1.pack(*entry)
if rev == 0: if rev == 0:
p = INDEX_HEADER.pack(version) + p[4:] p = INDEX_HEADER.pack(version) + p[4:]
return p return p
class revlogv2io(object): class revlogv2io(object):
def __init__(self):
self.size = INDEX_ENTRY_V2.size
def parseindex(self, data, inline): def parseindex(self, data, inline):
index, cache = parsers.parse_index2(data, inline, revlogv2=True) index, cache = parsers.parse_index2(data, inline, revlogv2=True)
return index, cache return index, cache
def packentry(self, entry, node, version, rev): def packentry(self, entry, node, version, rev):
p = INDEX_ENTRY_V2.pack(*entry) p = INDEX_ENTRY_V2.pack(*entry)
if rev == 0: if rev == 0:
p = INDEX_HEADER.pack(version) + p[4:] p = INDEX_HEADER.pack(version) + p[4:]
start = int(istart[0] >> 16) start = int(istart[0] >> 16)
if startrev == endrev: if startrev == endrev:
end = start + istart[1] end = start + istart[1]
else: else:
iend = index[endrev] iend = index[endrev]
end = int(iend[0] >> 16) + iend[1] end = int(iend[0] >> 16) + iend[1]
if self._inline: if self._inline:
start += (startrev + 1) * self._io.size start += (startrev + 1) * self.index.entry_size
end += (endrev + 1) * self._io.size end += (endrev + 1) * self.index.entry_size
length = end - start length = end - start
return start, self._getsegment(start, length, df=df) return start, self._getsegment(start, length, df=df)
def _chunk(self, rev, df=None): def _chunk(self, rev, df=None):
"""Obtain a single decompressed chunk for a revision. """Obtain a single decompressed chunk for a revision.
Accepts an integer revision and an optional already-open file handle Accepts an integer revision and an optional already-open file handle
Returns a list with decompressed data for each requested revision. Returns a list with decompressed data for each requested revision.
""" """
if not revs: if not revs:
return [] return []
start = self.start start = self.start
length = self.length length = self.length
inline = self._inline inline = self._inline
iosize = self._io.size iosize = self.index.entry_size
buffer = util.buffer buffer = util.buffer
l = [] l = []
ladd = l.append ladd = l.append
if not self._withsparseread: if not self._withsparseread:
slicedchunks = (revs,) slicedchunks = (revs,)
else: else:
def _sidedata(self, rev): def _sidedata(self, rev):
"""Return the sidedata for a given revision number.""" """Return the sidedata for a given revision number."""
index_entry = self.index[rev] index_entry = self.index[rev]
sidedata_offset = index_entry[8] sidedata_offset = index_entry[8]
sidedata_size = index_entry[9] sidedata_size = index_entry[9]
if self._inline: if self._inline:
sidedata_offset += self._io.size * (1 + rev) sidedata_offset += self.index.entry_size * (1 + rev)
if sidedata_size == 0: if sidedata_size == 0:
return {} return {}
segment = self._getsegment(sidedata_offset, sidedata_size) segment = self._getsegment(sidedata_offset, sidedata_size)
sidedata = sidedatautil.deserialize_sidedata(segment) sidedata = sidedatautil.deserialize_sidedata(segment)
return sidedata return sidedata
def rawdata(self, nodeorrev, _df=None): def rawdata(self, nodeorrev, _df=None):
io = self._io io = self._io
for i in self: for i in self:
e = io.packentry(self.index[i], self.node, self.version, i) e = io.packentry(self.index[i], self.node, self.version, i)
fp.write(e) fp.write(e)
# the temp file replace the real index when we exit the context # the temp file replace the real index when we exit the context
# manager # manager
tr.replace(self.indexfile, trindex * self._io.size) tr.replace(self.indexfile, trindex * self.index.entry_size)
nodemaputil.setup_persistent_nodemap(tr, self) nodemaputil.setup_persistent_nodemap(tr, self)
self._chunkclear() self._chunkclear()
def _nodeduplicatecallback(self, transaction, node): def _nodeduplicatecallback(self, transaction, node):
"""called when trying to add a node already stored.""" """called when trying to add a node already stored."""
def addrevision( def addrevision(
self, self,
offset = self._get_data_offset(prev) offset = self._get_data_offset(prev)
if self._concurrencychecker: if self._concurrencychecker:
if self._inline: if self._inline:
# offset is "as if" it were in the .d file, so we need to add on # offset is "as if" it were in the .d file, so we need to add on
# the size of the entry metadata. # the size of the entry metadata.
self._concurrencychecker( self._concurrencychecker(
ifh, self.indexfile, offset + curr * self._io.size ifh, self.indexfile, offset + curr * self.index.entry_size
) )
else: else:
# Entries in the .i are a consistent size. # Entries in the .i are a consistent size.
self._concurrencychecker( self._concurrencychecker(
ifh, self.indexfile, curr * self._io.size ifh, self.indexfile, curr * self.index.entry_size
) )
self._concurrencychecker(dfh, self.datafile, offset) self._concurrencychecker(dfh, self.datafile, offset)
p1r, p2r = self.rev(p1), self.rev(p2) p1r, p2r = self.rev(p1), self.rev(p2)
# full versions are inserted when the needed deltas # full versions are inserted when the needed deltas
# become comparable to the uncompressed text # become comparable to the uncompressed text
if rawtext is None: if rawtext is None:
transaction.add(self.indexfile, curr * len(entry)) transaction.add(self.indexfile, curr * len(entry))
if data[0]: if data[0]:
dfh.write(data[0]) dfh.write(data[0])
dfh.write(data[1]) dfh.write(data[1])
if sidedata: if sidedata:
dfh.write(sidedata) dfh.write(sidedata)
ifh.write(entry) ifh.write(entry)
else: else:
offset += curr * self._io.size offset += curr * self.index.entry_size
transaction.add(self.indexfile, offset) transaction.add(self.indexfile, offset)
ifh.write(entry) ifh.write(entry)
ifh.write(data[0]) ifh.write(data[0])
ifh.write(data[1]) ifh.write(data[1])
if sidedata: if sidedata:
ifh.write(sidedata) ifh.write(sidedata)
self._enforceinlinesize(transaction, ifh) self._enforceinlinesize(transaction, ifh)
nodemaputil.setup_persistent_nodemap(transaction, self) nodemaputil.setup_persistent_nodemap(transaction, self)
if self._writinghandles: if self._writinghandles:
raise error.ProgrammingError(b'cannot nest addgroup() calls') raise error.ProgrammingError(b'cannot nest addgroup() calls')
r = len(self) r = len(self)
end = 0 end = 0
if r: if r:
end = self.end(r - 1) end = self.end(r - 1)
ifh = self._indexfp(b"a+") ifh = self._indexfp(b"a+")
isize = r * self._io.size isize = r * self.index.entry_size
if self._inline: if self._inline:
transaction.add(self.indexfile, end + isize) transaction.add(self.indexfile, end + isize)
dfh = None dfh = None
else: else:
transaction.add(self.indexfile, isize) transaction.add(self.indexfile, isize)
transaction.add(self.datafile, end) transaction.add(self.datafile, end)
dfh = self._datafp(b"a+") dfh = self._datafp(b"a+")
rev, _ = self.getstrippoint(minlink) rev, _ = self.getstrippoint(minlink)
if rev == len(self): if rev == len(self):
return return
# first truncate the files on disk # first truncate the files on disk
end = self.start(rev) end = self.start(rev)
if not self._inline: if not self._inline:
transaction.add(self.datafile, end) transaction.add(self.datafile, end)
end = rev * self._io.size end = rev * self.index.entry_size
else: else:
end += rev * self._io.size end += rev * self.index.entry_size
transaction.add(self.indexfile, end) transaction.add(self.indexfile, end)
# then reset internal state in memory to forget those revisions # then reset internal state in memory to forget those revisions
self._revisioncache = None self._revisioncache = None
self._chaininfocache = util.lrucachedict(500) self._chaininfocache = util.lrucachedict(500)
self._chunkclear() self._chunkclear()
raise raise
dd = 0 dd = 0
try: try:
f = self.opener(self.indexfile) f = self.opener(self.indexfile)
f.seek(0, io.SEEK_END) f.seek(0, io.SEEK_END)
actual = f.tell() actual = f.tell()
f.close() f.close()
s = self._io.size s = self.index.entry_size
i = max(0, actual // s) i = max(0, actual // s)
di = actual - (i * s) di = actual - (i * s)
if self._inline: if self._inline:
databytes = 0 databytes = 0
for r in self: for r in self:
databytes += max(0, self.length(r)) databytes += max(0, self.length(r))
dd = 0 dd = 0
di = actual - len(self) * s - databytes di = actual - len(self) * s - databytes
entry += (current_offset, len(serialized_sidedata)) entry += (current_offset, len(serialized_sidedata))
fp.write(serialized_sidedata) fp.write(serialized_sidedata)
new_entries.append(entry) new_entries.append(entry)
current_offset += len(serialized_sidedata) current_offset += len(serialized_sidedata)
# rewrite the new index entries # rewrite the new index entries
with self._indexfp(b'w+') as fp: with self._indexfp(b'w+') as fp:
fp.seek(startrev * self._io.size) fp.seek(startrev * self.index.entry_size)
for i, entry in enumerate(new_entries): for i, entry in enumerate(new_entries):
rev = startrev + i rev = startrev + i
self.index.replace_sidedata_info(rev, entry[8], entry[9]) self.index.replace_sidedata_info(rev, entry[8], entry[9])
packed = self._io.packentry(entry, self.node, self.version, rev) packed = self._io.packentry(entry, self.node, self.version, rev)
fp.write(packed) fp.write(packed)

rust/hg-cpython/src/revlog.rs

// revlog.rs // revlog.rs
// //
// Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::{ use crate::{
cindex, cindex,
utils::{node_from_py_bytes, node_from_py_object}, utils::{node_from_py_bytes, node_from_py_object},
}; };
use cpython::{ use cpython::{
buffer::{Element, PyBuffer}, buffer::{Element, PyBuffer},
exc::{IndexError, ValueError}, exc::{IndexError, ValueError},
ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyModule, PyObject, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyInt, PyModule,
PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject, PyObject, PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject,
}; };
use hg::{ use hg::{
nodemap::{Block, NodeMapError, NodeTree}, nodemap::{Block, NodeMapError, NodeTree},
revlog::{nodemap::NodeMap, NodePrefix, RevlogIndex}, revlog::{nodemap::NodeMap, NodePrefix, RevlogIndex},
Revision, Revision,
}; };
use std::cell::RefCell; use std::cell::RefCell;
def update_nodemap_data( def update_nodemap_data(
&self, &self,
docket: PyObject, docket: PyObject,
nm_data: PyObject nm_data: PyObject
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
self.inner_update_nodemap_data(py, docket, nm_data) self.inner_update_nodemap_data(py, docket, nm_data)
} }
@property
def entry_size(&self) -> PyResult<PyInt> {
self.cindex(py).borrow().inner().getattr(py, "entry_size")?.extract::<PyInt>(py)
}
}); });
impl MixedIndex { impl MixedIndex {
fn new(py: Python, cindex: PyObject) -> PyResult<MixedIndex> { fn new(py: Python, cindex: PyObject) -> PyResult<MixedIndex> {
Self::create_instance( Self::create_instance(
py, py,
RefCell::new(cindex::Index::new(py, cindex)?), RefCell::new(cindex::Index::new(py, cindex)?),