"DeactivateThread",
"DeallocateThread",
"SuspendThread",
- "DisableThreads",
- "EnableThreads",
- "DisableVPEs",
- "EnableVPEs",
"Trap",
"InstGraduated",
- "SquashAll",
+ "SquashFromMemStall",
"UpdatePCs"
};
cpu->activateThread(tid);
break;
- //@TODO: Consider Implementing "Suspend Thread" as Separate from
- //Deallocate
case ActivateNextReadyThread:
cpu->activateNextReadyThread();
break;
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:
#endif // DEBUG
switchCount(0),
deferRegistration(false/*params->deferRegistration*/),
- stageTracing(params->stageTracing),
- numVirtProcs(1)
+ stageTracing(params->stageTracing)
{
ThreadID active_threads;
cpu_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);
{
for (int i = 0; i < numThreads; i++) {
isa[i].reset(coreType, numThreads,
- numVirtProcs, dynamic_cast<BaseCPU*>(this));
+ 1/*numVirtProcs*/, dynamic_cast<BaseCPU*>(this));
}
}
}
}
+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)
{
}
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
_status = Running;
}
+void
+InOrderCPU::haltContext(ThreadID tid, int delay)
+{
+ suspendContext(tid, delay);
+}
+
void
InOrderCPU::suspendContext(ThreadID tid, int delay)
{
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)
{
}
}
-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)
{
DeactivateThread,
DeallocateThread,
SuspendThread,
- DisableThreads,
- EnableThreads,
- DisableVPEs,
- EnableVPEs,
Trap,
InstGraduated,
SquashFromMemStall,
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);
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);
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();
/** 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
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()
{
virtual void wakeup();
#endif
- /** Gets a free thread id. Use if thread ids change across system. */
- ThreadID getFreeTid();
-
// LL/SC debug functionality
unsigned stCondFails;
/** 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();
projects / gem5.git / commitdiff