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

use crate::generators::{
    GraphSize, generate_project_graph, generate_random_graph, generate_social_graph,
};

use criterion::{BenchmarkGroup, Throughput, measurement::WallTime};
use graph_api_lib::Graph;
use graph_api_test::{Edge, Vertex};

/// Run all construction benchmarks
pub fn run_benchmarks<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    bench_construction_small(group, setup.clone());
    bench_construction_medium(group, setup.clone());
    bench_construction_social(group, setup.clone());
    bench_construction_project(group, setup.clone());
    bench_construction_batch(group, setup.clone());
}

/// Benchmark creating a small graph
fn bench_construction_small<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    let size = GraphSize::Small;
    let vertex_count = size.vertex_count();
    let edge_count = vertex_count * size.edge_multiplier();

    group.throughput(Throughput::Elements((vertex_count + edge_count) as u64));
    group.bench_function("construction_small", |b| {
        b.iter_batched(
            &setup,
            |mut graph| {
                generate_random_graph(&mut graph, size, 42);
            },
            criterion::BatchSize::SmallInput,
        )
    });
}

/// Benchmark creating a medium graph
fn bench_construction_medium<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    let size = GraphSize::Medium;
    let vertex_count = size.vertex_count();
    let edge_count = vertex_count * size.edge_multiplier();

    group.throughput(Throughput::Elements((vertex_count + edge_count) as u64));
    group.bench_function("construction_medium", |b| {
        b.iter_batched(
            &setup,
            |mut graph| {
                generate_random_graph(&mut graph, size, 42);
            },
            criterion::BatchSize::LargeInput,
        )
    });
}

/// Benchmark creating a social network graph
fn bench_construction_social<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    let size = GraphSize::Small;
    let vertex_count = size.vertex_count();
    let edge_count = vertex_count * size.edge_multiplier();

    group.throughput(Throughput::Elements((vertex_count + edge_count) as u64));
    group.bench_function("construction_social", |b| {
        b.iter_batched(
            &setup,
            |mut graph| {
                generate_social_graph(&mut graph, size, 42);
            },
            criterion::BatchSize::SmallInput,
        )
    });
}

/// Benchmark creating a project dependency graph
fn bench_construction_project<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    let size = GraphSize::Small;
    let vertex_count = size.vertex_count();
    let edge_count = vertex_count * size.edge_multiplier();

    group.throughput(Throughput::Elements((vertex_count + edge_count) as u64));
    group.bench_function("construction_project", |b| {
        b.iter_batched(
            &setup,
            |mut graph| {
                generate_project_graph(&mut graph, size, 42);
            },
            criterion::BatchSize::SmallInput,
        )
    });
}

/// Benchmark batch vertex and edge insertion
fn bench_construction_batch<G: Graph<Vertex = Vertex, Edge = Edge>>(
    group: &mut BenchmarkGroup<WallTime>,
    setup: impl Fn() -> G + Clone,
) {
    const BATCH_SIZE: usize = 100;

    group.throughput(Throughput::Elements(BATCH_SIZE as u64));
    group.bench_function("construction_batch_vertex", |b| {
        b.iter_batched(
            &setup,
            |mut graph| {
                // Create a batch of vertices
                for i in 0..BATCH_SIZE {
                    graph.add_vertex(Vertex::Person {
                        name: format!("BatchPerson-{}", i),
                        age: 30 + (i % 50) as u64,
                        unique_id: uuid::Uuid::new_v4(),
                        username: format!("batch_user_{}", i),
                        biography: format!("Batch created person {}", i),
                    });
                }
            },
            criterion::BatchSize::SmallInput,
        )
    });
}