inorder-cleanup: remove unused thread functions

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