This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10492

dirstate-tree: Add "non normal" and "from other parent" sets
ClosedPublic

Authored by SimonSapin on Apr 20 2021, 10:17 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGe3cebe96c0fc: dirstate-tree: Add "non normal" and "from other parent" sets
rHGa38e389fa680: dirstate-tree: Add "non normal" and "from other parent" sets
Summary

Unlike the other DirstateMap implementation, these sets are not materialized
separately in memory. Instead we traverse the main tree.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Apr 20 2021, 10:17 AM
baymax updated this revision to Diff 27142.Apr 20 2021, 1:03 PM

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

Alphare accepted this revision.Apr 22 2021, 5:25 AM
This revision is now accepted and ready to land.Apr 22 2021, 5:25 AM
SimonSapin updated this revision to Diff 27318.May 3 2021, 6:24 AM

Revision Contents
Changeset List

Diff 27112

rust/hg-core/src/dirstate.rs

#[derive(Debug, PartialEq, Copy, Clone)] #[derive(Debug, PartialEq, Copy, Clone)]
pub struct DirstateEntry { pub struct DirstateEntry {
pub state: EntryState, pub state: EntryState,
pub mode: i32, pub mode: i32,
pub mtime: i32, pub mtime: i32,
pub size: i32, pub size: i32,
} }
impl DirstateEntry {
pub fn is_non_normal(&self) -> bool {
self.state != EntryState::Normal || self.mtime == MTIME_UNSET
}
pub fn is_from_other_parent(&self) -> bool {
self.state == EntryState::Normal && self.size == SIZE_FROM_OTHER_PARENT
}
}
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
struct RawEntry { struct RawEntry {
state: u8, state: u8,
mode: unaligned::I32Be, mode: unaligned::I32Be,
size: unaligned::I32Be, size: unaligned::I32Be,
mtime: unaligned::I32Be, mtime: unaligned::I32Be,
length: unaligned::I32Be, length: unaligned::I32Be,
} }
const MTIME_UNSET: i32 = -1;
/// A `DirstateEntry` with a size of `-2` means that it was merged from the /// A `DirstateEntry` with a size of `-2` means that it was merged from the
/// other parent. This allows revert to pick the right status back during a /// other parent. This allows revert to pick the right status back during a
/// merge. /// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2; pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
pub type StateMap = FastHashMap<HgPathBuf, DirstateEntry>; pub type StateMap = FastHashMap<HgPathBuf, DirstateEntry>;
pub type StateMapIter<'a> = pub type StateMapIter<'a> =
Box<dyn Iterator<Item = (&'a HgPathBuf, &'a DirstateEntry)> + Send + 'a>; Box<dyn Iterator<Item = (&'a HgPathBuf, &'a DirstateEntry)> + Send + 'a>;

rust/hg-core/src/dirstate/dirstate_map.rs

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@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::dirstate::parsers::clear_ambiguous_mtime; use crate::dirstate::parsers::clear_ambiguous_mtime;
use crate::dirstate::parsers::Timestamp; use crate::dirstate::parsers::Timestamp;
use crate::errors::HgError; use crate::errors::HgError;
use crate::revlog::node::NULL_NODE; use crate::revlog::node::NULL_NODE;
use crate::{ use crate::{
dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT}, dirstate::{parsers::PARENT_SIZE, EntryState},
pack_dirstate, parse_dirstate, pack_dirstate, parse_dirstate,
utils::{ utils::{
files::normalize_case, files::normalize_case,
hg_path::{HgPath, HgPathBuf}, hg_path::{HgPath, HgPathBuf},
}, },
CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError, CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError,
DirstateParents, FastHashMap, StateMap, DirstateParents, FastHashMap, StateMap,
}; };
use micro_timer::timed; use micro_timer::timed;
use std::collections::HashSet; use std::collections::HashSet;
use std::convert::TryInto; use std::convert::TryInto;
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
pub type FileFoldMap = FastHashMap<HgPathBuf, HgPathBuf>; pub type FileFoldMap = FastHashMap<HgPathBuf, HgPathBuf>;
const MTIME_UNSET: i32 = -1;
#[derive(Default)] #[derive(Default)]
pub struct DirstateMap { pub struct DirstateMap {
state_map: StateMap, state_map: StateMap,
pub copy_map: CopyMap, pub copy_map: CopyMap,
file_fold_map: Option<FileFoldMap>, file_fold_map: Option<FileFoldMap>,
pub dirs: Option<DirsMultiset>, pub dirs: Option<DirsMultiset>,
pub all_dirs: Option<DirsMultiset>, pub all_dirs: Option<DirsMultiset>,
non_normal_set: Option<HashSet<HgPathBuf>>, non_normal_set: Option<HashSet<HgPathBuf>>,
} }
if old_state == EntryState::Unknown { if old_state == EntryState::Unknown {
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.add_path(filename)?; all_dirs.add_path(filename)?;
} }
} }
self.state_map.insert(filename.to_owned(), entry.to_owned()); self.state_map.insert(filename.to_owned(), entry.to_owned());
if entry.state != EntryState::Normal || entry.mtime == MTIME_UNSET { if entry.is_non_normal() {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
if entry.size == SIZE_FROM_OTHER_PARENT { if entry.is_from_other_parent() {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.1 .1
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
Ok(()) Ok(())
} }
/// Mark a file as removed in the dirstate. /// Mark a file as removed in the dirstate.
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
} }
} }
} }
pub fn non_normal_entries_remove( pub fn non_normal_entries_remove(&mut self, key: impl AsRef<HgPath>) {
&mut self,
key: impl AsRef<HgPath>,
) -> bool {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.remove(key.as_ref()) .remove(key.as_ref());
} }
pub fn non_normal_entries_union( pub fn non_normal_entries_union(
&mut self, &mut self,
other: HashSet<HgPathBuf>, other: HashSet<HgPathBuf>,
) -> Vec<HgPathBuf> { ) -> Vec<HgPathBuf> {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.union(&other) .union(&other)
.map(ToOwned::to_owned) .map(ToOwned::to_owned)
&& self.non_normal_set.is_some() && self.non_normal_set.is_some()
&& self.other_parent_set.is_some() && self.other_parent_set.is_some()
{ {
return; return;
} }
let mut non_normal = HashSet::new(); let mut non_normal = HashSet::new();
let mut other_parent = HashSet::new(); let mut other_parent = HashSet::new();
for ( for (filename, entry) in self.state_map.iter() {
filename, if entry.is_non_normal() {
DirstateEntry {
state, size, mtime, ..
},
) in self.state_map.iter()
{
if *state != EntryState::Normal || *mtime == MTIME_UNSET {
non_normal.insert(filename.to_owned()); non_normal.insert(filename.to_owned());
} }
if *state == EntryState::Normal && *size == SIZE_FROM_OTHER_PARENT if entry.is_from_other_parent() {
{
other_parent.insert(filename.to_owned()); other_parent.insert(filename.to_owned());
} }
} }
self.non_normal_set = Some(non_normal); self.non_normal_set = Some(non_normal);
self.other_parent_set = Some(other_parent); self.other_parent_set = Some(other_parent);
} }
/// Both of these setters and their uses appear to be the simplest way to /// Both of these setters and their uses appear to be the simplest way to

rust/hg-core/src/dirstate_tree/dirstate_map.rs

if let Some(node) = Self::get_node_mut(&mut self.root, &filename) { if let Some(node) = Self::get_node_mut(&mut self.root, &filename) {
if let Some(entry) = node.entry.as_mut() { if let Some(entry) = node.entry.as_mut() {
clear_ambiguous_mtime(entry, now); clear_ambiguous_mtime(entry, now);
} }
} }
} }
} }
fn non_normal_entries_contains(&mut self, _key: &HgPath) -> bool { fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool {
todo!() self.get_node(key)
.and_then(|node| node.entry.as_ref())
.map_or(false, DirstateEntry::is_non_normal)
} }
fn non_normal_entries_remove(&mut self, _key: &HgPath) -> bool { fn non_normal_entries_remove(&mut self, _key: &HgPath) {
todo!() // Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" set that need to be kept up to date
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> { ) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> {
todo!() Box::new(self.iter_nodes().filter_map(|(path, node)| {
node.entry
.as_ref()
.filter(|entry| {
entry.is_non_normal() || entry.is_from_other_parent()
})
.map(|_| path.full_path())
}))
} }
fn set_non_normal_other_parent_entries(&mut self, _force: bool) { fn set_non_normal_other_parent_entries(&mut self, _force: bool) {
todo!() // Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" and "from other parent" sets that need to be recomputed
} }
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
todo!() self.iter_non_normal_paths_panic()
} }
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
todo!() Box::new(self.iter_nodes().filter_map(|(path, node)| {
node.entry
.as_ref()
.filter(|entry| entry.is_non_normal())
.map(|_| path.full_path())
}))
} }
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
todo!() Box::new(self.iter_nodes().filter_map(|(path, node)| {
node.entry
.as_ref()
.filter(|entry| entry.is_from_other_parent())
.map(|_| path.full_path())
}))
} }
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateMapError> {
if let Some(node) = self.get_node(directory) { if let Some(node) = self.get_node(directory) {
// A node without a `DirstateEntry` was created to hold child // A node without a `DirstateEntry` was created to hold child

rust/hg-core/src/dirstate_tree/dispatch.rs

filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
) -> Result<bool, DirstateMapError>; ) -> Result<bool, DirstateMapError>;
fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32); fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32);
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool; fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool;
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool; fn non_normal_entries_remove(&mut self, key: &HgPath);
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + '_>; ) -> Box<dyn Iterator<Item = &HgPathBuf> + '_>;
fn set_non_normal_other_parent_entries(&mut self, force: bool); fn set_non_normal_other_parent_entries(&mut self, force: bool);
fn iter_non_normal_paths( fn iter_non_normal_paths(
} }
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool { fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool {
let (non_normal, _other_parent) = let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
non_normal.contains(key) non_normal.contains(key)
} }
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool { fn non_normal_entries_remove(&mut self, key: &HgPath) {
self.non_normal_entries_remove(key) self.non_normal_entries_remove(key)
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> { ) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> {
let (non_normal, other_parent) = let (non_normal, other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();