no_std_time 0.15.4

Time measurments that work in no_std environments
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

//! Fast implementations for specific CPU architectures.

#[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
use core::arch::asm;

#[cfg(not(any(
    target_arch = "x86_64",
    target_arch = "x86",
    target_arch = "aarch64",
    target_arch = "arm",
    target_arch = "riscv64",
    target_arch = "riscv32"
)))]
use crate::current_nanos;

// TODO: Add more architectures, using C code, see
// https://github.com/google/benchmark/blob/master/src/cycleclock.h
// Or using llvm intrinsics (if they ever should become available in stable rust?)

/// Read a timestamp for measurements.
///
/// This function is a wrapper around different ways to get a timestamp, fast.
/// In this way, an experiment only has to
/// change this implementation rather than every instead of `read_time_counter`.
/// It is using `rdtsc` on `x86_64` and `x86`.
#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
#[must_use]
pub fn read_time_counter() -> u64 {
    #[cfg(target_arch = "x86_64")]
    unsafe {
        core::arch::x86_64::_rdtsc()
    }
    #[cfg(target_arch = "x86")]
    unsafe {
        core::arch::x86::_rdtsc()
    }
}

/// Read a timestamp for measurements
///
/// Fetches the counter-virtual count register
/// as we do not need to remove the `cntvct_el2` offset.
#[cfg(target_arch = "aarch64")]
#[must_use]
pub fn read_time_counter() -> u64 {
    let mut v: u64;
    unsafe {
        // TODO pushing a change in core::arch::aarch64 ?
        asm!("mrs {v}, cntvct_el0", v = out(reg) v);
    }
    v
}

/// Read a timestamp for measurements
#[cfg(target_arch = "arm")]
#[must_use]
pub fn read_time_counter() -> u64 {
    let mut v: u32;
    unsafe {
        asm!("mrc p15, 0, {v}, c9, c13, 0", v = out(reg) v);
    }
    u64::from(v)
}

/// Read a timestamp for measurements
///
/// Fetches the full 64 bits of the cycle counter in one instruction.
#[cfg(target_arch = "riscv64")]
#[must_use]
pub fn read_time_counter() -> u64 {
    let mut v: u64;
    unsafe {
        asm!("rdcycle {v}", v = out(reg) v);
    }
    v
}

/// Read a timestamp for measurements
///
/// Fetches the high 32 bits of the cycle counter, its low end
/// If the high part has changed, we branch again.
/// FIXME: see if the latter is overkill.
#[cfg(target_arch = "riscv32")]
#[must_use]
pub fn read_time_counter() -> u64 {
    let mut v: u64;
    let mut hg: u32;
    let mut lw: u32;
    let mut cmp: u32;
    unsafe {
        asm!("jmp%=:",
             "rdcycleh {hg}",
             "rdcycle {lw}",
             "rdcycleh {cmp}",
             "bne {hg}, {cmp}, jmp%=",
             hg = out(reg) hg,
             lw = out(reg) lw,
             cmp = out(reg) cmp);
        v = ((hg as u64) << 32) | lw as u64;
    }
    v
}

/// Read a timestamp for measurements.
///
/// This function is a wrapper around different ways to get a timestamp, fast.
/// In this way, an experiment only has to
/// change this implementation rather than every instead of [`read_time_counter`]
/// On unsupported architectures, it's falling back to normal system time, in millis.
#[cfg(not(any(
    target_arch = "x86_64",
    target_arch = "x86",
    target_arch = "aarch64",
    target_arch = "arm",
    target_arch = "riscv64",
    target_arch = "riscv32"
)))]
#[must_use]
pub fn read_time_counter() -> u64 {
    current_nanos()
}