This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9084

rust-dirstatemap: add #[timed] to dirstatemap read for comparison
ClosedPublic

Authored by Alphare on Sep 25 2020, 12:05 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG80bf7b1ada15: rust-dirstatemap: add #[timed] to dirstatemap read for comparison

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

Alphare created this revision.Sep 25 2020, 12:05 PM
martinvonz added a subscriber: martinvonz.Sep 25 2020, 1:22 PM
martinvonz added inline comments.
rust/hg-core/src/dirstate/dirstate_map.rs
19

I let hg fix move this line on step down in flight (test-check-rust-format.t was failing).

Alphare added a commit: rHG80bf7b1ada15: rust-dirstatemap: add #[timed] to dirstatemap read for comparison.Sep 25 2020, 1:23 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG80bf7b1ada15: rust-dirstatemap: add #[timed] to dirstatemap read for comparison (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22856

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::revlog::node::NULL_NODE_ID; use crate::revlog::node::NULL_NODE_ID;
use crate::{ use crate::{
dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT}, dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT},
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,
DirstateParents, DirstateParseError, FastHashMap, StateMap, DirstateParseError, FastHashMap, StateMap,
}; };
use core::borrow::Borrow; use core::borrow::Borrow;
martinvonzUnsubmitted
Not Done

I let hg fix move this line on step down in flight (test-check-rust-format.t was failing).

martinvonz: I let `hg fix` move this line on step down in flight (`test-check-rust-format.t` was failing).
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;
use std::time::Duration; use std::time::Duration;
pub type FileFoldMap = FastHashMap<HgPathBuf, HgPathBuf>; pub type FileFoldMap = FastHashMap<HgPathBuf, HgPathBuf>;
type Target = StateMap; type Target = StateMap;
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
&self.state_map &self.state_map
} }
} }
impl FromIterator<(HgPathBuf, DirstateEntry)> for DirstateMap { impl FromIterator<(HgPathBuf, DirstateEntry)> for DirstateMap {
fn from_iter<I: IntoIterator<Item = (HgPathBuf, DirstateEntry)>>( fn from_iter<I: IntoIterator<Item = (HgPathBuf, DirstateEntry)>>(iter: I) -> Self {
iter: I,
) -> Self {
Self { Self {
state_map: iter.into_iter().collect(), state_map: iter.into_iter().collect(),
..Self::default() ..Self::default()
} }
} }
} }
impl DirstateMap { impl DirstateMap {
/// Add a tracked file to the dirstate /// Add a tracked file to the dirstate
pub fn add_file( pub fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateMapError> {
if old_state == EntryState::Unknown || old_state == EntryState::Removed if old_state == EntryState::Unknown || old_state == EntryState::Removed {
{
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.add_path(filename)?; dirs.add_path(filename)?;
} }
} }
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)?;
} }
/// the file's previous state. In the future, we should refactor this /// the file's previous state. In the future, we should refactor this
/// to be more explicit about what that state is. /// to be more explicit about what that state is.
pub fn remove_file( pub fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
size: i32, size: i32,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateMapError> {
if old_state != EntryState::Unknown && old_state != EntryState::Removed if old_state != EntryState::Unknown && old_state != EntryState::Removed {
{
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
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.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.remove(filename); .remove(filename);
Ok(exists) Ok(exists)
} }
pub fn clear_ambiguous_times( pub fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) {
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) {
for filename in filenames { for filename in filenames {
let mut changed = false; let mut changed = false;
self.state_map self.state_map
.entry(filename.to_owned()) .entry(filename.to_owned())
.and_modify(|entry| { .and_modify(|entry| {
if entry.state == EntryState::Normal && entry.mtime == now if entry.state == EntryState::Normal && entry.mtime == now {
{
changed = true; changed = true;
*entry = DirstateEntry { *entry = DirstateEntry {
mtime: MTIME_UNSET, mtime: MTIME_UNSET,
..*entry ..*entry
}; };
} }
}); });
if changed { if changed {
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>) -> bool {
&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, other: HashSet<HgPathBuf>) -> Vec<HgPathBuf> {
&mut self,
other: HashSet<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)
.collect() .collect()
} }
pub fn get_non_normal_other_parent_entries( pub fn get_non_normal_other_parent_entries(
) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>) { ) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>) {
( (
self.non_normal_set.as_ref().unwrap(), self.non_normal_set.as_ref().unwrap(),
self.other_parent_set.as_ref().unwrap(), self.other_parent_set.as_ref().unwrap(),
) )
} }
pub fn set_non_normal_other_parent_entries(&mut self, force: bool) { pub fn set_non_normal_other_parent_entries(&mut self, force: bool) {
if !force if !force && self.non_normal_set.is_some() && self.other_parent_set.is_some() {
&& self.non_normal_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, filename,
DirstateEntry { DirstateEntry {
state, size, mtime, .. state, size, mtime, ..
}, },
) in self.state_map.iter() ) in self.state_map.iter()
{ {
if *state != EntryState::Normal || *mtime == MTIME_UNSET { 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 *state == EntryState::Normal && *size == SIZE_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
/// emulate a Python lazy property, but it is ugly and unidiomatic. /// emulate a Python lazy property, but it is ugly and unidiomatic.
/// TODO One day, rewriting this struct using the typestate might be a /// TODO One day, rewriting this struct using the typestate might be a
/// good idea. /// good idea.
pub fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { pub fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> {
if self.all_dirs.is_none() { if self.all_dirs.is_none() {
self.all_dirs = self.all_dirs = Some(DirsMultiset::from_dirstate(&self.state_map, None)?);
Some(DirsMultiset::from_dirstate(&self.state_map, None)?);
} }
Ok(()) Ok(())
} }
pub fn set_dirs(&mut self) -> Result<(), DirstateMapError> { pub fn set_dirs(&mut self) -> Result<(), DirstateMapError> {
if self.dirs.is_none() { if self.dirs.is_none() {
self.dirs = Some(DirsMultiset::from_dirstate( self.dirs = Some(DirsMultiset::from_dirstate(
&self.state_map, &self.state_map,
Some(EntryState::Removed), Some(EntryState::Removed),
)?); )?);
} }
Ok(()) Ok(())
} }
pub fn has_tracked_dir( pub fn has_tracked_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateMapError> {
&mut self,
directory: &HgPath,
) -> Result<bool, DirstateMapError> {
self.set_dirs()?; self.set_dirs()?;
Ok(self.dirs.as_ref().unwrap().contains(directory)) Ok(self.dirs.as_ref().unwrap().contains(directory))
} }
pub fn has_dir( pub fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateMapError> {
&mut self,
directory: &HgPath,
) -> Result<bool, DirstateMapError> {
self.set_all_dirs()?; self.set_all_dirs()?;
Ok(self.all_dirs.as_ref().unwrap().contains(directory)) Ok(self.all_dirs.as_ref().unwrap().contains(directory))
} }
pub fn parents( pub fn parents(&mut self, file_contents: &[u8]) -> Result<&DirstateParents, DirstateError> {
&mut self,
file_contents: &[u8],
) -> Result<&DirstateParents, DirstateError> {
if let Some(ref parents) = self.parents { if let Some(ref parents) = self.parents {
return Ok(parents); return Ok(parents);
} }
let parents; let parents;
if file_contents.len() == PARENT_SIZE * 2 { if file_contents.len() == PARENT_SIZE * 2 {
parents = DirstateParents { parents = DirstateParents {
p1: file_contents[..PARENT_SIZE].try_into().unwrap(), p1: file_contents[..PARENT_SIZE].try_into().unwrap(),
p2: file_contents[PARENT_SIZE..PARENT_SIZE * 2] p2: file_contents[PARENT_SIZE..PARENT_SIZE * 2]
Ok(self.parents.as_ref().unwrap()) Ok(self.parents.as_ref().unwrap())
} }
pub fn set_parents(&mut self, parents: &DirstateParents) { pub fn set_parents(&mut self, parents: &DirstateParents) {
self.parents = Some(parents.clone()); self.parents = Some(parents.clone());
self.dirty_parents = true; self.dirty_parents = true;
} }
pub fn read( #[timed]
&mut self, pub fn read(&mut self, file_contents: &[u8]) -> Result<Option<DirstateParents>, DirstateError> {
file_contents: &[u8],
) -> Result<Option<DirstateParents>, DirstateError> {
if file_contents.is_empty() { if file_contents.is_empty() {
return Ok(None); return Ok(None);
} }
let (parents, entries, copies) = parse_dirstate(file_contents)?; let (parents, entries, copies) = parse_dirstate(file_contents)?;
self.state_map.extend( self.state_map.extend(
entries entries
.into_iter() .into_iter()
Ok(Some(parents)) Ok(Some(parents))
} }
pub fn pack( pub fn pack(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Duration, now: Duration,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
let packed = let packed = pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?;
pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?;
self.dirty_parents = false; self.dirty_parents = false;
self.set_non_normal_other_parent_entries(true); self.set_non_normal_other_parent_entries(true);
Ok(packed) Ok(packed)
} }
pub fn build_file_fold_map(&mut self) -> &FileFoldMap { pub fn build_file_fold_map(&mut self) -> &FileFoldMap {
if let Some(ref file_fold_map) = self.file_fold_map { if let Some(ref file_fold_map) = self.file_fold_map {
return file_fold_map; return file_fold_map;
} }
let mut new_file_fold_map = FileFoldMap::default(); let mut new_file_fold_map = FileFoldMap::default();
for (filename, DirstateEntry { state, .. }) in self.state_map.borrow() for (filename, DirstateEntry { state, .. }) in self.state_map.borrow() {
{
if *state == EntryState::Removed { if *state == EntryState::Removed {
new_file_fold_map new_file_fold_map.insert(normalize_case(filename), filename.to_owned());
.insert(normalize_case(filename), filename.to_owned());
} }
} }
self.file_fold_map = Some(new_file_fold_map); self.file_fold_map = Some(new_file_fold_map);
self.file_fold_map.as_ref().unwrap() self.file_fold_map.as_ref().unwrap()
} }
} }
#[cfg(test)] #[cfg(test)]
.iter() .iter()
.map(|x| HgPathBuf::from_bytes(x.as_ref())) .map(|x| HgPathBuf::from_bytes(x.as_ref()))
.collect(); .collect();
let mut other_parent = HashSet::new(); let mut other_parent = HashSet::new();
other_parent.insert(HgPathBuf::from_bytes(b"f4")); other_parent.insert(HgPathBuf::from_bytes(b"f4"));
let entries = map.get_non_normal_other_parent_entries(); let entries = map.get_non_normal_other_parent_entries();
assert_eq!( assert_eq!((&mut non_normal, &mut other_parent), (entries.0, entries.1));
(&mut non_normal, &mut other_parent),
(entries.0, entries.1)
);
} }
} }