rust/library/compiler-builtins/builtins-test/benches/float_extend.rs at fbc700f92bdb008a9fd76e2a02230cea6c23d2c4 · tgross35/rust · GitHub

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
#![allow(unused_variables)] // "unused" f16 registers
#![cfg_attr(f128_enabled, feature(f128))]
#![cfg_attr(f16_enabled, feature(f16))]

use builtins_test::float_bench;
use compiler_builtins::float::extend;
use criterion::{Criterion, criterion_main};

#[cfg(f16_enabled)]
float_bench! {
    name: extend_f16_f32,
    sig: (a: f16) -> f32,
    crate_fn: extend::__extendhfsf2,
    sys_fn: __extendhfsf2,
    sys_available: not(feature = "no-sys-f16"),
    asm: [
        #[cfg(target_arch = "aarch64")] {
            let ret: f32;
            asm!(
                "fcvt    {ret:s}, {a:h}",
                a = in(vreg) a,
                ret = lateout(vreg) ret,
                options(nomem, nostack, pure),
            );

            ret
        };
    ],
}

#[cfg(f16_enabled)]
float_bench! {
    name: extend_f16_f64,
    sig: (a: f16) -> f64,
    crate_fn: extend::__extendhfdf2,
    sys_fn: __extendhfdf2,
    sys_available: not(feature = "no-sys-f16-f64-convert"),
    asm: [
        #[cfg(target_arch = "aarch64")] {
            let ret: f64;
            asm!(
                "fcvt    {ret:d}, {a:h}",
                a = in(vreg) a,
                ret = lateout(vreg) ret,
                options(nomem, nostack, pure),
            );

            ret
        };
    ],
}

#[cfg(all(f16_enabled, f128_enabled))]
float_bench! {
    name: extend_f16_f128,
    sig: (a: f16) -> f128,
    crate_fn: extend::__extendhftf2,
    crate_fn_ppc: extend::__extendhfkf2,
    sys_fn: __extendhftf2,
    sys_fn_ppc: __extendhfkf2,
    sys_available: not(feature = "no-sys-f16-f128-convert"),
    asm: [],
}

float_bench! {
    name: extend_f32_f64,
    sig: (a: f32) -> f64,
    crate_fn: extend::__extendsfdf2,
    sys_fn: __extendsfdf2,
    sys_available: all(),
    asm: [
        #[cfg(target_arch = "aarch64")] {
            let ret: f64;
            asm!(
                "fcvt    {ret:d}, {a:s}",
                a = in(vreg) a,
                ret = lateout(vreg) ret,
                options(nomem, nostack, pure),
            );

            ret
        };
    ],
}

#[cfg(f128_enabled)]
float_bench! {
    name: extend_f32_f128,
    sig: (a: f32) -> f128,
    crate_fn: extend::__extendsftf2,
    crate_fn_ppc: extend::__extendsfkf2,
    sys_fn: __extendsftf2,
    sys_fn_ppc: __extendsfkf2,
    sys_available: not(feature = "no-sys-f128"),
    asm: [],
}

#[cfg(f128_enabled)]
float_bench! {
    name: extend_f64_f128,
    sig: (a: f64) -> f128,
    crate_fn: extend::__extenddftf2,
    crate_fn_ppc: extend::__extenddfkf2,
    sys_fn: __extenddftf2,
    sys_fn_ppc: __extenddfkf2,
    sys_available: not(feature = "no-sys-f128"),
    asm: [],
}

pub fn float_extend() {
    let mut criterion = Criterion::default().configure_from_args();

    #[cfg(f16_enabled)]
    {
        extend_f16_f32(&mut criterion);
        extend_f16_f64(&mut criterion);

        #[cfg(f128_enabled)]
        extend_f16_f128(&mut criterion);
    }

    extend_f32_f64(&mut criterion);

    #[cfg(f128_enabled)]
    {
        extend_f32_f128(&mut criterion);
        extend_f64_f128(&mut criterion);
    }
}

criterion_main!(float_extend);