( )⚙ D8098 rust-nodemap: a method for full invalidation

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8098

rust-nodemap: a method for full invalidation
ClosedPublic

Authored by marmoute on Feb 8 2020, 12:45 PM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHGd518994384a4: rust-nodemap: a method for full invalidation
rHGbbc61f36733c: rust-nodemap: a method for full invalidation
Summary

This will be used for exceptional operations,
such as a __delitem__ on the MixedIndex with
Rust nodemap.

In principle, NodeTree should also be able to forget
an entry in an efficient way, by accepting to insert
Element::None instead of only Element::Rev(r),
but that seems really overkill at this point. We need
to support exceptional operations such as __delitem__,
only for completeness of the revlog index as seen from
Python. The Python callers don't seem to even really
need it, deciding to drop the nodemap inconditionnally at
at higher level when calling hg strip. Also, hg strip
is very costly for reasons that are unrelated to nodemap
aspects.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

marmoute created this revision.Feb 8 2020, 12:45 PM
Alphare updated this revision to Diff 20220.Feb 14 2020, 6:02 AM
Alphare updated this revision to Diff 20239.Feb 15 2020, 6:50 AM
Alphare updated this revision to Diff 20280.Feb 24 2020, 5:13 AM
kevincox accepted this revision.Feb 24 2020, 5:56 AM
kevincox added inline comments.
rust/hg-core/src/revlog/nodemap.rs
580

-> () is unnecessary.

583

End the line with a ;.

Alphare updated this revision to Diff 20285.Feb 24 2020, 8:15 AM
gracinet added a commit: rHGbbc61f36733c: rust-nodemap: a method for full invalidation.Feb 26 2020, 10:33 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGbbc61f36733c: rust-nodemap: a method for full invalidation (authored by gracinet). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/revlog/nodemap.rs (35 lines)

Diff 20285

rust/hg-core/src/revlog/nodemap.rs

break; break;
} }
block.set(visited.nybble, to_write); block.set(visited.nybble, to_write);
block_idx = new_idx; block_idx = new_idx;
} }
Ok(()) Ok(())
} }
/// Make the whole `NodeTree` logically empty, without touching the
/// immutable part.
pub fn invalidate_all(&mut self) {
kevincoxUnsubmitted
Not Done

-> () is unnecessary.

kevincox: `-> ()` is unnecessary.
self.root = Block::new();
self.growable = Vec::new();
self.masked_inner_blocks = self.readonly.len();
kevincoxUnsubmitted
Not Done

End the line with a ;.

kevincox: End the line with a `;`.
}
/// Return the number of blocks in the readonly part that are currently /// Return the number of blocks in the readonly part that are currently
/// masked in the mutable part. /// masked in the mutable part.
/// ///
/// The `NodeTree` structure has no efficient way to know how many blocks /// The `NodeTree` structure has no efficient way to know how many blocks
/// are already unreachable in the readonly part. /// are already unreachable in the readonly part.
///
/// After a call to `invalidate_all()`, the returned number can be actually
/// bigger than the whole readonly part, a conventional way to mean that
/// all the readonly blocks have been masked. This is what is really
/// useful to the caller and does not require to know how many were
/// actually unreachable to begin with.
pub fn masked_readonly_blocks(&self) -> usize { pub fn masked_readonly_blocks(&self) -> usize {
if let Some(readonly_root) = self.readonly.last() { if let Some(readonly_root) = self.readonly.last() {
if readonly_root == &self.root { if readonly_root == &self.root {
return 0; return 0;
} }
} else { } else {
return 0; return 0;
} }
// inserting "c0" is just splitting the 'c' slot of the mutable root, // inserting "c0" is just splitting the 'c' slot of the mutable root,
// it doesn't mask anything // it doesn't mask anything
assert_eq!(idx.nt.masked_readonly_blocks(), 4); assert_eq!(idx.nt.masked_readonly_blocks(), 4);
Ok(()) Ok(())
} }
#[test] #[test]
fn test_invalidate_all() -> Result<(), NodeMapError> {
let mut idx = TestNtIndex::new();
idx.insert(0, "1234")?;
idx.insert(1, "1235")?;
idx.insert(2, "131")?;
idx.insert(3, "cafe")?;
let mut idx = idx.commit();
idx.nt.invalidate_all();
assert_eq!(idx.find_hex("1234")?, None);
assert_eq!(idx.find_hex("1235")?, None);
assert_eq!(idx.find_hex("131")?, None);
assert_eq!(idx.find_hex("cafe")?, None);
// all the readonly blocks have been masked, this is the
// conventional expected response
assert_eq!(idx.nt.masked_readonly_blocks(), idx.nt.readonly.len() + 1);
Ok(())
}
#[test]
fn test_into_added_empty() { fn test_into_added_empty() {
assert!(sample_nodetree().into_readonly_and_added().1.is_empty()); assert!(sample_nodetree().into_readonly_and_added().1.is_empty());
assert!(sample_nodetree() assert!(sample_nodetree()
.into_readonly_and_added_bytes() .into_readonly_and_added_bytes()
.1 .1
.is_empty()); .is_empty());
} }