summaryrefslogtreecommitdiff
path: root/cpu/beta_cpu/rename_map.hh
blob: 05b52bfb2abb0dbf75a7fddf2a1927fdcc31b113 (plain)
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
// Todo:  Create destructor.
// Make it so that there's a proper separation between int and fp.  Also
// have it so that there's a more meaningful name given to the variable
// that marks the beginning of the FP registers.

#ifndef __RENAME_MAP_HH__
#define __RENAME_MAP_HH__

#include <iostream>
#include <vector>
#include <utility>

//Will want to include faults
#include "cpu/beta_cpu/free_list.hh"

using namespace std;

class SimpleRenameMap
{
  public:
//    typedef typename Impl::RegIndex RegIndex;

    /**
     * Pair of a logical register and a physical register.  Tells the
     * previous mapping of a logical register to a physical register.
     * Used to roll back the rename map to a previous state.
     */
    typedef pair<RegIndex, PhysRegIndex> UnmapInfo;

    /**
     * Pair of a physical register and a physical register.  Used to
     * return the physical register that a logical register has been
     * renamed to, and the previous physical register that the same
     * logical register was previously mapped to.
     */
    typedef pair<PhysRegIndex, PhysRegIndex> RenameInfo;

  public:
    //Constructor
    SimpleRenameMap(unsigned _numLogicalIntRegs,
                    unsigned _numPhysicalIntRegs,
                    unsigned _numLogicalFloatRegs,
                    unsigned _numPhysicalFloatRegs,
                    unsigned _numMiscRegs,
                    RegIndex _intZeroReg,
                    RegIndex _floatZeroReg);

    void setFreeList(SimpleFreeList *fl_ptr);

    //Tell rename map to get a free physical register for a given
    //architected register.  Not sure it should have a return value,
    //but perhaps it should have some sort of fault in case there are
    //no free registers.
    RenameInfo rename(RegIndex arch_reg);

    PhysRegIndex lookup(RegIndex phys_reg);

    bool isReady(PhysRegIndex arch_reg);

    /**
     * Marks the given register as ready, meaning that its value has been
     * calculated and written to the register file.
     * @params ready_reg The index of the physical register that is now
     *                   ready.
     */
    void markAsReady(PhysRegIndex ready_reg);

    void setEntry(RegIndex arch_reg, PhysRegIndex renamed_reg);

    void squash(vector<RegIndex> freed_regs,
                vector<UnmapInfo> unmaps);

    int numFreeEntries();

  private:
    /** Number of logical integer registers. */
    int numLogicalIntRegs;

    /** Number of physical integer registers. */
    int numPhysicalIntRegs;

    /** Number of logical floating point registers. */
    int numLogicalFloatRegs;

    /** Number of physical floating point registers. */
    int numPhysicalFloatRegs;

    /** Number of miscellaneous registers. */
    int numMiscRegs;

    /** Number of logical integer + float registers. */
    int numLogicalRegs;

    /** Number of physical integer + float registers. */
    int numPhysicalRegs;

    /** The integer zero register.  This implementation assumes it is always
     *  zero and never can be anything else.
     */
    RegIndex intZeroReg;

    /** The floating point zero register.  This implementation assumes it is
     *  always zero and never can be anything else.
     */
    RegIndex floatZeroReg;

    class RenameEntry
    {
      public:
        PhysRegIndex physical_reg;
        bool valid;

        RenameEntry();
    };

    /** Integer rename map. */
    RenameEntry *intRenameMap;

    /** Floating point rename map. */
    RenameEntry *floatRenameMap;

    /** Free list interface. */
    SimpleFreeList *freeList;

    /** Scoreboard of physical integer registers, saying whether or not they
     *  are ready.
     */
    vector<bool> intScoreboard;

    /** Scoreboard of physical floating registers, saying whether or not they
     *  are ready.
     */
    vector<bool> floatScoreboard;

    /** Scoreboard of miscellaneous registers, saying whether or not they
     *  are ready.
     */
    vector<bool> miscScoreboard;
};

#endif //__RENAME_MAP_HH__