rustdv-sim 0.1.0

The cocotb-analog core: simulator-driven async executor, tasks, triggers, typed handles, clock, sim-aware queues (design-doc §4).
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

//! Simulation time (design-doc §3.1: time as u64 steps + precision).

use rustdv_gpi as gpi;

/// A span of simulation time in simulator precision steps. Unit-safe
/// constructors (mapping row 13): `SimDuration::ns(2)`.
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct SimDuration {
    pub steps: u64,
}

impl SimDuration {
    pub fn steps(steps: u64) -> SimDuration {
        SimDuration { steps }
    }

    fn from_pow10(n: u64, exp: i32) -> SimDuration {
        let prec = gpi::time_precision();
        if exp >= prec {
            let factor = 10u64.pow((exp - prec) as u32);
            SimDuration { steps: n * factor }
        } else {
            let div = 10u64.pow((prec - exp) as u32);
            assert!(
                n % div == 0,
                "duration {n}e{exp} is below simulator precision 1e{prec}"
            );
            SimDuration { steps: n / div }
        }
    }

    pub fn fs(n: u64) -> SimDuration {
        Self::from_pow10(n, -15)
    }
    pub fn ps(n: u64) -> SimDuration {
        Self::from_pow10(n, -12)
    }
    pub fn ns(n: u64) -> SimDuration {
        Self::from_pow10(n, -9)
    }
    pub fn us(n: u64) -> SimDuration {
        Self::from_pow10(n, -6)
    }
    pub fn ms(n: u64) -> SimDuration {
        Self::from_pow10(n, -3)
    }
    pub fn sec(n: u64) -> SimDuration {
        Self::from_pow10(n, 0)
    }

    /// Parse a cocotb-style unit name ("ns", "us", ...).
    pub fn from_unit(n: u64, unit: &str) -> SimDuration {
        match unit {
            "fs" => Self::fs(n),
            "ps" => Self::ps(n),
            "ns" => Self::ns(n),
            "us" => Self::us(n),
            "ms" => Self::ms(n),
            "s" | "sec" => Self::sec(n),
            "step" | "steps" => Self::steps(n),
            _ => panic!("unknown time unit '{unit}'"),
        }
    }
}

/// Current simulation time in precision steps.
pub fn sim_time_steps() -> u64 {
    gpi::sim_time_steps()
}

/// Current simulation time in nanoseconds (for log formatting).
pub fn sim_time_ns() -> f64 {
    let prec = gpi::time_precision();
    let steps = gpi::sim_time_steps() as f64;
    steps * 10f64.powi(prec + 9)
}