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

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

//! Benchmarks for time-to-refresh overhead.

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

use std::collections::HashMap;
use std::hint::black_box;
use std::time::{Duration, Instant};

use anyspawn::Spawner;
use cachet::{Cache, CacheEntry, TimeToRefresh};
use cachet_tier::MockCache;
use criterion::{Criterion, criterion_group, criterion_main};
use tick::Clock;
use tokio::runtime::Runtime;

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

fn mock_with_value(key: &str, value: &str) -> MockCache<String, String> {
    let mut data = HashMap::new();
    data.insert(key.to_string(), CacheEntry::new(value.to_string()));
    MockCache::with_data(data)
}

fn bench_refresh_overhead(c: &mut Criterion) {
    let rt = rt();
    let mut group = c.benchmark_group("refresh_overhead");

    // Baseline: fallback without refresh
    group.bench_function("without_refresh", |b| {
        let cache = rt.block_on(async {
            let clock = Clock::new_tokio();
            Cache::builder(clock.clone())
                .storage(mock_with_value("key", "value"))
                .fallback(Cache::builder(clock).storage(MockCache::<String, String>::new()))
                .build()
        });
        let key = "key".to_string();

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

    // With refresh enabled but not triggering (TTR > entry age)
    group.bench_function("with_refresh_not_triggering", |b| {
        let cache = rt.block_on(async {
            let clock = Clock::new_tokio();
            Cache::builder(clock.clone())
                .storage(mock_with_value("key", "value"))
                .fallback(Cache::builder(clock).storage(MockCache::<String, String>::new()))
                .time_to_refresh(TimeToRefresh::new(Duration::from_hours(1), Spawner::new_tokio()))
                .build()
        });
        let key = "key".to_string();

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

    // With refresh triggering (TTR = 0, always triggers)
    group.bench_function("with_refresh_triggering", |b| {
        let cache = rt.block_on(async {
            let clock = Clock::new_tokio();
            Cache::builder(clock.clone())
                .storage(mock_with_value("key", "value"))
                .fallback(Cache::builder(clock).storage(mock_with_value("key", "refreshed")))
                .time_to_refresh(TimeToRefresh::new(Duration::from_secs(0), Spawner::new_tokio()))
                .build()
        });
        let key = "key".to_string();

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

    group.finish();
}

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