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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

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

use criterion::{BenchmarkGroup, Throughput, measurement::WallTime};
use graph_api_lib::{EdgeSearch, Graph, VertexReference};
use graph_api_test::{Edge, EdgeExt, Person, Vertex, VertexExt};

/// Run all traversal operation benchmarks
pub fn run_benchmarks<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    bench_traversal_outgoing(group, setup.clone());
    bench_traversal_incoming(group, setup.clone());
    bench_traversal_filtered(group, setup.clone());
    bench_traversal_complex(group, setup.clone());
    bench_traversal_deep(group, setup.clone());
}

/// Benchmark basic outgoing traversal
fn bench_traversal_outgoing<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    group.throughput(Throughput::Elements(1));
    group.bench_function("traversal_outgoing", |b| {
        // Setup: Create graph with test data
        let mut graph = setup();
        let refs = generate_test_graph(&mut graph);

        b.iter(|| {
            graph
                .walk()
                .vertices_by_id(vec![refs.bryn])
                .edges(EdgeSearch::scan().outgoing())
                .head()
                .collect::<Vec<_>>()
        })
    });
}

/// Benchmark incoming traversal
fn bench_traversal_incoming<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    group.throughput(Throughput::Elements(1));
    group.bench_function("traversal_incoming", |b| {
        // Setup: Create graph with test data
        let mut graph = setup();
        let refs = generate_test_graph(&mut graph);

        b.iter(|| {
            graph
                .walk()
                .vertices_by_id(vec![refs.bryn])
                .edges(EdgeSearch::scan().incoming())
                .head()
                .collect::<Vec<_>>()
        })
    });
}

/// Benchmark filtered traversal
fn bench_traversal_filtered<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    group.throughput(Throughput::Elements(1));
    group.bench_function("traversal_filtered", |b| {
        // Setup: Create graph with test data
        let mut graph = setup();
        let refs = generate_test_graph(&mut graph);

        b.iter(|| {
            graph
                .walk()
                .vertices_by_id(vec![refs.bryn])
                .filter_by_person(|_, _| true)
                .edges(EdgeSearch::scan().outgoing())
                .filter_by_knows(|_, _| true)
                .head()
                .collect::<Vec<_>>()
        })
    });
}

/// Benchmark complex traversal combining multiple operations
fn bench_traversal_complex<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    group.throughput(Throughput::Elements(1));
    group.bench_function("traversal_complex", |b| {
        // Setup: Create graph with test data
        let mut graph = setup();
        let refs = generate_test_graph(&mut graph);

        b.iter(|| {
            graph
                .walk()
                .vertices_by_id(vec![refs.bryn])
                .filter_by_person(|v, _| v.age() > 40)
                .push_context(|v, _ctx| v.project::<Person<_>>().unwrap().age())
                .edges(EdgeSearch::scan().outgoing())
                .take(5)
                .head()
                .collect::<Vec<_>>()
        })
    });
}

/// Benchmark deep traversal (multiple hops)
fn bench_traversal_deep<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    group.throughput(Throughput::Elements(1));
    group.bench_function("traversal_deep", |b| {
        // Setup: Create a bigger graph for this test
        let mut graph = setup();
        let vertex_ids = generate_social_graph(&mut graph, GraphSize::Small, 42);
        let start_id = vertex_ids[0]; // Start with the first vertex

        b.iter(|| {
            // Friends of friends (2 hops)
            graph
                .walk()
                .vertices_by_id(vec![start_id])
                .edges(EdgeSearch::scan().outgoing())
                .head()
                .edges(EdgeSearch::scan().outgoing())
                .head()
                .collect::<Vec<_>>()
        })
    });
}