|
| 1 | +#![allow(long_running_const_eval)] |
| 2 | + |
| 3 | +use criterion::{black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion}; |
| 4 | +use rand::rngs::StdRng; |
| 5 | +use rand::{Rng, SeedableRng}; |
| 6 | +use std::cmp::Reverse; |
| 7 | +use std::collections::{BinaryHeap, HashSet}; |
| 8 | +use vers_vecs::trees::bp::BpBuilder; |
| 9 | +use vers_vecs::trees::bp::BpTree; |
| 10 | +use vers_vecs::trees::{Tree, TreeBuilder}; |
| 11 | + |
| 12 | +mod common; |
| 13 | + |
| 14 | +const BLOCK_SIZE: usize = 1024; |
| 15 | + |
| 16 | +// TODO this function has nlogn runtime, which is a bit too much for the largest trees |
| 17 | +fn generate_tree<R: Rng>(rng: &mut R, nodes: u64) -> BpTree<BLOCK_SIZE> { |
| 18 | + // generate prüfer sequence |
| 19 | + let mut sequence = vec![0; (nodes - 2) as usize]; |
| 20 | + for i in 0..nodes - 2 { |
| 21 | + sequence[i as usize] = rng.gen_range(0..nodes - 1); |
| 22 | + } |
| 23 | + |
| 24 | + // decode prüfer sequence |
| 25 | + let mut degrees = vec![1; nodes as usize]; |
| 26 | + sequence.iter().for_each(|i| degrees[*i as usize] += 1); |
| 27 | + |
| 28 | + let mut prefix_sum = vec![0; nodes as usize]; |
| 29 | + let mut sum = 0; |
| 30 | + degrees.iter().enumerate().for_each(|(i, d)| { |
| 31 | + prefix_sum[i] = sum; |
| 32 | + sum += d; |
| 33 | + }); |
| 34 | + |
| 35 | + let mut children = vec![0u64; sum]; |
| 36 | + let mut assigned_children = vec![0; nodes as usize]; |
| 37 | + |
| 38 | + // keep a priority queue of nodes with degree one to reduce runtime from O(n^2) to O(n log n) |
| 39 | + let mut degree_one_set = BinaryHeap::new(); |
| 40 | + degrees |
| 41 | + .iter() |
| 42 | + .enumerate() |
| 43 | + .filter(|(_, &v)| v == 1) |
| 44 | + .for_each(|(idx, _)| degree_one_set.push(Reverse(idx as u64))); |
| 45 | + |
| 46 | + sequence.iter().for_each(|&i| { |
| 47 | + let j = degree_one_set.pop().unwrap().0; |
| 48 | + children[prefix_sum[i as usize] + assigned_children[i as usize]] = j; |
| 49 | + children[prefix_sum[j as usize] + assigned_children[j as usize]] = i; |
| 50 | + degrees[i as usize] -= 1; |
| 51 | + if degrees[i as usize] == 1 { |
| 52 | + degree_one_set.push(Reverse(i)) |
| 53 | + } |
| 54 | + |
| 55 | + degrees[j as usize] -= 1; |
| 56 | + if degrees[j as usize] == 1 { |
| 57 | + degree_one_set.push(Reverse(j)) |
| 58 | + } |
| 59 | + |
| 60 | + assigned_children[i as usize] += 1; |
| 61 | + assigned_children[j as usize] += 1; |
| 62 | + }); |
| 63 | + |
| 64 | + assert_eq!(degrees.iter().sum::<usize>(), 2); |
| 65 | + let u = degree_one_set.pop().unwrap().0; |
| 66 | + let v = degree_one_set.pop().unwrap().0; |
| 67 | + |
| 68 | + children[prefix_sum[u as usize] + assigned_children[u as usize]] = v; |
| 69 | + children[prefix_sum[v as usize] + assigned_children[v as usize]] = u; |
| 70 | + |
| 71 | + // build tree |
| 72 | + let mut bpb = BpBuilder::with_capacity(nodes); |
| 73 | + let mut stack = Vec::new(); |
| 74 | + let mut visited = HashSet::with_capacity(nodes as usize); |
| 75 | + visited.insert(0); |
| 76 | + stack.push((0, 0u64, true)); |
| 77 | + while let Some((depth, node, enter)) = stack.pop() { |
| 78 | + if enter { |
| 79 | + bpb.enter_node(); |
| 80 | + stack.push((depth, node, false)); |
| 81 | + for child in children |
| 82 | + .iter() |
| 83 | + .take(*prefix_sum.get(node as usize + 1).unwrap_or(&children.len())) |
| 84 | + .skip(prefix_sum[node as usize]) |
| 85 | + { |
| 86 | + if visited.insert(*child) { |
| 87 | + stack.push((depth + 1, *child, true)) |
| 88 | + } |
| 89 | + } |
| 90 | + } else { |
| 91 | + bpb.leave_node(); |
| 92 | + } |
| 93 | + } |
| 94 | + |
| 95 | + bpb.build().unwrap() |
| 96 | +} |
| 97 | + |
| 98 | +fn bench_navigation(b: &mut Criterion) { |
| 99 | + let mut group = b.benchmark_group("bp"); |
| 100 | + group.plot_config(common::plot_config()); |
| 101 | + |
| 102 | + for l in common::SIZES { |
| 103 | + // fix the rng seed because the measurements depend on the input structure. |
| 104 | + // to make multiple runs of the benchmark comparable, we fix the seed. |
| 105 | + // this is only a valid approach to check for performance improvements, it may not give |
| 106 | + // an accurate summary of the library's runtime |
| 107 | + let mut rng = StdRng::from_seed([0; 32]); |
| 108 | + |
| 109 | + let bp = generate_tree(&mut rng, l as u64); |
| 110 | + let node_handles = (0..l).map(|i| bp.node_handle(i)).collect::<Vec<_>>(); |
| 111 | + |
| 112 | + group.bench_with_input(BenchmarkId::new("parent", l), &l, |b, _| { |
| 113 | + b.iter_batched( |
| 114 | + || node_handles[rng.gen_range(0..node_handles.len())], |
| 115 | + |h| black_box(bp.parent(h)), |
| 116 | + BatchSize::SmallInput, |
| 117 | + ) |
| 118 | + }); |
| 119 | + |
| 120 | + group.bench_with_input(BenchmarkId::new("last_child", l), &l, |b, _| { |
| 121 | + b.iter_batched( |
| 122 | + || node_handles[rng.gen_range(0..node_handles.len())], |
| 123 | + |h| black_box(bp.last_child(h)), |
| 124 | + BatchSize::SmallInput, |
| 125 | + ) |
| 126 | + }); |
| 127 | + |
| 128 | + group.bench_with_input(BenchmarkId::new("next_sibling", l), &l, |b, _| { |
| 129 | + b.iter_batched( |
| 130 | + || node_handles[rng.gen_range(0..node_handles.len())], |
| 131 | + |h| black_box(bp.next_sibling(h)), |
| 132 | + BatchSize::SmallInput, |
| 133 | + ) |
| 134 | + }); |
| 135 | + |
| 136 | + group.bench_with_input(BenchmarkId::new("prev_sibling", l), &l, |b, _| { |
| 137 | + b.iter_batched( |
| 138 | + || node_handles[rng.gen_range(0..node_handles.len())], |
| 139 | + |h| black_box(bp.previous_sibling(h)), |
| 140 | + BatchSize::SmallInput, |
| 141 | + ) |
| 142 | + }); |
| 143 | + } |
| 144 | +} |
| 145 | + |
| 146 | +criterion_group!(benches, bench_navigation); |
| 147 | +criterion_main!(benches); |
0 commit comments