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

//! Branch history table.

use super::*;

/// 2-bit saturation counter.
#[derive(Debug, Default, Clone, Copy)]
pub enum SatCounter {
    /// Strongly not taken.
    StronglyNotTaken,

    /// Weakly not taken.
    #[default]
    WeaklyNotTaken,

    /// Weakly taken.
    WeaklyTaken,

    /// Strongly taken.
    StronglyTaken,
}

impl SatCounter {
    /// Increments the counter.
    pub fn increment(self) -> Self {
        match self {
            SatCounter::StronglyNotTaken => SatCounter::WeaklyNotTaken,
            SatCounter::WeaklyNotTaken => SatCounter::WeaklyTaken,
            SatCounter::WeaklyTaken => SatCounter::StronglyTaken,
            SatCounter::StronglyTaken => SatCounter::StronglyTaken,
        }
    }

    /// Decrements the counter.
    pub fn decrement(self) -> Self {
        match self {
            SatCounter::StronglyNotTaken => SatCounter::StronglyNotTaken,
            SatCounter::WeaklyNotTaken => SatCounter::StronglyNotTaken,
            SatCounter::WeaklyTaken => SatCounter::WeaklyNotTaken,
            SatCounter::StronglyTaken => SatCounter::WeaklyTaken,
        }
    }

    /// Predicts the branch is taken or not.
    pub fn predict(self) -> bool {
        match self {
            SatCounter::StronglyNotTaken | SatCounter::WeaklyNotTaken => false,
            SatCounter::WeaklyTaken | SatCounter::StronglyTaken => true,
        }
    }
}

/// BHT.
#[derive(Debug, Default, Clone, Copy)]
pub struct Bht {
    /// BHT entries.
    #[allow(unused)]
    entries: Array<SatCounter, BHT_ENTRIES>,
}

impl Bht {
    /// Predicts the direction of a branch instruction with the given PC.
    ///
    /// Returns `true` if the branch is prediction as taken; otherwise, returns `false`.
    pub fn predict(self, _pc: u32) -> bool {
        todo!("assignment 2")
    }

    /// Returns the updated BHT when a branch instruction resolves at the execute stage with the given PC.
    ///
    /// It updates the entry corresponding to the given PC.
    pub fn update(self, _pc: u32, _taken: bool) -> Self {
        todo!("assignment 2")
    }
}