mijit 0.2.4

Experimental JIT compiler generator
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
141
142
143
144
145
146
147

use super::{Op, Resources};

/// The CPU resources available per cycle. The different resources are as
/// follows (modelled on Skylake):
///  - The number of instructions decoded.
///  - The number of flag-using macro instructions (this is a hack).
///  - The number of address generation units.
///  - The number of load units.
///  - The number of store units.
///  - The number of arithmetic / logic units.
///  - The number of multiplication units.
/// These correspond to the hexadecimal digits of the [`Resources`] from least
/// to most significant.
pub const BUDGET: Resources = Resources::new(0x1412316);

/// The resources needed to spill a value.
pub const SPILL_COST: Resources = Resources::new(0x0010202);

/// The additional resources needed per operand that is a [`Slot`].
///
/// [`Slot`]: super::code::Slot
pub const SLOT_COST: Resources = Resources::new(0x0001100);

//-----------------------------------------------------------------------------

/// Represents the cost of executing an [`Op`] (for example).
#[derive(Debug)]
pub struct Cost {
    /// The number of cycles after executing the `Op` that its result appears.
    /// If there's no result, use `0xFF`.
    pub latency: u8,
    /// The execution resources are occupied by the `Op`.
    pub resources: Resources,
}

/// The cost of a no-op.
pub const INPUT_COST: Cost = Cost {
    latency: 0,
    resources: Resources::new(0x0000000),
};

/// The cost of a compare and branch.
pub const GUARD_COST: Cost = Cost {
    latency: 0xFF,
    resources: Resources::new(0x0100012),
};

/// The cost of a typical `Constant`.
pub const CONST_COST: Cost = Cost {
    latency: 0,
    resources: Resources::new(0x0100001),
};

/// The cost of a typical unary ALU operation such as `Not`, `Neg`.
pub const UNARY_COST: Cost = Cost {
    latency: 1,
    resources: Resources::new(0x0100001),
};

/// The cost of a typical binary ALU operation such as `Add`, `And`.
pub const BINARY_COST: Cost = Cost {
    latency: 1,
    resources: Resources::new(0x0100001),
};

/// The cost of a unary conditional operation such as `Abs`.
pub const ABS_COST: Cost = Cost {
    latency: 2,
    resources: Resources::new(0x0200013),
};

/// The cost of a binary conditional operation such as `Abs`, `Max`.
pub const CONDITIONAL_COST: Cost = Cost {
    latency: 2,
    resources: Resources::new(0x0200013),
};

/// The cost of a `Mul` operation.
pub const MUL_COST: Cost = Cost {
    latency: 3,
    resources: Resources::new(0x1100001),
};

/// The cost of a `UDiv` or `SDiv` operation.
pub const DIV_COST: Cost = Cost {
    latency: 30,
    resources: Resources::new(0x1012306),
};

/// The cost of a typical shift operation such as `Lsl`.
pub const SHIFT_COST: Cost = Cost {
    latency: 1,
    resources: Resources::new(0x0100002),
};

/// The cost of a `Load` operation.
pub const LOAD_COST: Cost = Cost {
    latency: 3,
    resources: Resources::new(0x0001101),
};

/// The cost of a `Load` operation.
pub const STORE_COST: Cost = Cost {
    latency: 0,
    resources: Resources::new(0x0010101),
};

/// The cost of a `Send` operation.
pub const SEND_COST: Cost = Cost {
    latency: 0,
    resources: Resources::new(0x0000000),
};

/// A cost used for Debug operations. This won't affect other instructions.
pub const DEBUG_COST: Cost = Cost {
    latency: 0xFF,
    resources: Resources::new(0x0000000),
};

//-----------------------------------------------------------------------------

/// Returns the [`Cost`] of `op`.
#[allow(clippy::module_name_repetitions)]
pub fn op_cost(op: Op) -> &'static Cost {
    use Op::*;
    use super::code::{UnaryOp::*, BinaryOp::*};
    match op {
        Guard => &GUARD_COST,
        Input => &INPUT_COST,
        Constant(_) => &CONST_COST, // TODO: Make the cost depend on `n`.
        Unary(_, op) => match op {
            Abs => &ABS_COST,
            Negate | Not => &UNARY_COST,
        },
        Binary(_, op) => match op {
            Add | Sub | And| Or| Xor => &BINARY_COST,
            Mul => &MUL_COST,
            UDiv | SDiv => &DIV_COST,
            Lsl | Lsr | Asr => &SHIFT_COST,
            Lt | Ult | Eq | Max | Min => &CONDITIONAL_COST,
        },
        Load(_, _) => &LOAD_COST,
        Store(_, _) => &STORE_COST,
        Send => &SEND_COST,
        Debug => &DEBUG_COST,
    }
}