hft-benchmarks 0.1.2

High-precision benchmarking tools for high-frequency trading systems with nanosecond-level timing accuracy
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! High-resolution timing utilities using CPU timestamp counter

#[cfg(target_arch = "x86_64")]
use core::arch::x86_64::{_rdtsc, _mm_lfence, _mm_mfence};

/// Read timestamp counter for the current architecture
#[cfg(target_arch = "x86_64")]
#[inline(always)]
unsafe fn read_timestamp_with_fences() -> u64 {
    _mm_mfence();
    let tsc = _rdtsc();
    _mm_lfence();
    tsc
}

#[cfg(target_arch = "aarch64")]
#[inline(always)]
unsafe fn read_timestamp_with_fences() -> u64 {
    read_timestamp()
}

#[cfg(target_arch = "aarch64")]
#[inline(always)]
pub fn read_timestamp() -> u64 {
    read_virtual_counter()
}

#[cfg(target_arch = "aarch64")]
#[inline(always)]
fn read_virtual_counter() -> u64 {
    unsafe {
        let counter: u64;
        std::arch::asm!("mrs {}, cntvct_el0", out(reg) counter, options(nomem, nostack));
        counter
    }
}

#[cfg(target_arch = "aarch64")]
fn get_counter_frequency() -> u64 {
    unsafe {
        let freq: u64;
        std::arch::asm!("mrs {}, cntfrq_el0", out(reg) freq, options(nomem, nostack));
        freq
    }
}

pub struct PrecisionTimer {
    start: u64,
    frequency_mhz: u64,
}

impl PrecisionTimer {
    #[inline(always)]
    pub fn start() -> Self {
        unsafe {
            let start = read_timestamp_with_fences();
            
            Self {
                start,
                frequency_mhz: crate::mock_core::cpu_frequency_mhz(),
            }
        }
    }
    
    #[inline(always)]
    pub fn stop(self) -> u64 {
        unsafe {
            let end = read_timestamp_with_fences();
            
            let cycles = end - self.start;
            if self.frequency_mhz == 0 {
                cycles
            } else {
                #[cfg(target_arch = "x86_64")]
                {
                    (cycles * 1000) / self.frequency_mhz
                }
                #[cfg(target_arch = "aarch64")]
                {
                    let counter_freq = get_counter_frequency();
                    if counter_freq > 0 {
                        if cycles == 0 {
                            0
                        } else {
                            std::cmp::max(1, (cycles * 1_000_000_000) / counter_freq)
                        }
                    } else {
                        (cycles * 1000) / self.frequency_mhz
                    }
                }
            }
        }
    }
}

pub fn time_function<F, R>(f: F) -> (R, u64)
where
    F: FnOnce() -> R,
{
    let timer = PrecisionTimer::start();
    let result = f();
    let elapsed = timer.stop();
    (result, elapsed)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::calibration::calibrate_tsc_frequency;
    
    #[test]
    fn test_precision_timer() {
        calibrate_tsc_frequency();
        
        let timer = PrecisionTimer::start();
        let _ = (0..10).sum::<i32>();
        let elapsed = timer.stop();
        
        #[cfg(target_arch = "x86_64")]
        {
            assert!(elapsed < 1000, "Elapsed time too high: {}ns", elapsed);
        }
        #[cfg(target_arch = "aarch64")]
        {
            assert!(elapsed < 5000, "Elapsed time too high: {}ns", elapsed);
        }
    }
    
    #[test]
    fn test_time_function() {
        calibrate_tsc_frequency();
        
        let (result, elapsed) = time_function(|| {
            (0..100).sum::<i32>()
        });
        
        assert_eq!(result, 4950);
        assert!(elapsed < 10000, "Function took too long: {}ns", elapsed);
    }
}