summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorKorey Sewell <ksewell@umich.edu>2010-01-31 18:26:40 -0500
committerKorey Sewell <ksewell@umich.edu>2010-01-31 18:26:40 -0500
commitd9eaa2fe2149528e109b8b32a00dd4fa72d8ec4f (patch)
treefc446281f12bf285dc96b83279cb1bd29e12a5ca /src
parente1fcc6498017574735362636791f9ad73fb39b04 (diff)
downloadgem5-d9eaa2fe2149528e109b8b32a00dd4fa72d8ec4f.tar.xz
inorder-cleanup: remove unused thread functions
Diffstat (limited to 'src')
-rw-r--r--src/cpu/inorder/cpu.cc278
-rw-r--r--src/cpu/inorder/cpu.hh92
-rw-r--r--src/cpu/inorder/inorder_dyn_inst.cc24
-rw-r--r--src/cpu/inorder/inorder_dyn_inst.hh6
4 files changed, 74 insertions, 326 deletions
diff --git a/src/cpu/inorder/cpu.cc b/src/cpu/inorder/cpu.cc
index e52e5935a..954309a74 100644
--- a/src/cpu/inorder/cpu.cc
+++ b/src/cpu/inorder/cpu.cc
@@ -100,13 +100,9 @@ std::string InOrderCPU::eventNames[NumCPUEvents] =
"DeactivateThread",
"DeallocateThread",
"SuspendThread",
- "DisableThreads",
- "EnableThreads",
- "DisableVPEs",
- "EnableVPEs",
"Trap",
"InstGraduated",
- "SquashAll",
+ "SquashFromMemStall",
"UpdatePCs"
};
@@ -119,8 +115,6 @@ InOrderCPU::CPUEvent::process()
cpu->activateThread(tid);
break;
- //@TODO: Consider Implementing "Suspend Thread" as Separate from
- //Deallocate
case ActivateNextReadyThread:
cpu->activateNextReadyThread();
break;
@@ -129,28 +123,12 @@ InOrderCPU::CPUEvent::process()
cpu->deactivateThread(tid);
break;
- case SuspendThread: // Suspend & Deallocate are same for now.
- cpu->suspendThread(tid);
- break;
-
case DeallocateThread:
cpu->deallocateThread(tid);
break;
- case EnableVPEs:
- cpu->enableVPEs(vpe);
- break;
-
- case DisableVPEs:
- cpu->disableVPEs(tid, vpe);
- break;
-
- case EnableThreads:
- cpu->enableThreads(vpe);
- break;
-
- case DisableThreads:
- cpu->disableThreads(tid, vpe);
+ case SuspendThread:
+ cpu->suspendThread(tid);
break;
case SquashFromMemStall:
@@ -212,8 +190,7 @@ InOrderCPU::InOrderCPU(Params *params)
#endif // DEBUG
switchCount(0),
deferRegistration(false/*params->deferRegistration*/),
- stageTracing(params->stageTracing),
- numVirtProcs(1)
+ stageTracing(params->stageTracing)
{
ThreadID active_threads;
cpu_params = params;
@@ -335,11 +312,10 @@ InOrderCPU::InOrderCPU(Params *params)
memset(floatRegs.i[tid], 0, sizeof(floatRegs.i[tid]));
isa[tid].clear();
- isa[tid].expandForMultithreading(numThreads, numVirtProcs);
+ isa[tid].expandForMultithreading(numThreads, 1/*numVirtProcs*/);
}
lastRunningCycle = curTick;
- contextSwitch = false;
// Define dummy instructions and resource requests to be used.
dummyInst = new InOrderDynInst(this, NULL, 0, 0);
@@ -526,7 +502,7 @@ InOrderCPU::reset()
{
for (int i = 0; i < numThreads; i++) {
isa[i].reset(coreType, numThreads,
- numVirtProcs, dynamic_cast<BaseCPU*>(this));
+ 1/*numVirtProcs*/, dynamic_cast<BaseCPU*>(this));
}
}
@@ -704,6 +680,20 @@ InOrderCPU::activateThread(ThreadID tid)
}
void
+InOrderCPU::deactivateContext(ThreadID tid, int delay)
+{
+ DPRINTF(InOrderCPU,"[tid:%i]: Deactivating ...\n", tid);
+
+ scheduleCpuEvent(DeactivateThread, NoFault, tid, dummyInst, delay);
+
+ // Be sure to signal that there's some activity so the CPU doesn't
+ // deschedule itself.
+ activityRec.activity();
+
+ _status = Running;
+}
+
+void
InOrderCPU::deactivateThread(ThreadID tid)
{
DPRINTF(InOrderCPU, "[tid:%i]: Calling deactivate thread.\n", tid);
@@ -723,173 +713,58 @@ InOrderCPU::deactivateThread(ThreadID tid)
}
void
-InOrderCPU::removePipelineStalls(ThreadID tid)
-{
- DPRINTF(InOrderCPU,"[tid:%i]: Removing all pipeline stalls\n",
- tid);
-
- for (int stNum = 0; stNum < NumStages ; stNum++) {
- pipelineStage[stNum]->removeStalls(tid);
- }
-
-}
-bool
-InOrderCPU::isThreadInCPU(ThreadID tid)
-{
- list<ThreadID>::iterator isCurrent =
- std::find(currentThreads.begin(), currentThreads.end(), tid);
-
- return (isCurrent != currentThreads.end());
-}
-
-void
-InOrderCPU::addToCurrentThreads(ThreadID tid)
-{
- if (!isThreadInCPU(tid)) {
- DPRINTF(InOrderCPU, "Adding Thread %i to current threads list in CPU."
- "\n", tid);
- currentThreads.push_back(tid);
- }
-}
-
-void
-InOrderCPU::removeFromCurrentThreads(ThreadID tid)
-{
- if (isThreadInCPU(tid)) {
- DPRINTF(InOrderCPU,
- "Adding Thread %i to current threads list in CPU.\n", tid);
- list<ThreadID>::iterator isCurrent =
- std::find(currentThreads.begin(), currentThreads.end(), tid);
- currentThreads.erase(isCurrent);
- }
-}
-
-bool
-InOrderCPU::isThreadSuspended(ThreadID tid)
-{
- list<ThreadID>::iterator isSuspended =
- std::find(suspendedThreads.begin(), suspendedThreads.end(), tid);
-
- return (isSuspended!= suspendedThreads.end());
-}
-
-void
-InOrderCPU::enableVirtProcElement(unsigned vpe)
-{
- DPRINTF(InOrderCPU, "[vpe:%i]: Scheduling "
- "Enabling of concurrent virtual processor execution",
- vpe);
-
- scheduleCpuEvent(EnableVPEs, NoFault, 0/*tid*/, dummyInst);
-}
-
-void
-InOrderCPU::enableVPEs(unsigned vpe)
+InOrderCPU::deallocateContext(ThreadID tid, int delay)
{
- DPRINTF(InOrderCPU, "[vpe:%i]: Enabling Concurrent Execution "
- "virtual processors %i", vpe);
-
- list<ThreadID>::iterator thread_it = currentThreads.begin();
+ DPRINTF(InOrderCPU,"[tid:%i]: Deallocating ...\n", tid);
- while (thread_it != currentThreads.end()) {
- if (!isThreadSuspended(*thread_it)) {
- activateThread(*thread_it);
- }
- thread_it++;
- }
-}
+ scheduleCpuEvent(DeallocateThread, NoFault, tid, dummyInst, delay);
-void
-InOrderCPU::disableVirtProcElement(ThreadID tid, unsigned vpe)
-{
- DPRINTF(InOrderCPU, "[vpe:%i]: Scheduling "
- "Disabling of concurrent virtual processor execution",
- vpe);
+ // Be sure to signal that there's some activity so the CPU doesn't
+ // deschedule itself.
+ activityRec.activity();
- scheduleCpuEvent(DisableVPEs, NoFault, 0/*tid*/, dummyInst);
+ _status = Running;
}
void
-InOrderCPU::disableVPEs(ThreadID tid, unsigned vpe)
+InOrderCPU::deallocateThread(ThreadID tid)
{
- DPRINTF(InOrderCPU, "[vpe:%i]: Disabling Concurrent Execution of "
- "virtual processors %i", vpe);
+ DPRINTF(InOrderCPU, "[tid:%i]: Calling deallocate thread.\n", tid);
- unsigned base_vpe = TheISA::getVirtProcNum(tcBase(tid));
-
- list<ThreadID>::iterator thread_it = activeThreads.begin();
-
- vector<list<ThreadID>::iterator> removeList;
+ if (isThreadActive(tid)) {
+ DPRINTF(InOrderCPU,"[tid:%i]: Removing from active threads list\n",
+ tid);
+ list<ThreadID>::iterator thread_it =
+ std::find(activeThreads.begin(), activeThreads.end(), tid);
- while (thread_it != activeThreads.end()) {
- if (base_vpe != vpe) {
- removeList.push_back(thread_it);
- }
- thread_it++;
- }
+ removePipelineStalls(*thread_it);
- for (int i = 0; i < removeList.size(); i++) {
- activeThreads.erase(removeList[i]);
+ activeThreads.erase(thread_it);
}
-}
-void
-InOrderCPU::enableMultiThreading(unsigned vpe)
-{
- // Schedule event to take place at end of cycle
- DPRINTF(InOrderCPU, "[vpe:%i]: Scheduling Enable Multithreading on "
- "virtual processor %i", vpe);
-
- scheduleCpuEvent(EnableThreads, NoFault, 0/*tid*/, dummyInst);
+ // TODO: "Un"Load/Unmap register file state
+
}
void
-InOrderCPU::enableThreads(unsigned vpe)
+InOrderCPU::removePipelineStalls(ThreadID tid)
{
- DPRINTF(InOrderCPU, "[vpe:%i]: Enabling Multithreading on "
- "virtual processor %i", vpe);
-
- list<ThreadID>::iterator thread_it = currentThreads.begin();
+ DPRINTF(InOrderCPU,"[tid:%i]: Removing all pipeline stalls\n",
+ tid);
- while (thread_it != currentThreads.end()) {
- if (TheISA::getVirtProcNum(tcBase(*thread_it)) == vpe) {
- if (!isThreadSuspended(*thread_it)) {
- activateThread(*thread_it);
- }
- }
- thread_it++;
+ for (int stNum = 0; stNum < NumStages ; stNum++) {
+ pipelineStage[stNum]->removeStalls(tid);
}
-}
-void
-InOrderCPU::disableMultiThreading(ThreadID tid, unsigned vpe)
-{
- // Schedule event to take place at end of cycle
- DPRINTF(InOrderCPU, "[tid:%i]: Scheduling Disable Multithreading on "
- "virtual processor %i", tid, vpe);
- scheduleCpuEvent(DisableThreads, NoFault, tid, dummyInst);
}
-void
-InOrderCPU::disableThreads(ThreadID tid, unsigned vpe)
+bool
+InOrderCPU::isThreadSuspended(ThreadID tid)
{
- DPRINTF(InOrderCPU, "[tid:%i]: Disabling Multithreading on "
- "virtual processor %i", tid, vpe);
-
- list<ThreadID>::iterator thread_it = activeThreads.begin();
-
- vector<list<ThreadID>::iterator> removeList;
-
- while (thread_it != activeThreads.end()) {
- if (TheISA::getVirtProcNum(tcBase(*thread_it)) == vpe) {
- removeList.push_back(thread_it);
- }
- thread_it++;
- }
+ list<ThreadID>::iterator isSuspended =
+ std::find(suspendedThreads.begin(), suspendedThreads.end(), tid);
- for (int i = 0; i < removeList.size(); i++) {
- activeThreads.erase(removeList[i]);
- }
+ return (isSuspended!= suspendedThreads.end());
}
void
@@ -959,6 +834,12 @@ InOrderCPU::activateNextReadyContext(int delay)
}
void
+InOrderCPU::haltContext(ThreadID tid, int delay)
+{
+ suspendContext(tid, delay);
+}
+
+void
InOrderCPU::suspendContext(ThreadID tid, int delay)
{
scheduleCpuEvent(SuspendThread, NoFault, tid, dummyInst, delay);
@@ -974,24 +855,6 @@ InOrderCPU::suspendThread(ThreadID tid)
}
void
-InOrderCPU::deallocateContext(ThreadID tid, int delay)
-{
- scheduleCpuEvent(DeallocateThread, NoFault, tid, dummyInst, delay);
-}
-
-void
-InOrderCPU::deallocateThread(ThreadID tid)
-{
- DPRINTF(InOrderCPU,"[tid:%i]: Deallocating ...", tid);
-
- removeFromCurrentThreads(tid);
-
- deactivateThread(tid);
-
- squashThreadInPipeline(tid);
-}
-
-void
InOrderCPU::squashThreadInPipeline(ThreadID tid)
{
//Squash all instructions in each stage
@@ -1000,45 +863,12 @@ InOrderCPU::squashThreadInPipeline(ThreadID tid)
}
}
-void
-InOrderCPU::haltContext(ThreadID tid, int delay)
-{
- DPRINTF(InOrderCPU, "[tid:%i]: Halt context called.\n", tid);
-
- // Halt is same thing as deallocate for now
- // @TODO: Differentiate between halt & deallocate in the CPU
- // model
- deallocateContext(tid, delay);
-}
-
-void
-InOrderCPU::insertThread(ThreadID tid)
-{
- panic("Unimplemented Function\n.");
-}
-
-void
-InOrderCPU::removeThread(ThreadID tid)
-{
- DPRINTF(InOrderCPU, "Removing Thread %i from CPU.\n", tid);
-
- /** Broadcast to CPU resources*/
-}
-
PipelineStage*
InOrderCPU::getPipeStage(int stage_num)
{
return pipelineStage[stage_num];
}
-
-void
-InOrderCPU::activateWhenReady(ThreadID tid)
-{
- panic("Unimplemented Function\n.");
-}
-
-
uint64_t
InOrderCPU::readPC(ThreadID tid)
{
diff --git a/src/cpu/inorder/cpu.hh b/src/cpu/inorder/cpu.hh
index 854f5167c..c31481421 100644
--- a/src/cpu/inorder/cpu.hh
+++ b/src/cpu/inorder/cpu.hh
@@ -179,10 +179,6 @@ class InOrderCPU : public BaseCPU
DeactivateThread,
DeallocateThread,
SuspendThread,
- DisableThreads,
- EnableThreads,
- DisableVPEs,
- EnableVPEs,
Trap,
InstGraduated,
SquashFromMemStall,
@@ -347,18 +343,6 @@ class InOrderCPU : public BaseCPU
void trap(Fault fault, ThreadID tid, int delay = 0);
void trapCPU(Fault fault, ThreadID tid);
- /** squashFromMemStall() - sets up a squash event
- * squashDueToMemStall() - squashes pipeline
- */
- void squashFromMemStall(DynInstPtr inst, ThreadID tid, int delay = 0);
- void squashDueToMemStall(int stage_num, InstSeqNum seq_num, ThreadID tid);
-
- /** Setup CPU to insert a thread's context */
- void insertThread(ThreadID tid);
-
- /** Remove all of a thread's context from CPU */
- void removeThread(ThreadID tid);
-
/** Add Thread to Active Threads List. */
void activateContext(ThreadID tid, int delay = 0);
void activateThread(ThreadID tid);
@@ -367,16 +351,28 @@ class InOrderCPU : public BaseCPU
void activateNextReadyContext(int delay = 0);
void activateNextReadyThread();
- /** Remove Thread from Active Threads List */
+ /** Remove from Active Thread List */
+ void deactivateContext(ThreadID tid, int delay = 0);
+ void deactivateThread(ThreadID tid);
+
+ /** Suspend Thread, Remove from Active Threads List, Add to Suspend List */
+ void haltContext(ThreadID tid, int delay = 0);
void suspendContext(ThreadID tid, int delay = 0);
void suspendThread(ThreadID tid);
- /** Remove Thread from Active Threads List &&
- * Remove Thread Context from CPU.
- */
+ /** Remove Thread from Active Threads List, Remove Any Loaded Thread State */
void deallocateContext(ThreadID tid, int delay = 0);
void deallocateThread(ThreadID tid);
- void deactivateThread(ThreadID tid);
+
+ /** squashFromMemStall() - sets up a squash event
+ * squashDueToMemStall() - squashes pipeline
+ */
+ void squashFromMemStall(DynInstPtr inst, ThreadID tid, int delay = 0);
+ void squashDueToMemStall(int stage_num, InstSeqNum seq_num, ThreadID tid);
+
+ void removePipelineStalls(ThreadID tid);
+ void squashThreadInPipeline(ThreadID tid);
+ void squashBehindMemStall(int stage_num, InstSeqNum seq_num, ThreadID tid);
PipelineStage* getPipeStage(int stage_num);
@@ -387,37 +383,6 @@ class InOrderCPU : public BaseCPU
return 0;
}
- /** Remove Thread from Active Threads List &&
- * Remove Thread Context from CPU.
- */
- void haltContext(ThreadID tid, int delay = 0);
-
- void removePipelineStalls(ThreadID tid);
-
- void squashThreadInPipeline(ThreadID tid);
-
- /// Notify the CPU to enable a virtual processor element.
- virtual void enableVirtProcElement(unsigned vpe);
- void enableVPEs(unsigned vpe);
-
- /// Notify the CPU to disable a virtual processor element.
- virtual void disableVirtProcElement(ThreadID tid, unsigned vpe);
- void disableVPEs(ThreadID tid, unsigned vpe);
-
- /// Notify the CPU that multithreading is enabled.
- virtual void enableMultiThreading(unsigned vpe);
- void enableThreads(unsigned vpe);
-
- /// Notify the CPU that multithreading is disabled.
- virtual void disableMultiThreading(ThreadID tid, unsigned vpe);
- void disableThreads(ThreadID tid, unsigned vpe);
-
- /** Activate a Thread When CPU Resources are Available. */
- void activateWhenReady(ThreadID tid);
-
- /** Add or Remove a Thread Context in the CPU. */
- void doContextSwitch();
-
/** Update The Order In Which We Process Threads. */
void updateThreadPriority();
@@ -615,21 +580,15 @@ class InOrderCPU : public BaseCPU
/** Active Threads List */
std::list<ThreadID> activeThreads;
- /** Current Threads List */
- std::list<ThreadID> currentThreads;
-
/** Ready Threads List */
std::list<ThreadID> readyThreads;
/** Suspended Threads List */
std::list<ThreadID> suspendedThreads;
- /** Thread Status Functions (Unused Currently) */
- bool isThreadInCPU(ThreadID tid);
+ /** Thread Status Functions */
bool isThreadActive(ThreadID tid);
bool isThreadSuspended(ThreadID tid);
- void addToCurrentThreads(ThreadID tid);
- void removeFromCurrentThreads(ThreadID tid);
private:
/** The activity recorder; used to tell if the CPU has any
@@ -643,7 +602,8 @@ class InOrderCPU : public BaseCPU
ThreadID numActiveThreads() { return activeThreads.size(); }
/** Thread id of active thread
- * Only used for SwitchOnCacheMiss model. Assumes only 1 thread active
+ * Only used for SwitchOnCacheMiss model.
+ * Assumes only 1 thread active
*/
ThreadID activeThreadId()
{
@@ -672,9 +632,6 @@ class InOrderCPU : public BaseCPU
virtual void wakeup();
#endif
- /** Gets a free thread id. Use if thread ids change across system. */
- ThreadID getFreeTid();
-
// LL/SC debug functionality
unsigned stCondFails;
@@ -740,18 +697,9 @@ class InOrderCPU : public BaseCPU
/** Per-Stage Instruction Tracing */
bool stageTracing;
- /** Is there a context switch pending? */
- bool contextSwitch;
-
- /** Threads Scheduled to Enter CPU */
- std::list<int> cpuWaitList;
-
/** The cycle that the CPU was last running, used for statistics. */
Tick lastRunningCycle;
- /** Number of Virtual Processors the CPU can process */
- unsigned numVirtProcs;
-
/** Update Thread , used for statistic purposes*/
inline void tickThreadStats();
diff --git a/src/cpu/inorder/inorder_dyn_inst.cc b/src/cpu/inorder/inorder_dyn_inst.cc
index 5ab839615..79f8de05d 100644
--- a/src/cpu/inorder/inorder_dyn_inst.cc
+++ b/src/cpu/inorder/inorder_dyn_inst.cc
@@ -583,30 +583,6 @@ InOrderDynInst::deallocateContext(int thread_num)
this->cpu->deallocateContext(thread_num);
}
-void
-InOrderDynInst::enableVirtProcElement(unsigned vpe)
-{
- this->cpu->enableVirtProcElement(vpe);
-}
-
-void
-InOrderDynInst::disableVirtProcElement(unsigned vpe)
-{
- this->cpu->disableVirtProcElement(threadNumber, vpe);
-}
-
-void
-InOrderDynInst::enableMultiThreading(unsigned vpe)
-{
- this->cpu->enableMultiThreading(vpe);
-}
-
-void
-InOrderDynInst::disableMultiThreading(unsigned vpe)
-{
- this->cpu->disableMultiThreading(threadNumber, vpe);
-}
-
template<class T>
inline Fault
InOrderDynInst::read(Addr addr, T &data, unsigned flags)
diff --git a/src/cpu/inorder/inorder_dyn_inst.hh b/src/cpu/inorder/inorder_dyn_inst.hh
index 522b4e8d7..b573c1029 100644
--- a/src/cpu/inorder/inorder_dyn_inst.hh
+++ b/src/cpu/inorder/inorder_dyn_inst.hh
@@ -515,12 +515,6 @@ class InOrderDynInst : public FastAlloc, public RefCounted
////////////////////////////////////////////////////////////
virtual void deallocateContext(int thread_num);
- virtual void enableVirtProcElement(unsigned vpe);
- virtual void disableVirtProcElement(unsigned vpe);
-
- virtual void enableMultiThreading(unsigned vpe);
- virtual void disableMultiThreading(unsigned vpe);
-
////////////////////////////////////////////////////////////
//
// PROGRAM COUNTERS - PC/NPC/NPC