ie0521/pshared.py at master · dotjae/ie0521 · 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
class pshared:
    def __init__(self, bits_to_index, lhist_size):
        #Escriba aquí el init de la clase
        self.total_predictions = 0
        self.total_taken_pred_taken = 0
        self.total_taken_pred_not_taken = 0
        self.total_not_taken_pred_taken = 0
        self.total_not_taken_pred_not_taken = 0

        self.bits_to_index = bits_to_index
        self.lhist_size = lhist_size
        self.size_of_history_table = 2**bits_to_index
        self.size_of_pattern_table = 2**lhist_size
        self.history_table = [0 for i in range(self.size_of_history_table)]
        self.pattern_table = [0 for i in range(self.size_of_pattern_table)]

    def print_info(self):
        print("Parámetros del predictor:")
        print("\tTipo de predictor:\t\t\tP-Shared")

    def print_stats(self):
        print("Resultados de la simulación")
        print("\t# branches:\t\t\t\t\t\t"+str(self.total_predictions))
        print("\t# branches tomados predichos correctamente:\t\t"+str(self.total_taken_pred_taken))
        print("\t# branches tomados predichos incorrectamente:\t\t"+str(self.total_taken_pred_not_taken))
        print("\t# branches no tomados predichos correctamente:\t\t"+str(self.total_not_taken_pred_not_taken))
        print("\t# branches no tomados predichos incorrectamente:\t"+str(self.total_not_taken_pred_taken))
        perc_correct = 100*(self.total_taken_pred_taken+self.total_not_taken_pred_not_taken)/self.total_predictions
        formatted_perc = "{:.3f}".format(perc_correct)
        print("\t% predicciones correctas:\t\t\t\t"+str(formatted_perc)+"%")

    # Give prediction
    def predict(self, PC):
        index = self.history_table[(int(PC) % self.size_of_history_table)]
        pattern_table_entry = self.pattern_table[index]
        if pattern_table_entry in [0,1]:
            return "N"
        else:
            return "T"

    # Update prediction
    def update(self, PC, result, prediction):
        htable_index = int(PC) % self.size_of_history_table
        ptable_index = self.history_table[htable_index]
        pattern_table_entry = self.pattern_table[ptable_index]

        # Update local history
        if result == "T":
            self.history_table[htable_index] = self.update_lhist(self.history_table[htable_index], 1)
        else:
            self.history_table[htable_index] = self.update_lhist(self.history_table[htable_index], 0)

        #Update entry accordingly
        if pattern_table_entry == 0 and result == "N":
            updated_pattern_table_entry = pattern_table_entry
        elif pattern_table_entry != 0 and result == "N":
            updated_pattern_table_entry = pattern_table_entry - 1
        elif pattern_table_entry == 3 and result == "T":
            updated_pattern_table_entry = pattern_table_entry
        else:
            updated_pattern_table_entry = pattern_table_entry + 1

        self.pattern_table[ptable_index] = updated_pattern_table_entry

         #Update stats
        if result == "T" and result == prediction:
            self.total_taken_pred_taken += 1
        elif result == "T" and result != prediction:
            self.total_taken_pred_not_taken += 1
        elif result == "N" and result == prediction:
            self.total_not_taken_pred_not_taken += 1
        else:
            self.total_not_taken_pred_taken += 1

        self.total_predictions += 1

    # Update local history register
    def update_lhist(self, lhist, taken):
            # Shift the LHR to the left by one bit
            lhist = (lhist << 1) & ((1 << self.lhist_size) - 1)  # Mask to maintain register size
            # Set the LSB to 1 if the branch is taken, else 0
            if taken:
                lhist |= 1

            return lhist