diff options
author | Nathan Binkert <nate@binkert.org> | 2009-05-26 09:23:13 -0700 |
---|---|---|
committer | Nathan Binkert <nate@binkert.org> | 2009-05-26 09:23:13 -0700 |
commit | 47877cf2dbd6ee2f1cf9b2c609d37b0589e876ca (patch) | |
tree | 6beb00dfe7e31b9bf82f7aba4710b0c487b6543f /src/cpu/o3/lsq.hh | |
parent | d93392df28fc6c9a5c70fb6252a12afdc72d9344 (diff) | |
download | gem5-47877cf2dbd6ee2f1cf9b2c609d37b0589e876ca.tar.xz |
types: add a type for thread IDs and try to use it everywhere
Diffstat (limited to 'src/cpu/o3/lsq.hh')
-rw-r--r-- | src/cpu/o3/lsq.hh | 76 |
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); } |