Use faster compose implementation for symmetric filters

Such filters can never have any non unique mappings
and as such don't need the complexity of the more general
algorithm that ensures uniqueness.
The simpler implementation compose_fast() results in large
speedups (2x and more) when trying different compose filters
on the Josh repo.

Change-Id: compose-fast

Author: christian-schilling

src/filter/mod.rs

@@ -322,15 +322,30 @@ fn apply_to_commit2(
 
             let filtered = some_or!(filtered, { return Ok(None) });
 
-            let filtered = filters
-                .iter()
-                .zip(filtered.into_iter())
-                .filter(|(_, id)| *id != git2::Oid::zero())
-                .into_iter()
-                .map(|(f, id)| Ok((f, repo.find_commit(id)?.tree()?)))
-                .collect::<JoshResult<Vec<_>>>()?;
+            let inverted = filter::invert(filter)?;
+
+            if filter == inverted {
+                // If the filter is symetric it does not change any paths and uniqueness of
+                // mappings is already guaranteed.
+                let filtered = filtered
+                    .into_iter()
+                    .filter(|id| *id != git2::Oid::zero())
+                    .into_iter()
+                    .map(|id| Ok(repo.find_commit(id)?.tree_id()))
+                    .collect::<JoshResult<Vec<_>>>()?;
+
+                tree::compose_fast(transaction, filtered)?
+            } else {
+                let filtered = filters
+                    .iter()
+                    .zip(filtered.into_iter())
+                    .filter(|(_, id)| *id != git2::Oid::zero())
+                    .into_iter()
+                    .map(|(f, id)| Ok((f, repo.find_commit(id)?.tree()?)))
+                    .collect::<JoshResult<Vec<_>>>()?;
 
-            tree::compose(transaction, filtered)?
+                tree::compose(transaction, filtered)?
+            }
         }
         Op::Workspace(ws_path) => {
             let normal_parents = commit

src/filter/opt.rs

@@ -445,6 +445,8 @@ pub fn invert(filter: Filter) -> JoshResult<Filter> {
         _ => return Err(josh_error("no invert")),
     });
 
+    let result = optimize(result);
+
     INVERTED.lock().unwrap().insert(original, result);
     Ok(result)
 }

src/filter/tree.rs

@@ -796,6 +796,20 @@ fn populate(
     Ok(result_tree)
 }
 
+pub fn compose_fast<'a>(
+    transaction: &'a cache::Transaction,
+    trees: Vec<git2::Oid>,
+) -> super::JoshResult<git2::Tree<'a>> {
+    rs_tracing::trace_scoped!("compose_fast");
+    let repo = transaction.repo();
+    let mut result = tree::empty_id();
+    for tree in trees {
+        result = overlay(repo, tree, result)?;
+    }
+
+    Ok(repo.find_tree(result)?)
+}
+
 pub fn compose<'a>(
     transaction: &'a cache::Transaction,
     trees: Vec<(&super::filter::Filter, git2::Tree<'a>)>,