Parallel walks

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "orx-tree"
-version = "1.6.0"
+version = "1.7.0"
 edition = "2024"
 authors = ["orxfun <[email protected]>"]
-description = "A beautiful tree 🌳 with convenient and efficient growth, mutation and traversal features with support for parallel computation."
+description = "A beautiful tree 🌳 with convenient, efficient, parallelizable growth, mutation and features."
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/orxfun/orx-tree/"
 keywords = ["tree", "data-structures", "traversal", "traverse", "binarytree"]
@@ -16,7 +16,7 @@ orx-pinned-vec = "3.16.0"
 orx-self-or = "1.2.0"
 serde = { version = "1.0.219", optional = true, default-features = false }
 orx-split-vec = { version = "3.17.0", default-features = false }
-orx-selfref-col = { version = "2.9.0", default-features = false }
+orx-selfref-col = { version = "2.10.0", default-features = false }
 orx-concurrent-iter = { version = "2.1.0", default-features = false }
 orx-parallel = { version = "2.1.0", default-features = false, optional = true }
 
@@ -34,5 +34,5 @@ default = ["orx-parallel"]
 serde = ["dep:serde"]
 
 [[bench]]
-name = "parallelization_ref"
+name = "walk_iterator"
 harness = false

benches/children_iterator.rs

@@ -0,0 +1,110 @@
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+#[cfg(feature = "orx-parallel")]
+use orx_parallel::ParIter;
+use orx_tree::*;
+
+fn build_tree(n: usize) -> DynTree<String> {
+    let mut tree = DynTree::new(0.to_string());
+    let mut dfs = Traversal.dfs().over_nodes();
+    while tree.len() < n {
+        let root = tree.root();
+        let x: Vec<_> = root.leaves_with(&mut dfs).map(|x| x.idx()).collect();
+        for idx in x.iter() {
+            let count = tree.len();
+            let mut node = tree.node_mut(idx);
+            let num_children = 4;
+            for j in 0..num_children {
+                node.push_child((count + j).to_string());
+            }
+        }
+    }
+    tree
+}
+
+fn fibonacci(n: u64) -> u64 {
+    let mut a = 0;
+    let mut b = 1;
+    for _ in 0..n {
+        let c = a + b;
+        a = b;
+        b = c;
+    }
+    a
+}
+
+fn compute_subtree_value(subtree: &DynNode<String>) -> u64 {
+    subtree
+        .walk::<Dfs>()
+        .map(|x| x.parse::<u64>().unwrap())
+        .map(|x| fibonacci(x % 1000))
+        .sum()
+}
+
+fn children(tree: &DynTree<String>) -> u64 {
+    tree.root()
+        .children()
+        .map(|x| compute_subtree_value(&x))
+        .sum()
+}
+
+#[cfg(feature = "orx-parallel")]
+fn children_par(tree: &DynTree<String>) -> u64 {
+    tree.root()
+        .children_par()
+        .map(|x| compute_subtree_value(&x))
+        .sum()
+}
+
+#[cfg(feature = "orx-parallel")]
+fn children_par_2threads(tree: &DynTree<String>) -> u64 {
+    tree.root()
+        .children_par()
+        .num_threads(2)
+        .map(|x| compute_subtree_value(&x))
+        .sum()
+}
+
+fn bench(c: &mut Criterion) {
+    let treatments = vec![1_024 * 64];
+
+    let mut group = c.benchmark_group("children_iterator");
+
+    for n in &treatments {
+        let tree = build_tree(*n);
+
+        let expected = children(&tree);
+
+        group.bench_with_input(BenchmarkId::new("NodeRef::children()", n), n, |b, _| {
+            let result = children(&tree);
+            assert_eq!(result, expected);
+            b.iter(|| children(&tree))
+        });
+
+        #[cfg(feature = "orx-parallel")]
+        group.bench_with_input(
+            BenchmarkId::new("NNodeRef::children_par()", n),
+            n,
+            |b, _| {
+                let result = children_par(&tree);
+                assert_eq!(result, expected);
+                b.iter(|| children_par(&tree))
+            },
+        );
+
+        #[cfg(feature = "orx-parallel")]
+        group.bench_with_input(
+            BenchmarkId::new("NodeRef::children_par().num_threads(2)", n),
+            n,
+            |b, _| {
+                let result = children_par_2threads(&tree);
+                assert_eq!(result, expected);
+                b.iter(|| children_par_2threads(&tree))
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench);
+criterion_main!(benches);

benches/parallelization_owned.rs

@@ -56,6 +56,7 @@ fn tree_into_bfs(mut tree: DynTree<String>) -> i64 {
         .sum()
 }
 
+#[cfg(feature = "orx-parallel")]
 fn tree_into_par_x(tree: DynTree<String>) -> i64 {
     tree.into_par()
         .map(|x| x.parse::<usize>().unwrap())
@@ -107,6 +108,7 @@ fn bench(c: &mut Criterion) {
             },
         );
 
+        #[cfg(feature = "orx-parallel")]
         group.bench_with_input(
             BenchmarkId::new("Tree::into_par_x() - orx-parallel", n),
             n,

benches/parallelization_ref.rs

@@ -56,6 +56,7 @@ fn tree_bfs(tree: &DynTree<String>) -> i64 {
         .sum()
 }
 
+#[cfg(feature = "orx-parallel")]
 fn tree_par_x(tree: &DynTree<String>) -> i64 {
     tree.par()
         .map(|x| x.parse::<usize>().unwrap())
@@ -107,6 +108,7 @@ fn bench(c: &mut Criterion) {
             },
         );
 
+        #[cfg(feature = "orx-parallel")]
         group.bench_with_input(
             BenchmarkId::new("Tree::par_x() - orx-parallel", n),
             n,

benches/paths_iterator.rs

@@ -0,0 +1,98 @@
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use orx_iterable::{IntoCloningIterable, Iterable};
+#[cfg(feature = "orx-parallel")]
+use orx_parallel::ParIter;
+use orx_tree::*;
+
+fn build_tree(n: usize) -> DynTree<String> {
+    let mut tree = DynTree::new(0.to_string());
+    let mut dfs = Traversal.dfs().over_nodes();
+    while tree.len() < n {
+        let root = tree.root();
+        let x: Vec<_> = root.leaves_with(&mut dfs).map(|x| x.idx()).collect();
+        for idx in x.iter() {
+            let count = tree.len();
+            let mut node = tree.node_mut(idx);
+            let num_children = 4;
+            for j in 0..num_children {
+                node.push_child((count + j).to_string());
+            }
+        }
+    }
+    tree
+}
+
+fn fibonacci(n: i64) -> i64 {
+    let mut a = 0;
+    let mut b = 1;
+    for _ in 0..n {
+        let c = a + b;
+        a = b;
+        b = c;
+    }
+    a
+}
+
+fn path_value<'a>(path: impl IntoIterator<Item = &'a String>) -> i64 {
+    path.into_iter()
+        .map(|x| x.parse::<i64>().unwrap())
+        .map(|x| x % 500)
+        .map(fibonacci)
+        .max()
+        .unwrap()
+}
+
+fn paths<T: Traverser>(tree: &DynTree<String>) -> Vec<String> {
+    let root = tree.root();
+    root.paths::<T>()
+        .map(|x| x.into_iterable())
+        .max_by_key(|x| path_value(x.iter()))
+        .map(|x| x.iter().cloned().collect())
+        .unwrap()
+}
+
+#[cfg(feature = "orx-parallel")]
+fn paths_par<T: Traverser>(tree: &DynTree<String>) -> Vec<String> {
+    let root = tree.root();
+    root.paths_par::<T>()
+        .map(|x| x.into_iterable())
+        .max_by_key(|x| path_value(x.iter()))
+        .map(|x| x.iter().cloned().collect())
+        .unwrap()
+}
+
+type TRAVERSER = Dfs;
+
+fn bench(c: &mut Criterion) {
+    let treatments = vec![1_024 * 64];
+
+    let mut group = c.benchmark_group("paths_iterator");
+
+    for n in &treatments {
+        let data = build_tree(*n);
+
+        let expected = paths::<TRAVERSER>(&data);
+
+        group.bench_with_input(BenchmarkId::new("NodeRef::paths::<T>()", n), n, |b, _| {
+            let result = paths::<TRAVERSER>(&data);
+            assert_eq!(path_value(&result), path_value(&expected));
+            b.iter(|| paths::<TRAVERSER>(&data))
+        });
+
+        #[cfg(feature = "orx-parallel")]
+        group.bench_with_input(
+            BenchmarkId::new("NodeRef::paths_par::<T>()", n),
+            n,
+            |b, _| {
+                let result = paths_par::<TRAVERSER>(&data);
+                assert_eq!(path_value(&result), path_value(&expected));
+                b.iter(|| paths_par::<TRAVERSER>(&data))
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench);
+criterion_main!(benches);