This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10900

censor: extract the part about recomputing delta in a function
ClosedPublic

Authored by marmoute on Jun 22 2021, 7:27 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG60c48458ee6c: censor: extract the part about recomputing delta in a function
Summary

The v2_censor function is huge, now that its content has settled a bit it is a
good time to split individual part inside dedicated function.

It is now the turn of the logic that recompute new delta to replace the one
based on the revision that are going away.

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.Jun 22 2021, 7:27 PM
Alphare accepted this revision.Jul 1 2021, 4:50 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
mercurial/revlogutils/rewrite.py
262

nit: survive

This revision is now accepted and ready to land.Jul 1 2021, 4:50 AM

Revision Contents
Changeset List

PathPackages
Mmercurial/revlogutils/rewrite.py (98 lines)

Diff 28711

mercurial/revlogutils/rewrite.py

censor_rev = rl.rev(censornode) censor_rev = rl.rev(censornode)
tombstone = storageutil.packmeta({b'censored': tombstone}, b'') tombstone = storageutil.packmeta({b'censored': tombstone}, b'')
censored_entry = rl.index[censor_rev] censored_entry = rl.index[censor_rev]
index_cutoff = rl.index.entry_size * censor_rev index_cutoff = rl.index.entry_size * censor_rev
data_cutoff = censored_entry[ENTRY_DATA_OFFSET] >> 16 data_cutoff = censored_entry[ENTRY_DATA_OFFSET] >> 16
sidedata_cutoff = rl.sidedata_cut_off(censor_rev) sidedata_cutoff = rl.sidedata_cut_off(censor_rev)
# rev → (new_base, data_start, data_end)
rewritten_entries = {}
dc = deltas.deltacomputer(rl)
excl = [censor_rev]
with pycompat.unnamedtempfile(mode=b"w+b") as tmp_storage: with pycompat.unnamedtempfile(mode=b"w+b") as tmp_storage:
with rl._segmentfile._open_read() as dfh: # rev → (new_base, data_start, data_end, compression_mode)
for rev in range(censor_rev + 1, len(old_index)): rewritten_entries = _precompute_rewritten_delta(
entry = old_index[rev] rl,
if censor_rev != entry[ENTRY_DELTA_BASE]: old_index,
continue {censor_rev},
# This is a revision that use the censored revision as the base tmp_storage,
# for its delta. We need a need new deltas
if entry[ENTRY_DATA_UNCOMPRESSED_LENGTH] == 0:
# this revision is empty, we can delta against nullrev
rewritten_entries[rev] = (nullrev, 0, 0)
else:
text = rl.rawdata(rev, _df=dfh)
info = revlogutils.revisioninfo(
node=entry[ENTRY_NODE_ID],
p1=rl.node(entry[ENTRY_PARENT_1]),
p2=rl.node(entry[ENTRY_PARENT_2]),
btext=[text],
textlen=len(text),
cachedelta=None,
flags=entry[ENTRY_DATA_OFFSET] & 0xFFFF,
)
d = dc.finddeltainfo(
info, dfh, excluded_bases=excl, target_rev=rev
) )
default_comp = rl._docket.default_compression_header
comp_mode, d = deltas.delta_compression(default_comp, d)
# using `tell` is a bit lazy, but we are not here for speed
start = tmp_storage.tell()
tmp_storage.write(d.data[1])
end = tmp_storage.tell()
rewritten_entries[rev] = (d.base, start, end, comp_mode)
old_index_filepath = rl.opener.join(docket.index_filepath()) old_index_filepath = rl.opener.join(docket.index_filepath())
old_data_filepath = rl.opener.join(docket.data_filepath()) old_data_filepath = rl.opener.join(docket.data_filepath())
old_sidedata_filepath = rl.opener.join(docket.sidedata_filepath()) old_sidedata_filepath = rl.opener.join(docket.sidedata_filepath())
new_index_filepath = rl.opener.join(docket.new_index_file()) new_index_filepath = rl.opener.join(docket.new_index_file())
new_data_filepath = rl.opener.join(docket.new_data_file()) new_data_filepath = rl.opener.join(docket.new_data_file())
new_sidedata_filepath = rl.opener.join(docket.new_sidedata_file()) new_sidedata_filepath = rl.opener.join(docket.new_sidedata_file())
open_files, open_files,
rev, rev,
rewritten_entries, rewritten_entries,
tmp_storage, tmp_storage,
) )
docket.write(transaction=None, stripping=True) docket.write(transaction=None, stripping=True)
def _precompute_rewritten_delta(
revlog,
old_index,
excluded_revs,
tmp_storage,
):
"""Compute new delta for revisions whose delta is based on revision that
will not survive as is.
AlphareUnsubmitted
Not Done

nit: survive

Alphare: nit: survive
Return a mapping: {rev → (new_base, data_start, data_end, compression_mode)}
"""
dc = deltas.deltacomputer(revlog)
rewritten_entries = {}
first_excl_rev = min(excluded_revs)
with revlog._segmentfile._open_read() as dfh:
for rev in range(first_excl_rev, len(old_index)):
if rev in excluded_revs:
# this revision will be preserved as is, so we don't need to
# consider recomputing a delta.
continue
entry = old_index[rev]
if entry[ENTRY_DELTA_BASE] not in excluded_revs:
continue
# This is a revision that use the censored revision as the base
# for its delta. We need a need new deltas
if entry[ENTRY_DATA_UNCOMPRESSED_LENGTH] == 0:
# this revision is empty, we can delta against nullrev
rewritten_entries[rev] = (nullrev, 0, 0, COMP_MODE_PLAIN)
else:
text = revlog.rawdata(rev, _df=dfh)
info = revlogutils.revisioninfo(
node=entry[ENTRY_NODE_ID],
p1=revlog.node(entry[ENTRY_PARENT_1]),
p2=revlog.node(entry[ENTRY_PARENT_2]),
btext=[text],
textlen=len(text),
cachedelta=None,
flags=entry[ENTRY_DATA_OFFSET] & 0xFFFF,
)
d = dc.finddeltainfo(
info, dfh, excluded_bases=excluded_revs, target_rev=rev
)
default_comp = revlog._docket.default_compression_header
comp_mode, d = deltas.delta_compression(default_comp, d)
# using `tell` is a bit lazy, but we are not here for speed
start = tmp_storage.tell()
tmp_storage.write(d.data[1])
end = tmp_storage.tell()
rewritten_entries[rev] = (d.base, start, end, comp_mode)
return rewritten_entries
def _rewrite_simple( def _rewrite_simple(
revlog, revlog,
old_index, old_index,
all_files, all_files,
rev, rev,
rewritten_entries, rewritten_entries,
tmp_storage, tmp_storage,
): ):