graph-api-benches 0.2.1

Benchmarking utilities and performance tests for the graph-api ecosystem
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::generators::{GraphSize, generate_random_graph, generate_test_graph};

use criterion::{BenchmarkGroup, Throughput, measurement::WallTime};
#[cfg(feature = "element-removal")]
use graph_api_lib::SupportsElementRemoval;
use graph_api_lib::{Graph, VertexReferenceMut, VertexSearch};
use graph_api_test::{Edge, PersonMut, Vertex, VertexExt};

/// Run all mutation operation benchmarks
pub fn run_benchmarks<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    bench_mutation_vertex_update(group, setup.clone());
    bench_mutation_edge_add(group, setup.clone());

    // Only run removal benchmarks if the feature is enabled and graph supports removal
    #[cfg(feature = "element-removal")]
    run_removal_benchmarks(group, setup);
}

/// Run removal-specific benchmarks
#[cfg(feature = "element-removal")]
fn run_removal_benchmarks<G: Graph<Vertex = Vertex, Edge = Edge> + SupportsElementRemoval>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    bench_mutation_edge_remove(group, setup.clone());
}

/// Benchmark updating vertices during traversal
fn bench_mutation_vertex_update<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    group.throughput(Throughput::Elements(10));
    group.bench_function("mutation_vertex_update", |b| {
        b.iter_batched(
            || {
                // Setup: Create graph with random data
                let mut graph = setup();
                generate_random_graph(&mut graph, GraphSize::Small, 42);
                graph
            },
            |mut graph| {
                // Update age of first 10 Person vertices by incrementing it
                graph
                    .walk_mut()
                    .vertices(VertexSearch::scan())
                    .filter_person()
                    .take(10)
                    .mutate(|graph, vertex_id, _context| {
                        let mut vertex = graph.vertex_mut(vertex_id).expect("vertex");
                        let mut person = vertex.project_mut::<PersonMut<_, _>>().expect("person");
                        person.set_age(100)
                    })
            },
            criterion::BatchSize::SmallInput,
        )
    });
}

/// Benchmark adding edges during traversal
fn bench_mutation_edge_add<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    group.throughput(Throughput::Elements(1));
    group.bench_function("mutation_edge_add", |b| {
        b.iter_batched(
            || {
                // Setup: Create graph with test data
                let mut graph = setup();
                let refs = generate_test_graph(&mut graph);
                (graph, refs.julia, refs.rust)
            },
            |(mut graph, source_id, target_id)| {
                // Add an edge during traversal
                graph
                    .walk_mut()
                    .vertices_by_id(vec![source_id])
                    .mutate(|graph, _, _| {
                        graph.add_edge(source_id, target_id, Edge::Created);
                    })
            },
            criterion::BatchSize::SmallInput,
        )
    });
}

/// Benchmark removing edges during traversal
#[cfg(feature = "element-removal")]
fn bench_mutation_edge_remove<G: Graph<Vertex = Vertex, Edge = Edge> + SupportsElementRemoval>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    group.throughput(Throughput::Elements(1));
    group.bench_function("mutation_edge_remove", |b| {
        b.iter_batched(
            || {
                // Setup: Create graph with test data
                let mut graph = setup();
                let _refs = generate_test_graph(&mut graph);
                graph
            },
            |mut graph| {
                // Find and remove the first outgoing edge from Bryn
                let count = graph
                    .walk_mut()
                    .vertices(VertexSearch::scan())
                    .edges(EdgeSearch::scan().outgoing())
                    .take(1)
                    .mutate(|graph, edge_id, _| {
                        graph.remove_edge(edge_id);
                    });
                count
            },
            criterion::BatchSize::SmallInput,
        )
    });
}