qubit-clock 0.10.1

Injectable wall and monotonic clocks with deterministic timers
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

// =============================================================================
//    Copyright (c) 2025 - 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================
//! Shares Tokio runtime liveness across independent timers.

use crate::timer::internal::tokio_runtime_liveness::TokioRuntimeLiveness;
use std::{
    collections::HashMap,
    sync::{
        Arc,
        LazyLock,
        Mutex,
        Weak,
    },
};
use tokio::runtime::{
    Handle,
    Id,
};

/// Process-wide runtime-liveness registry.
static REGISTRY: LazyLock<TokioRuntimeLivenessRegistry> =
    LazyLock::new(TokioRuntimeLivenessRegistry::default);

/// Weakly indexes one liveness sentinel per running Tokio runtime.
#[derive(Debug, Default)]
pub(crate) struct TokioRuntimeLivenessRegistry {
    /// Runtime identifiers mapped to non-owning liveness references.
    entries: Mutex<HashMap<Id, Weak<TokioRuntimeLiveness>>>,
}

impl TokioRuntimeLivenessRegistry {
    /// Returns shared liveness for the currently entered Tokio runtime.
    ///
    /// # Returns
    ///
    /// Existing live state for the current runtime, or newly spawned state.
    ///
    /// # Panics
    ///
    /// Panics when no Tokio runtime is entered.
    #[must_use]
    pub(crate) fn current() -> Arc<TokioRuntimeLiveness> {
        REGISTRY.get_or_create(Handle::current().id())
    }

    /// Returns live state for one runtime identifier.
    ///
    /// Closed state is never reused because Tokio may recycle identifiers after
    /// a runtime completes.
    ///
    /// # Parameters
    ///
    /// * `runtime_id` - Identifier of the currently entered runtime.
    ///
    /// # Returns
    ///
    /// Shared live state for `runtime_id`.
    fn get_or_create(&self, runtime_id: Id) -> Arc<TokioRuntimeLiveness> {
        let (liveness, release_notification) = {
            let mut entries = self.entries.lock().expect(
                "Tokio runtime-liveness registry lock should not be poisoned",
            );
            entries.retain(|_, liveness| liveness.strong_count() != 0);
            if let Some(liveness) =
                entries.get(&runtime_id).and_then(Weak::upgrade)
                && !liveness.is_shutdown()
            {
                return liveness;
            }
            let (liveness, release_notification) = TokioRuntimeLiveness::new();
            let liveness = Arc::new(liveness);
            entries.insert(runtime_id, Arc::downgrade(&liveness));
            (liveness, release_notification)
        };
        liveness.start(release_notification);
        liveness
    }
}