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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#![no_std]
#![feature(asm)]

#[no_mangle]
#[inline(never)]
#[cfg(target_arch = "x86_64")]
pub fn ticks() -> u64 {
    let mask = 0xFFFFFFFFu64;
    let high: u64;
    let low: u64;
    unsafe {
        asm!("lfence;rdtsc"
            : "={edx}"(high), "={eax}"(low)
            :
            : "rdx", "rax"
            : "volatile"
        );
    }
    ((high)<<32) | (mask&low)
}
#[test]
fn test_delta() {
    let x = ticks();
    let y = ticks();
    assert!( (y-x) < 1000000);
}

/// The difference between `ticks` and `ticks_amd` is that
/// on AMD processors `lfence` instruction doesn't
/// always prevent instruction reordering. Instead it is
/// recommended to use the `mfence` instruction.
///
/// [See this
/// citation](https://github.com/golang/go/blob/bf9ad7080d0a22acf502a60d8bc6ebbc4f5340ef/src/runtime/asm_amd64.s#L112)
#[no_mangle]
#[inline(never)]
#[cfg(target_arch = "x86_64")]
pub fn ticks_amd() -> u64 {
    let mask = 0xFFFFFFFFu64;
    let high: u64;
    let low: u64;
    unsafe {
        asm!("mfence;rdtsc"
            : "={edx}"(high), "={eax}"(low)
            :
            : "rdx", "rax"
            : "volatile"
        );
    }
    ((high)<<32) | (mask&low)
}

/// The standard `ticks` and `ticks_amd` use the `rdtsc` instruction which as it
/// maybe reordered in respect to other instructions the functions will contain
/// memory fences to attempt to insure relative order. But in some highly
/// sensative benchmarks this may introduce memory overhead, as you enforce
/// cache consistency.
///
/// Please see these docs on the [`rdtscp`](http://www.felixcloutier.com/x86/RDTSCP.html)
/// instruction.
///
/// Be aware that this instruction maybe masked by the OS, or Hypervisor.
#[no_mangle]
#[inline(never)]
#[cfg(target_arch = "x86_64")]
pub fn ticks_modern() -> u64 {
    let mask = 0xFFFFFFFFu64;
    let high: u64;
    let low: u64;
    unsafe {
        asm!("rdtscp"
            : "={edx}"(high), "={eax}"(low)
            :
            : "rdx", "rax"
            : "volatile"
        );
    }
    ((high)<<32) | (mask&low)
}

#[no_mangle]
#[inline(never)]
#[cfg(target_arch = "x86")]
pub fn ticks() -> u64 {
    let high: u32;
    let low: u32;
    unsafe {
        asm!("lfence;rdtsc"
            : "={edx}"(high), "={eax}"(low)
            :
            : "edx", "eax"
            : "volatile"
        );
    }
    let high_val = (high as u64) << 32;
    let low_val = low as u64;
    high_val|low_val
}

/// The difference between `ticks` and `ticks_amd` is that
/// on AMD processors `lfence` instruction doesn't
/// always prevent instruction reordering. Instead it is
/// recommended to use the `mfence` instruction.
///
/// [See this
/// citation](https://github.com/golang/go/blob/bf9ad7080d0a22acf502a60d8bc6ebbc4f5340ef/src/runtime/asm_amd64.s#L112)
#[no_mangle]
#[inline(never)]
#[cfg(target_arch = "x86")]
pub fn ticks_amd() -> u64 {
    let high: u32;
    let low: u32;
    unsafe {
        asm!("mfence;rdtsc"
            : "={edx}"(high), "={eax}"(low)
            :
            : "edx", "eax"
            : "volatile"
        );
    }
    let high_val = (high as u64) << 32;
    let low_val = low as u64;
    high_val|low_val
}

/// The standard `ticks` and `ticks_amd` use the `rdtsc` instruction which as it
/// maybe reordered in respect to other instructions the functions will contain
/// memory fences to attempt to insure relative order. But in some highly
/// sensative benchmarks this may introduce memory overhead, as you enforce
/// cache consistency.
///
/// Please see these docs on the [`rdtscp`](http://www.felixcloutier.com/x86/RDTSCP.html)
/// instruction.
///
/// Be aware that this instruction maybe masked by the OS, or Hypervisor.
#[no_mangle]
#[inline(never)]
#[cfg(target_arch = "x86")]
pub fn ticks_modern() -> u64 {
    let mask = 0xFFFFFFFFu64;
    let high: u32;
    let low: u32;
    unsafe {
        asm!("rdtscp"
            : "={edx}"(high), "={eax}"(low)
            :
            : "edx", "eax"
            : "volatile"
        );
    }
    let high_val = (high as u64) << 32;
    let low_val = low as u64;
    high_val|low_val
}