types: add a type for thread IDs and try to use it everywhere

1 files changed, 38 insertions, 38 deletions

diff --git a/src/cpu/o3/lsq.hh b/src/cpu/o3/lsq.hh
index cf27552d4..a0bae058c 100644
--- a/src/cpu/o3/lsq.hh
+++ b/src/cpu/o3/lsq.hh
@@ -74,24 +74,24 @@ class LSQ {
     Port *getDcachePort() { return &dcachePort; }
 
     /** Sets the pointer to the list of active threads. */
-    void setActiveThreads(std::list<unsigned> *at_ptr);
+    void setActiveThreads(std::list<ThreadID> *at_ptr);
     /** Switches out the LSQ. */
     void switchOut();
     /** Takes over execution from another CPU's thread. */
     void takeOverFrom();
 
     /** Number of entries needed for the given amount of threads.*/
-    int entryAmount(int num_threads);
-    void removeEntries(unsigned tid);
+    int entryAmount(ThreadID num_threads);
+    void removeEntries(ThreadID tid);
     /** Reset the max entries for each thread. */
     void resetEntries();
     /** Resize the max entries for a thread. */
-    void resizeEntries(unsigned size, unsigned tid);
+    void resizeEntries(unsigned size, ThreadID tid);
 
     /** Ticks the LSQ. */
     void tick();
     /** Ticks a specific LSQ Unit. */
-    void tick(unsigned tid)
+    void tick(ThreadID tid)
     { thread[tid].tick(); }
 
     /** Inserts a load into the LSQ. */
@@ -108,13 +108,13 @@ class LSQ {
     /**
      * Commits loads up until the given sequence number for a specific thread.
      */
-    void commitLoads(InstSeqNum &youngest_inst, unsigned tid)
+    void commitLoads(InstSeqNum &youngest_inst, ThreadID tid)
     { thread[tid].commitLoads(youngest_inst); }
 
     /**
      * Commits stores up until the given sequence number for a specific thread.
      */
-    void commitStores(InstSeqNum &youngest_inst, unsigned tid)
+    void commitStores(InstSeqNum &youngest_inst, ThreadID tid)
     { thread[tid].commitStores(youngest_inst); }
 
     /**
@@ -123,12 +123,12 @@ class LSQ {
      */
     void writebackStores();
     /** Same as above, but only for one thread. */
-    void writebackStores(unsigned tid);
+    void writebackStores(ThreadID tid);
 
     /**
      * Squash instructions from a thread until the specified sequence number.
      */
-    void squash(const InstSeqNum &squashed_num, unsigned tid)
+    void squash(const InstSeqNum &squashed_num, ThreadID tid)
     { thread[tid].squash(squashed_num); }
 
     /** Returns whether or not there was a memory ordering violation. */
@@ -137,41 +137,41 @@ class LSQ {
      * Returns whether or not there was a memory ordering violation for a
      * specific thread.
      */
-    bool violation(unsigned tid)
+    bool violation(ThreadID tid)
     { return thread[tid].violation(); }
 
     /** Returns if a load is blocked due to the memory system for a specific
      *  thread.
      */
-    bool loadBlocked(unsigned tid)
+    bool loadBlocked(ThreadID tid)
     { return thread[tid].loadBlocked(); }
 
-    bool isLoadBlockedHandled(unsigned tid)
+    bool isLoadBlockedHandled(ThreadID tid)
     { return thread[tid].isLoadBlockedHandled(); }
 
-    void setLoadBlockedHandled(unsigned tid)
+    void setLoadBlockedHandled(ThreadID tid)
     { thread[tid].setLoadBlockedHandled(); }
 
     /** Gets the instruction that caused the memory ordering violation. */
-    DynInstPtr getMemDepViolator(unsigned tid)
+    DynInstPtr getMemDepViolator(ThreadID tid)
     { return thread[tid].getMemDepViolator(); }
 
     /** Returns the head index of the load queue for a specific thread. */
-    int getLoadHead(unsigned tid)
+    int getLoadHead(ThreadID tid)
     { return thread[tid].getLoadHead(); }
 
     /** Returns the sequence number of the head of the load queue. */
-    InstSeqNum getLoadHeadSeqNum(unsigned tid)
+    InstSeqNum getLoadHeadSeqNum(ThreadID tid)
     {
         return thread[tid].getLoadHeadSeqNum();
     }
 
     /** Returns the head index of the store queue. */
-    int getStoreHead(unsigned tid)
+    int getStoreHead(ThreadID tid)
     { return thread[tid].getStoreHead(); }
 
     /** Returns the sequence number of the head of the store queue. */
-    InstSeqNum getStoreHeadSeqNum(unsigned tid)
+    InstSeqNum getStoreHeadSeqNum(ThreadID tid)
     {
         return thread[tid].getStoreHeadSeqNum();
     }
@@ -179,31 +179,31 @@ class LSQ {
     /** Returns the number of instructions in all of the queues. */
     int getCount();
     /** Returns the number of instructions in the queues of one thread. */
-    int getCount(unsigned tid)
+    int getCount(ThreadID tid)
     { return thread[tid].getCount(); }
 
     /** Returns the total number of loads in the load queue. */
     int numLoads();
     /** Returns the total number of loads for a single thread. */
-    int numLoads(unsigned tid)
+    int numLoads(ThreadID tid)
     { return thread[tid].numLoads(); }
 
     /** Returns the total number of stores in the store queue. */
     int numStores();
     /** Returns the total number of stores for a single thread. */
-    int numStores(unsigned tid)
+    int numStores(ThreadID tid)
     { return thread[tid].numStores(); }
 
     /** Returns the total number of loads that are ready. */
     int numLoadsReady();
     /** Returns the number of loads that are ready for a single thread. */
-    int numLoadsReady(unsigned tid)
+    int numLoadsReady(ThreadID tid)
     { return thread[tid].numLoadsReady(); }
 
     /** Returns the number of free entries. */
     unsigned numFreeEntries();
     /** Returns the number of free entries for a specific thread. */
-    unsigned numFreeEntries(unsigned tid);
+    unsigned numFreeEntries(ThreadID tid);
 
     /** Returns if the LSQ is full (either LQ or SQ is full). */
     bool isFull();
@@ -211,17 +211,17 @@ class LSQ {
      * Returns if the LSQ is full for a specific thread (either LQ or SQ is
      * full).
      */
-    bool isFull(unsigned tid);
+    bool isFull(ThreadID tid);
 
     /** Returns if any of the LQs are full. */
     bool lqFull();
     /** Returns if the LQ of a given thread is full. */
-    bool lqFull(unsigned tid);
+    bool lqFull(ThreadID tid);
 
     /** Returns if any of the SQs are full. */
     bool sqFull();
     /** Returns if the SQ of a given thread is full. */
-    bool sqFull(unsigned tid);
+    bool sqFull(ThreadID tid);
 
     /**
      * Returns if the LSQ is stalled due to a memory operation that must be
@@ -232,7 +232,7 @@ class LSQ {
      * Returns if the LSQ of a specific thread is stalled due to a memory
      * operation that must be replayed.
      */
-    bool isStalled(unsigned tid);
+    bool isStalled(ThreadID tid);
 
     /** Returns whether or not there are any stores to write back to memory. */
     bool hasStoresToWB();
@@ -240,11 +240,11 @@ class LSQ {
     /** Returns whether or not a specific thread has any stores to write back
      * to memory.
      */
-    bool hasStoresToWB(unsigned tid)
+    bool hasStoresToWB(ThreadID tid)
     { return thread[tid].hasStoresToWB(); }
 
     /** Returns the number of stores a specific thread has to write back. */
-    int  numStoresToWB(unsigned tid)
+    int numStoresToWB(ThreadID tid)
     { return thread[tid].numStoresToWB(); }
 
     /** Returns if the LSQ will write back to memory this cycle. */
@@ -252,22 +252,22 @@ class LSQ {
     /** Returns if the LSQ of a specific thread will write back to memory this
      * cycle.
      */
-    bool willWB(unsigned tid)
+    bool willWB(ThreadID tid)
     { return thread[tid].willWB(); }
 
     /** Returns if the cache is currently blocked. */
     bool cacheBlocked()
-    { return retryTid != -1; }
+    { return retryTid != InvalidThreadID; }
 
     /** Sets the retry thread id, indicating that one of the LSQUnits
      * tried to access the cache but the cache was blocked. */
-    void setRetryTid(int tid)
+    void setRetryTid(ThreadID tid)
     { retryTid = tid; }
 
     /** Debugging function to print out all instructions. */
     void dumpInsts();
     /** Debugging function to print out instructions from a specific thread. */
-    void dumpInsts(unsigned tid)
+    void dumpInsts(ThreadID tid)
     { thread[tid].dumpInsts(); }
 
     /** Executes a read operation, using the load specified at the load index. */
@@ -345,7 +345,7 @@ class LSQ {
     LSQUnit thread[Impl::MaxThreads];
 
     /** List of Active Threads in System. */
-    std::list<unsigned> *activeThreads;
+    std::list<ThreadID> *activeThreads;
 
     /** Total Size of LQ Entries. */
     unsigned LQEntries;
@@ -359,11 +359,11 @@ class LSQ {
     unsigned maxSQEntries;
 
     /** Number of Threads. */
-    unsigned numThreads;
+    ThreadID numThreads;
 
     /** The thread id of the LSQ Unit that is currently waiting for a
      * retry. */
-    int retryTid;
+    ThreadID retryTid;
 };
 
 template <class Impl>
@@ -371,7 +371,7 @@ template <class T>
 Fault
 LSQ<Impl>::read(RequestPtr req, T &data, int load_idx)
 {
-    unsigned tid = req->threadId();
+    ThreadID tid = req->threadId();
 
     return thread[tid].read(req, data, load_idx);
 }
@@ -381,7 +381,7 @@ template <class T>
 Fault
 LSQ<Impl>::write(RequestPtr req, T &data, int store_idx)
 {
-    unsigned tid = req->threadId();
+    ThreadID tid = req->threadId();
 
     return thread[tid].write(req, data, store_idx);
 }