From: Korey Sewell Date: Sun, 31 Jan 2010 23:26:40 +0000 (-0500) Subject: inorder-cleanup: remove unused thread functions X-Git-Tag: stable_2012_02_02~1516^2~27 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=d9eaa2fe2149528e109b8b32a00dd4fa72d8ec4f;p=gem5.git inorder-cleanup: remove unused thread functions --- 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(this)); + 1/*numVirtProcs*/, dynamic_cast(this)); } } @@ -703,6 +679,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) { @@ -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::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::iterator isCurrent = - std::find(currentThreads.begin(), currentThreads.end(), tid); - currentThreads.erase(isCurrent); - } -} - -bool -InOrderCPU::isThreadSuspended(ThreadID tid) -{ - list::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::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::iterator thread_it = activeThreads.begin(); - - vector::iterator> removeList; + if (isThreadActive(tid)) { + DPRINTF(InOrderCPU,"[tid:%i]: Removing from active threads list\n", + tid); + list::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::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::iterator thread_it = activeThreads.begin(); - - vector::iterator> removeList; - - while (thread_it != activeThreads.end()) { - if (TheISA::getVirtProcNum(tcBase(*thread_it)) == vpe) { - removeList.push_back(thread_it); - } - thread_it++; - } + list::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 @@ -958,6 +833,12 @@ InOrderCPU::activateNextReadyContext(int delay) _status = Running; } +void +InOrderCPU::haltContext(ThreadID tid, int delay) +{ + suspendContext(tid, delay); +} + void InOrderCPU::suspendContext(ThreadID tid, int delay) { @@ -973,24 +854,6 @@ InOrderCPU::suspendThread(ThreadID tid) suspendedThreads.push_back(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) { @@ -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 activeThreads; - /** Current Threads List */ - std::list currentThreads; - /** Ready Threads List */ std::list readyThreads; /** Suspended Threads List */ std::list 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 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 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