# HG changeset patch
# User Korey Sewell <[email protected]>
# Date 1254427253 14400
# Node ID d7442a099e4b73c34aefbd74058205b6aafd3f61
# Parent cc0c51c78c1badc7767a664d4375274805781aec
inorder-cleanup: remove unused thread functions
diff --git a/src/cpu/inorder/cpu.cc b/src/cpu/inorder/cpu.cc
--- a/src/cpu/inorder/cpu.cc
+++ b/src/cpu/inorder/cpu.cc
@@ -99,13 +99,9 @@
"DeactivateThread",
"DeallocateThread",
"SuspendThread",
- "DisableThreads",
- "EnableThreads",
- "DisableVPEs",
- "EnableVPEs",
"Trap",
"InstGraduated",
- "SquashAll",
+ "SquashFromMemStall",
"UpdatePCs"
};
@@ -126,28 +122,12 @@
cpu->deactivateThread(tid);
break;
- case SuspendThread:
- 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:
@@ -202,8 +182,7 @@
#endif // FULL_SYSTEM
switchCount(0),
deferRegistration(false/*params->deferRegistration*/),
- stageTracing(params->stageTracing),
- numVirtProcs(1)
+ stageTracing(params->stageTracing)
{
ThreadID active_threads;
cpu_params = params;
@@ -322,11 +301,10 @@
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);
@@ -505,7 +483,7 @@
{
for (int i = 0; i < numThreads; i++) {
isa[i].reset(coreType, numThreads,
- numVirtProcs, dynamic_cast<BaseCPU*>(this));
+ 1/*numVirtProcs*/, dynamic_cast<BaseCPU*>(this));
}
}
@@ -683,6 +661,20 @@
}
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);
@@ -702,6 +694,40 @@
}
void
+InOrderCPU::deallocateContext(ThreadID tid, int delay)
+{
+ DPRINTF(InOrderCPU,"[tid:%i]: Deallocating ...\n", tid);
+
+ scheduleCpuEvent(DeallocateThread, 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::deallocateThread(ThreadID tid)
+{
+ DPRINTF(InOrderCPU, "[tid:%i]: Calling deallocate thread.\n", tid);
+
+ 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);
+
+ removePipelineStalls(*thread_it);
+
+ activeThreads.erase(thread_it);
+ }
+
+ // TODO: "Un"Load/Unmap register file state
+
+}
+
+void
InOrderCPU::removePipelineStalls(ThreadID tid)
{
DPRINTF(InOrderCPU,"[tid:%i]: Removing all pipeline stalls\n",
@@ -712,36 +738,6 @@
}
}
-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)
@@ -753,125 +749,6 @@
}
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)
-{
- DPRINTF(InOrderCPU, "[vpe:%i]: Enabling Concurrent Execution "
- "virtual processors %i", vpe);
-
- list<ThreadID>::iterator thread_it = currentThreads.begin();
-
- while (thread_it != currentThreads.end()) {
- if (!isThreadSuspended(*thread_it)) {
- activateThread(*thread_it);
- }
- thread_it++;
- }
-}
-
-void
-InOrderCPU::disableVirtProcElement(ThreadID tid, unsigned vpe)
-{
- DPRINTF(InOrderCPU, "[vpe:%i]: Scheduling "
- "Disabling of concurrent virtual processor execution",
- vpe);
-
- scheduleCpuEvent(DisableVPEs, NoFault, 0/*tid*/, dummyInst);
-}
-
-void
-InOrderCPU::disableVPEs(ThreadID tid, unsigned vpe)
-{
- DPRINTF(InOrderCPU, "[vpe:%i]: Disabling Concurrent Execution of "
- "virtual processors %i", vpe);
-
- unsigned base_vpe = TheISA::getVirtProcNum(tcBase(tid));
-
- list<ThreadID>::iterator thread_it = activeThreads.begin();
-
- vector<list<ThreadID>::iterator> removeList;
-
- while (thread_it != activeThreads.end()) {
- if (base_vpe != vpe) {
- removeList.push_back(thread_it);
- }
- thread_it++;
- }
-
- for (int i = 0; i < removeList.size(); i++) {
- activeThreads.erase(removeList[i]);
- }
-}
-
-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);
-}
-
-void
-InOrderCPU::enableThreads(unsigned vpe)
-{
- DPRINTF(InOrderCPU, "[vpe:%i]: Enabling Multithreading on "
- "virtual processor %i", vpe);
-
- list<ThreadID>::iterator thread_it = currentThreads.begin();
-
- while (thread_it != currentThreads.end()) {
- if (TheISA::getVirtProcNum(tcBase(*thread_it)) == vpe) {
- if (!isThreadSuspended(*thread_it)) {
- activateThread(*thread_it);
- }
- }
- thread_it++;
- }
-}
-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)
-{
- 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++;
- }
-
- for (int i = 0; i < removeList.size(); i++) {
- activeThreads.erase(removeList[i]);
- }
-}
-
-void
InOrderCPU::updateThreadPriority()
{
if (activeThreads.size() > 1)
@@ -938,6 +815,12 @@
}
void
+InOrderCPU::haltContext(ThreadID tid, int delay)
+{
+ suspendContext(tid, delay);
+}
+
+void
InOrderCPU::suspendContext(ThreadID tid, int delay)
{
scheduleCpuEvent(SuspendThread, NoFault, tid, dummyInst, delay);
@@ -953,24 +836,6 @@
}
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
@@ -979,45 +844,12 @@
}
}
-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
--- a/src/cpu/inorder/cpu.hh
+++ b/src/cpu/inorder/cpu.hh
@@ -176,10 +176,6 @@
DeactivateThread,
DeallocateThread,
SuspendThread,
- DisableThreads,
- EnableThreads,
- DisableVPEs,
- EnableVPEs,
Trap,
InstGraduated,
SquashFromMemStall,
@@ -342,18 +338,6 @@
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);
@@ -362,16 +346,28 @@
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);
@@ -382,37 +378,6 @@
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();
@@ -606,21 +571,15 @@
/** 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
@@ -634,7 +593,8 @@
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()
{
@@ -663,9 +623,6 @@
virtual void wakeup();
#endif
- /** Gets a free thread id. Use if thread ids change across system. */
- ThreadID getFreeTid();
-
// LL/SC debug functionality
unsigned stCondFails;
unsigned readStCondFailures() { return stCondFails; }
@@ -720,18 +677,9 @@
/** 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
--- a/src/cpu/inorder/inorder_dyn_inst.cc
+++ b/src/cpu/inorder/inorder_dyn_inst.cc
@@ -584,30 +584,6 @@
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
--- a/src/cpu/inorder/inorder_dyn_inst.hh
+++ b/src/cpu/inorder/inorder_dyn_inst.hh
@@ -515,12 +515,6 @@
////////////////////////////////////////////////////////////
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
_______________________________________________
m5-dev mailing list
[email protected]
http://m5sim.org/mailman/listinfo/m5-dev
