rob.hh revision 1061 
1// Todo: Probably add in support for scheduling events (more than one as
2// well) on the case of the ROB being empty or full.  Considering tracking
3// free entries instead of insts in ROB.  Differentiate between squashing
4// all instructions after the instruction, and all instructions after *and*
5// including that instruction.
6
7#ifndef __ROB_HH__
8#define __ROB_HH__
9
10#include<utility>
11#include<vector>
12
13#include "arch/alpha/isa_traits.hh"
14
15using namespace std;
16
17/**
18 * ROB class.  Uses the instruction list that exists within the CPU to
19 * represent the ROB.  This class doesn't contain that list, but instead
20 * a pointer to the CPU to get access to the list.  The ROB, in this first
21 * implementation, is largely what drives squashing.
22 */
23template <class Impl>
24class ROB
25{
26  public:
27    //Typedefs from the Impl.
28    typedef typename Impl::FullCPU FullCPU;
29    typedef typename Impl::DynInstPtr DynInstPtr;
30
31    typedef pair<RegIndex, PhysRegIndex> UnmapInfo_t;
32    typedef typename list<DynInstPtr>::iterator InstIt_t;
33
34  public:
35    /** ROB constructor.
36     *  @params _numEntries Number of entries in ROB.
37     *  @params _squashWidth Number of instructions that can be squashed in a
38     *                       single cycle.
39     */
40    ROB(unsigned _numEntries, unsigned _squashWidth);
41
42    /** Function to set the CPU pointer, necessary due to which object the ROB
43     *  is created within.
44     *  @params cpu_ptr Pointer to the implementation specific full CPU object.
45     */
46    void setCPU(FullCPU *cpu_ptr);
47
48    /** Function to insert an instruction into the ROB.  The parameter inst is
49     *  not truly required, but is useful for checking correctness.  Note
50     *  that whatever calls this function must ensure that there is enough
51     *  space within the ROB for the new instruction.
52     *  @params inst The instruction being inserted into the ROB.
53     *  @todo Remove the parameter once correctness is ensured.
54     */
55    void insertInst(DynInstPtr &inst);
56
57    /** Returns pointer to the head instruction within the ROB.  There is
58     *  no guarantee as to the return value if the ROB is empty.
59     *  @retval Pointer to the DynInst that is at the head of the ROB.
60     */
61    DynInstPtr readHeadInst() { return cpu->instList.front(); }
62
63    DynInstPtr readTailInst() { return (*tail); }
64
65    void retireHead();
66
67    bool isHeadReady();
68
69    unsigned numFreeEntries();
70
71    bool isFull()
72    { return numInstsInROB == numEntries; }
73
74    bool isEmpty()
75    { return numInstsInROB == 0; }
76
77    void doSquash();
78
79    void squash(InstSeqNum squash_num);
80
81    uint64_t readHeadPC();
82
83    uint64_t readHeadNextPC();
84
85    InstSeqNum readHeadSeqNum();
86
87    uint64_t readTailPC();
88
89    InstSeqNum readTailSeqNum();
90
91    /** Checks if the ROB is still in the process of squashing instructions.
92     *  @retval Whether or not the ROB is done squashing.
93     */
94    bool isDoneSquashing() const { return doneSquashing; }
95
96    /** This is more of a debugging function than anything.  Use
97     *  numInstsInROB to get the instructions in the ROB unless you are
98     *  double checking that variable.
99     */
100    int countInsts();
101
102  private:
103
104    /** Pointer to the CPU. */
105    FullCPU *cpu;
106
107    /** Number of instructions in the ROB. */
108    unsigned numEntries;
109
110    /** Number of instructions that can be squashed in a single cycle. */
111    unsigned squashWidth;
112
113    /** Iterator pointing to the instruction which is the last instruction
114     *  in the ROB.  This may at times be invalid (ie when the ROB is empty),
115     *  however it should never be incorrect.
116     */
117    InstIt_t tail;
118
119    /** Iterator used for walking through the list of instructions when
120     *  squashing.  Used so that there is persistent state between cycles;
121     *  when squashing, the instructions are marked as squashed but not
122     *  immediately removed, meaning the tail iterator remains the same before
123     *  and after a squash.
124     *  This will always be set to cpu->instList.end() if it is invalid.
125     */
126    InstIt_t squashIt;
127
128    /** Number of instructions in the ROB. */
129    int numInstsInROB;
130
131    /** The sequence number of the squashed instruction. */
132    InstSeqNum squashedSeqNum;
133
134    /** Is the ROB done squashing. */
135    bool doneSquashing;
136};
137
138#endif //__ROB_HH__
139