This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9304

copies-rust: combine the iteration over remove and copies into one
ClosedPublic

Authored by marmoute on Nov 12 2020, 10:16 AM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGed0e1339e4a8: copies-rust: combine the iteration over remove and copies into one
Summary

In the underlying data, the copies information and the removal information are
interleaved. And in the consumer code, the consumption could be interleaved too.
So, we make the processing closer to the underlying data by fusing the two
iterators into one. Later, we will directly consume the underlying data and that
logic to combine the two iterators will be unnecessary.

Diff Detail

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

Event Timeline

marmoute created this revision.Nov 12 2020, 10:16 AM
Alphare accepted this revision.Nov 13 2020, 7:54 AM
Alphare added a subscriber: Alphare.

You accidentally a verb at the end of the commit description, and there are a few typos here and there, but otherwise it looks good.

marmoute edited the summary of this revision. (Show Details)Nov 13 2020, 7:05 PM
marmoute updated this revision to Diff 23498.
Alphare accepted this revision.Nov 16 2020, 6:19 AM
Alphare updated this revision to Diff 23727.Nov 27 2020, 11:11 AM
marmoute updated this revision to Diff 23809.Nov 29 2020, 6:12 AM
pulkit accepted this revision.Nov 29 2020, 2:07 PM
This revision is now accepted and ready to land.Nov 29 2020, 2:07 PM

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/copy_tracing.rs (95 lines)

Diff 23474

rust/hg-core/src/copy_tracing.rs

use crate::utils::hg_path::HgPath;
use crate::utils::hg_path::HgPathBuf; use crate::utils::hg_path::HgPathBuf;
use crate::Revision; use crate::Revision;
use im_rc::ordmap::DiffItem; use im_rc::ordmap::DiffItem;
use im_rc::ordmap::OrdMap; use im_rc::ordmap::OrdMap;
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::HashSet; use std::collections::HashSet;
pub struct ChangedFiles { pub struct ChangedFiles {
removed: HashSet<HgPathBuf>, removed: HashSet<HgPathBuf>,
merged: HashSet<HgPathBuf>, merged: HashSet<HgPathBuf>,
salvaged: HashSet<HgPathBuf>, salvaged: HashSet<HgPathBuf>,
copied_from_p1: PathCopies, copied_from_p1: PathCopies,
copied_from_p2: PathCopies, copied_from_p2: PathCopies,
} }
/// Represent active changes that affect the copy tracing.
enum Action<'a> {
/// The parent → children edge is removing a file
///
/// (actually, this could be the edge from the other parent, but it does
/// not matters)
Removed(&'a HgPath),
/// The parent → children edge introduce copy information between (dest,
/// source)
Copied(&'a HgPath, &'a HgPath),
}
impl ChangedFiles { impl ChangedFiles {
pub fn new( pub fn new(
removed: HashSet<HgPathBuf>, removed: HashSet<HgPathBuf>,
merged: HashSet<HgPathBuf>, merged: HashSet<HgPathBuf>,
salvaged: HashSet<HgPathBuf>, salvaged: HashSet<HgPathBuf>,
copied_from_p1: PathCopies, copied_from_p1: PathCopies,
copied_from_p2: PathCopies, copied_from_p2: PathCopies,
) -> Self { ) -> Self {
ChangedFiles { ChangedFiles {
removed: HashSet::new(), removed: HashSet::new(),
merged: HashSet::new(), merged: HashSet::new(),
salvaged: HashSet::new(), salvaged: HashSet::new(),
copied_from_p1: PathCopies::new(), copied_from_p1: PathCopies::new(),
copied_from_p2: PathCopies::new(), copied_from_p2: PathCopies::new(),
} }
} }
/// Return an iterator over all the `Action` in this instance.
fn iter_actions(&self, parent: usize) -> impl Iterator<Item = Action> {
let copies_iter = match parent {
1 => self.copied_from_p1.iter(),
2 => self.copied_from_p2.iter(),
_ => unreachable!(),
};
let remove_iter = self.removed.iter();
let copies_iter = copies_iter.map(|(x, y)| Action::Copied(x, y));
let remove_iter = remove_iter.map(|x| Action::Removed(x));
copies_iter.chain(remove_iter)
}
} }
/// A struct responsible for answering "is X ancestors of Y" quickly /// A struct responsible for answering "is X ancestors of Y" quickly
/// ///
/// The structure will delegate ancestors call to a callback, and cache the /// The structure will delegate ancestors call to a callback, and cache the
/// result. /// result.
#[derive(Debug)] #[derive(Debug)]
struct AncestorOracle<'a, A: Fn(Revision, Revision) -> bool> { struct AncestorOracle<'a, A: Fn(Revision, Revision) -> bool> {
for child in current_children.into_iter() { for child in current_children.into_iter() {
// We will chain the copies information accumulated for `rev` with // We will chain the copies information accumulated for `rev` with
// the individual copies information for each of its children. // the individual copies information for each of its children.
// Creating a new PathCopies for each `rev` → `children` vertex. // Creating a new PathCopies for each `rev` → `children` vertex.
let (p1, p2, changes) = rev_info(*child); let (p1, p2, changes) = rev_info(*child);
let parent; let parent;
let child_copies;
if rev == p1 { if rev == p1 {
parent = 1; parent = 1;
child_copies = &changes.copied_from_p1;
} else { } else {
assert_eq!(rev, p2); assert_eq!(rev, p2);
parent = 2; parent = 2;
child_copies = &changes.copied_from_p2;
} }
let mut new_copies = copies.clone(); let mut new_copies = copies.clone();
for (dest, source) in child_copies.into_iter() { for action in changes.iter_actions(parent) {
match action {
Action::Copied(dest, source) => {
let entry; let entry;
if let Some(v) = copies.get(source) { if let Some(v) = copies.get(source) {
entry = match &v.path { entry = match &v.path {
Some(path) => Some((*(path)).to_owned()), Some(path) => Some((*(path)).to_owned()),
None => Some(source.to_owned()), None => Some(source.to_owned()),
} }
} else { } else {
entry = Some(source.to_owned()); entry = Some(source.to_owned());
} }
// Each new entry is introduced by the children, we record this // Each new entry is introduced by the children, we
// information as we will need it to take the right decision // record this information as we will need it to take
// when merging conflicting copy information. See // the right decision when merging conflicting copy
// merge_copies_dict for details. // information. See merge_copies_dict for details.
let ttpc = TimeStampedPathCopy { let ttpc = TimeStampedPathCopy {
rev: *child, rev: *child,
path: entry, path: entry,
}; };
new_copies.insert(dest.to_owned(), ttpc); new_copies.insert(dest.to_owned(), ttpc);
} }
Action::Removed(f) => {
// We must drop copy information for removed file. // We must drop copy information for removed file.
// //
// We need to explicitly record them as dropped to propagate this // We need to explicitly record them as dropped to
// information when merging two TimeStampedPathCopies object. // propagate this information when merging two
for f in changes.removed.iter() { // TimeStampedPathCopies object.
if new_copies.contains_key(f.as_ref()) { if new_copies.contains_key(f.as_ref()) {
let ttpc = TimeStampedPathCopy { let ttpc = TimeStampedPathCopy {
rev: *child, rev: *child,
path: None, path: None,
}; };
new_copies.insert(f.to_owned(), ttpc); new_copies.insert(f.to_owned(), ttpc);
} }
} }
}
}
// Merge has two parents needs to combines their copy information. // Merge has two parents needs to combines their copy information.
// //
// If the vertex from the other parent was already processed, we // If the vertex from the other parent was already processed, we
// will have a value for the child ready to be used. We need to // will have a value for the child ready to be used. We need to
// grab it and combine it with the one we already // grab it and combine it with the one we already
// computed. If not we can simply store the newly // computed. If not we can simply store the newly
// computed data. The processing happening at // computed data. The processing happening at