O3: Pack the comm structures a bit better to reduce their size.

src/cpu/o3/comm.hh

@@ -121,12 +121,12 @@ template<class Impl>
 struct TimeBufStruct {
     typedef typename Impl::DynInstPtr DynInstPtr;
     struct decodeComm {
-        uint64_t branchAddr;
+        TheISA::PCState nextPC;
-        InstSeqNum doneSeqNum;
         DynInstPtr mispredictInst;
         DynInstPtr squashInst;
+        InstSeqNum doneSeqNum;
         Addr mispredPC;
-        TheISA::PCState nextPC;
+        uint64_t branchAddr;
         unsigned branchCount;
         bool squash;
         bool predIncorrect;
@@ -143,9 +143,7 @@ struct TimeBufStruct {
 
     struct iewComm {
         // Also eventually include skid buffer space.
-        bool usedIQ;
         unsigned freeIQEntries;
-        bool usedLSQ;
         unsigned freeLSQEntries;
 
         unsigned iqCount;
@@ -153,57 +151,70 @@ struct TimeBufStruct {
 
         unsigned dispatched;
         unsigned dispatchedToLSQ;
+        bool usedIQ;
+        bool usedLSQ;
     };
 
     iewComm iewInfo[Impl::MaxThreads];
 
     struct commitComm {
+        /////////////////////////////////////////////////////////////////////
+        // This code has been re-structured for better packing of variables
+        // instead of by stage which is the more logical way to arrange the
+        // data.
+        // F = Fetch
+        // D = Decode
+        // I = IEW
+        // R = Rename
+        // As such each member is annotated with who consumes it
+        // e.g. bool variable name // *F,R for Fetch and Rename
+        /////////////////////////////////////////////////////////////////////
 
-        /////////////// For Decode, IEW, Rename, Fetch ///////////
+        /// The pc of the next instruction to execute. This is the next
-        bool squash;
+        /// instruction for a branch mispredict, but the same instruction for
-        bool robSquashing;
+        /// order violation and the like
+        TheISA::PCState pc; // *F
 
-        ////////// For Fetch & IEW /////////////
+        /// Provide fetch the instruction that mispredicted, if this
-        // Represents the instruction that has either been retired or
+        /// pointer is not-null a misprediction occured
-        // squashed.  Similar to having a single bus that broadcasts the
+        DynInstPtr mispredictInst;  // *F
-        // retired or squashed sequence number.
-        InstSeqNum doneSeqNum;
 
-        ////////////// For Rename /////////////////
+        /// Instruction that caused the a non-mispredict squash
-        // Rename should re-read number of free rob entries
+        DynInstPtr squashInst; // *F
-        bool usedROB;
-        // Notify Rename that the ROB is empty
-        bool emptyROB;
-        // Tell Rename how many free entries it has in the ROB
-        unsigned freeROBEntries;
 
+        /// Hack for now to send back an uncached access to the IEW stage.
+        DynInstPtr uncachedLoad; // *I
 
-        ///////////// For Fetch //////////////////
+        /// Communication specifically to the IQ to tell the IQ that it can
-        // Provide fetch the instruction that mispredicted, if this
+        /// schedule a non-speculative instruction.
-        // pointer is not-null a misprediction occured
+        InstSeqNum nonSpecSeqNum; // *I
-        DynInstPtr mispredictInst;
-        // Was the branch taken or not
-        bool branchTaken;
-        // The pc of the next instruction to execute. This is the next
-        // instruction for a branch mispredict, but the same instruction for
-        // order violation and the like
-        TheISA::PCState pc;
 
-        // Instruction that caused the a non-mispredict squash
+        /// Represents the instruction that has either been retired or
-        DynInstPtr squashInst;
+        /// squashed.  Similar to having a single bus that broadcasts the
-        // If an interrupt is pending and fetch should stall
+        /// retired or squashed sequence number.
-        bool interruptPending;
+        InstSeqNum doneSeqNum; // *F, I
-        // If the interrupt ended up being cleared before being handled
-        bool clearInterrupt;
 
-        //////////// For IEW //////////////////
+        /// Tell Rename how many free entries it has in the ROB
-        // Communication specifically to the IQ to tell the IQ that it can
+        unsigned freeROBEntries; // *R
-        // schedule a non-speculative instruction.
-        InstSeqNum nonSpecSeqNum;
 
-        // Hack for now to send back an uncached access to the IEW stage.
+        bool squash; // *F, D, R, I
-        bool uncached;
+        bool robSquashing; // *F, D, R, I
-        DynInstPtr uncachedLoad;
+
+        /// Rename should re-read number of free rob entries
+        bool usedROB; // *R
+
+        /// Notify Rename that the ROB is empty
+        bool emptyROB; // *R
+
+        /// Was the branch taken or not
+        bool branchTaken; // *F
+        /// If an interrupt is pending and fetch should stall
+        bool interruptPending; // *F
+        /// If the interrupt ended up being cleared before being handled
+        bool clearInterrupt; // *F
+
+        /// Hack for now to send back an uncached access to the IEW stage.
+        bool uncached; // *I
 
     };