zccache 1.12.8

Local-first compiler cache for C/C++/Rust/Emscripten
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

//! Integration tests for the `pending_cache_writes` registry on
//! `SharedState` (issue #610, DD-025 condition 1).
//!
//! The registry module itself has unit tests in
//! `daemon/server/pending_writes.rs` covering the helper API in
//! isolation. These tests verify the field is properly wired through
//! `SharedState`/`DaemonServer::bind` and that the registry behaves
//! correctly when driven through the `Arc<SharedState>` pathway the
//! cold-miss handler will use in the follow-up PR.

use std::sync::Arc;
use std::time::{Duration, Instant};

use super::super::pending_writes;
use super::super::*;

/// At daemon startup the pending registry must be empty — DD-025
/// condition 3 requires the scope be per-process. A non-empty registry
/// at bind time would mean some other state path is leaking into it.
#[tokio::test]
async fn pending_cache_writes_is_empty_on_fresh_daemon() {
    let endpoint = crate::ipc::unique_test_endpoint();
    let server = DaemonServer::bind(&endpoint).unwrap();
    assert!(
        server.state.pending_cache_writes.is_empty(),
        "fresh daemon must have empty pending_cache_writes registry, found {}",
        server.state.pending_cache_writes.len()
    );
}

/// End-to-end register + complete through the `SharedState` pathway.
/// `register` adds an entry; a concurrent lookup observes the pending
/// entry and waits; `complete` wakes it and clears the registry.
#[tokio::test]
async fn pending_registry_register_and_complete_through_shared_state() {
    let endpoint = crate::ipc::unique_test_endpoint();
    let server = DaemonServer::bind(&endpoint).unwrap();
    let state = Arc::clone(&server.state);

    let key = "deadbeefcafebabe0000000000000000";
    let _registered = pending_writes::register(&state.pending_cache_writes, key);
    assert_eq!(state.pending_cache_writes.len(), 1);

    let state_for_lookup = Arc::clone(&state);
    let waiter = tokio::spawn(async move {
        pending_writes::await_pending(
            &state_for_lookup.pending_cache_writes,
            key,
            Duration::from_millis(5),
        )
        .await
    });

    // Give the waiter a moment to enter `notified()`.
    tokio::time::sleep(Duration::from_millis(1)).await;
    pending_writes::complete(&state.pending_cache_writes, key);

    let observed = waiter.await.unwrap();
    assert!(observed, "waiter must report it saw a pending entry");
    assert!(
        state.pending_cache_writes.is_empty(),
        "complete must clear the registry entry"
    );
}

/// **DD-025 condition 4 — notify-timeout fall-through, through `SharedState`.**
///
/// The unit-level fall-through test lives in `pending_writes::tests`;
/// this case verifies the same property through the actual `SharedState`
/// pathway the cold-miss handler will use. A lookup that observes a
/// pending entry but whose `complete` never arrives must:
/// 1. Wake up within the blast-radius bound (≤ 100 ms).
/// 2. Report `true` so the caller knows to re-attempt the lookup.
/// 3. Not leak the registry entry — a later `complete` must still
///    succeed.
#[tokio::test]
async fn pending_registry_notify_timeout_through_shared_state() {
    let endpoint = crate::ipc::unique_test_endpoint();
    let server = DaemonServer::bind(&endpoint).unwrap();
    let state = Arc::clone(&server.state);

    let key = "feedfacedeadbeef0000000000000000";
    let _registered = pending_writes::register(&state.pending_cache_writes, key);

    let start = Instant::now();
    let observed =
        pending_writes::await_pending(&state.pending_cache_writes, key, Duration::from_millis(5))
            .await;
    let elapsed = start.elapsed();

    assert!(observed, "pending entry was present — must report true");
    // Must wake up within the blast-radius bound, not hang forever.
    assert!(
        elapsed < Duration::from_millis(100),
        "notify-timeout blew the blast-radius bound: {elapsed:?}"
    );

    // Registry still holds the entry — a late `complete` can clean it up.
    assert_eq!(state.pending_cache_writes.len(), 1);
    pending_writes::complete(&state.pending_cache_writes, key);
    assert!(state.pending_cache_writes.is_empty());
}

/// A lookup for a key with no pending entry must fall through
/// immediately — the registry is near-zero overhead at rest.
#[tokio::test]
async fn pending_registry_warm_lookup_pays_no_wait() {
    let endpoint = crate::ipc::unique_test_endpoint();
    let server = DaemonServer::bind(&endpoint).unwrap();
    let state = Arc::clone(&server.state);

    let start = Instant::now();
    let observed = pending_writes::await_pending(
        &state.pending_cache_writes,
        "warmkey0000000000000000000000000",
        Duration::from_millis(5),
    )
    .await;
    let elapsed = start.elapsed();

    assert!(!observed, "no pending entry must report false");
    assert!(
        elapsed < Duration::from_millis(2),
        "warm-lookup no-wait path took {elapsed:?}"
    );
}