linelog: cache calculate_dep_map result in linelog field

Summary:
I'd like to use the dependency map in more places. For example, to check if
remap_revs (re-order) is valid or not. If reorders get frequently tested,
it seems nice to cache the dependency map result.

Reviewed By: muirdm

Differential Revision: D103701815

fbshipit-source-id: eed78ca8fffb4fc78e18b940c740dee8480b37b7

Author: quark-zju

eden/scm/lib/linelog/src/linelog.rs

@@ -9,6 +9,7 @@ use std::collections::HashSet;
 use std::collections::VecDeque;
 use std::fmt;
 use std::sync::Arc;
+use std::sync::OnceLock;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 
@@ -25,6 +26,7 @@ pub struct AbstractLineLog<T> {
     pub(crate) dag: NanoDag,
 
     a_lines_cache: Option<(Rev, ImVec<LineInfo<T>>)>,
+    deps_map_cache: OnceLock<Arc<NanoDag>>,
     perf_stats: Option<Arc<PerfStats>>,
 }
 
@@ -46,6 +48,7 @@ impl<T> Clone for AbstractLineLog<T> {
             max_rev: self.max_rev,
             dag: self.dag.clone(),
             a_lines_cache: self.a_lines_cache.clone(),
+            deps_map_cache: self.deps_map_cache.clone(),
             perf_stats: self.perf_stats.clone(),
         }
     }
@@ -112,6 +115,7 @@ impl<T> Default for AbstractLineLog<T> {
             max_rev: 0,
             dag: Default::default(),
             a_lines_cache: None,
+            deps_map_cache: OnceLock::new(),
             perf_stats: None,
         }
     }
@@ -225,6 +229,7 @@ impl<T: Default + PartialEq + fmt::Debug> AbstractLineLog<T> {
             dag: new_dag,
             max_rev: self.max_rev.max(b_rev),
             a_lines_cache,
+            deps_map_cache: Default::default(),
             ..self
         }
     }
@@ -586,6 +591,7 @@ impl<T: Default + PartialEq + fmt::Debug> AbstractLineLog<T> {
             code,
             max_rev: self.max_rev.max(b_rev),
             a_lines_cache: None,
+            deps_map_cache: Default::default(),
             ..self
         }
     }
@@ -662,7 +668,7 @@ impl<T> AbstractLineLog<T> {
     /// the dag will resize to make sure all revs are present in the dag.
     ///
     /// Note: There are no checks about whether the reordering is meaningful.
-    /// The callsite should use `calculate_dep_map` to check dependencies
+    /// The callsite should use `can_reorder` to check dependencies
     /// and avoid troublesome reorders, like moving a change to before its
     /// dependency.
     pub fn remap_revs(self, rev_map: &dyn Fn(Rev) -> Rev) -> Self {
@@ -689,6 +695,7 @@ impl<T> AbstractLineLog<T> {
             max_rev,
             dag: self.dag.with_edge(max_rev, max_rev),
             a_lines_cache: None,
+            deps_map_cache: Default::default(),
             ..self
         }
     }
@@ -716,6 +723,7 @@ impl<T> AbstractLineLog<T> {
             code,
             max_rev,
             a_lines_cache: None,
+            deps_map_cache: Default::default(),
             ..self
         }
     }
@@ -724,6 +732,16 @@ impl<T> AbstractLineLog<T> {
     pub fn nanodag(&self) -> &NanoDag {
         &self.dag
     }
+
+    /// Get the dependency dag. If `rev1` has parent `rev2`, then `rev1`
+    /// textually depend on `rev2` and cannot be moved to an ancestor of `rev2`.
+    ///
+    /// Only includes revs explicitly appear in linelog instructions, i.e. revs
+    /// that actually edit the lines.
+    pub fn dep_map(&self) -> &Arc<NanoDag> {
+        self.deps_map_cache
+            .get_or_init(|| Arc::new(self.calculate_dep_map()))
+    }
 }
 
 impl<T: AsRef<str> + Default + PartialEq + fmt::Debug> AbstractLineLog<T> {

eden/scm/lib/linelog/src/stacks.rs

@@ -127,7 +127,7 @@ impl<T> AbstractLineLog<T> {
     /// deletions) might be skipped incorrectly after `remap_revs`.
     /// Practically, LineLog might allow reorder cases that would be disallowed
     /// by traditional context-line dependencies.
-    pub fn calculate_dep_map(&self) -> NanoDag {
+    pub(crate) fn calculate_dep_map(&self) -> NanoDag {
         // With the insertion and deletion stacks (see explanation in
         // visit_with_ins_del_stacks), when we see a new insertion block, or deletion
         // block, we add two dependencies:

eden/scm/lib/linelog/src/tests.rs

@@ -366,7 +366,7 @@ fn test_remap_revs() {
 fn test_remap_revs_reorder_insertions() {
     let log = log_from_texts(&["a\n".into(), "a\nb\n".into(), "a\nb\nc\n".into()]);
 
-    let dep_map = log.calculate_dep_map();
+    let dep_map = log.dep_map();
     for rev in 1..=3 {
         assert_eq!(dep_map.parents(rev), Some(&[0][..]), "rev={rev}");
     }
@@ -438,7 +438,7 @@ fn test_reorder_insertions(lines: &[&str], line_added_order: &[usize]) {
     let log = log_from_texts(&texts);
 
     // Verify dep map.
-    let deps = log.calculate_dep_map();
+    let deps = log.dep_map();
     assert!(
         deps.iter().all(|(rev, deps)| rev == 0 || deps == &[0]),
         "order={line_added_order:?}"
@@ -578,14 +578,14 @@ fn test_flatten() {
 }
 
 #[test]
-fn test_calculate_dep_map() {
-    let deps = |text_list: &[&str]| -> NanoDag {
+fn test_dep_map() {
+    let deps = |text_list: &[&str]| -> Arc<NanoDag> {
         let texts: Vec<String> = text_list
             .iter()
             .map(|t| t.chars().map(|c| format!("{c}\n")).collect::<String>())
             .collect();
         let log = log_from_texts(&texts);
-        log.calculate_dep_map()
+        log.dep_map().clone()
     };
 
     assert_eq!(deps(&[]).to_string(), "");
@@ -785,7 +785,7 @@ fn test_block_shift_effectiveness() {
             let lines = expected_rev3_lines[a1..a1 + n].to_vec();
             let log = base.clone().edit_chunk(2, a1, a1, 3, lines, flags);
             assert_eq!(log.checkout_text(3), expected_rev3_text);
-            let dep = log.calculate_dep_map();
+            let dep = log.dep_map();
             let dep = format!("DepMap({})", dep);
             grouped.entry(dep).or_default().push(a1);
         }
@@ -831,7 +831,7 @@ fn test_block_shift_overflow() {
         let log = base
             .clone()
             .edit_chunk(1, a1, a1, 1, vec![""], EditFlags::default());
-        let dep = log.calculate_dep_map();
+        let dep = log.dep_map();
         assert!(dep.iter().all(|(rev, deps)| rev == 0 || deps == &[0]))
     }
 }