cachet 0.6.2 

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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Benchmarks for `DynamicCache` with allocation tracking.
//!
//! `DynamicCache` uses boxing for type erasure, so we track both time and allocations.

#![allow(missing_docs, reason = "Benchmark code")]

use std::hint::black_box;
use std::time::Instant;

use alloc_tracker::{Allocator, Session};
use cachet::{Cache, CacheEntry};
use cachet_tier::{DynamicCache, MockCache};
use criterion::{Criterion, criterion_group, criterion_main};
use tick::Clock;
use tokio::runtime::Runtime;

#[global_allocator]
static ALLOCATOR: Allocator<std::alloc::System> = Allocator::system();

fn rt() -> Runtime {
    Runtime::new().expect("failed to create runtime")
}

fn bench_dynamic_cache(c: &mut Criterion) {
    let rt = rt();
    let mut group = c.benchmark_group("dynamic_cache");
    let session = Session::new();

    // Baseline: MockCache wrapped normally (no dynamic dispatch)
    let static_get_name = "static_get";
    group.bench_function(static_get_name, |b| {
        let cache = rt.block_on(async {
            let clock = Clock::new_tokio();
            Cache::builder(clock).storage(MockCache::<String, String>::new()).build()
        });
        let key = "key".to_string();

        b.iter_custom(|iters| {
            let op = session.operation(static_get_name);
            rt.block_on(async {
                let _span = op.measure_thread();
                let start = Instant::now();
                for _ in 0..iters {
                    let _ = black_box(cache.get(black_box(&key)).await);
                }
                start.elapsed()
            })
        });
    });

    // DynamicCache (with boxing overhead)
    let dynamic_get_name = "dynamic_get";
    group.bench_function(dynamic_get_name, |b| {
        let cache = rt.block_on(async {
            let clock = Clock::new_tokio();
            let mock = MockCache::<String, String>::new();
            let dynamic: DynamicCache<String, String> = DynamicCache::new(mock);
            Cache::builder(clock).storage(dynamic).build()
        });
        let key = "key".to_string();

        b.iter_custom(|iters| {
            let op = session.operation(dynamic_get_name);
            rt.block_on(async {
                let _span = op.measure_thread();
                let start = Instant::now();
                for _ in 0..iters {
                    let _ = black_box(cache.get(black_box(&key)).await);
                }
                start.elapsed()
            })
        });
    });

    // Static insert
    let static_insert_name = "static_insert";
    group.bench_function(static_insert_name, |b| {
        let cache = rt.block_on(async {
            let clock = Clock::new_tokio();
            Cache::builder(clock).storage(MockCache::<String, String>::new()).build()
        });

        b.iter_custom(|iters| {
            let op = session.operation(static_insert_name);
            rt.block_on(async {
                let _span = op.measure_thread();
                let start = Instant::now();
                for i in 0..iters {
                    let _ = cache.insert(format!("key_{i}"), CacheEntry::new(format!("value_{i}"))).await;
                }
                start.elapsed()
            })
        });
    });

    // Dynamic insert
    let dynamic_insert_name = "dynamic_insert";
    group.bench_function(dynamic_insert_name, |b| {
        let cache = rt.block_on(async {
            let clock = Clock::new_tokio();
            let mock = MockCache::<String, String>::new();
            let dynamic: DynamicCache<String, String> = DynamicCache::new(mock);
            Cache::builder(clock).storage(dynamic).build()
        });

        b.iter_custom(|iters| {
            let op = session.operation(dynamic_insert_name);
            rt.block_on(async {
                let _span = op.measure_thread();
                let start = Instant::now();
                for i in 0..iters {
                    let _ = cache.insert(format!("key_{i}"), CacheEntry::new(format!("value_{i}"))).await;
                }
                start.elapsed()
            })
        });
    });

    group.finish();
    // Use eprintln (not println) so output goes to stderr. Writing to stdout
    // breaks nextest's benchmark list parser, which expects every non-empty
    // stdout line to end with ': test' or ': benchmark'.
    eprintln!("\n{session}");
}

criterion_group!(benches, bench_dynamic_cache);
criterion_main!(benches);