X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fcpu%2Fbase.cc;h=ce440aeffc2eaf9ba316ea5e8a7abb13e093224f;hb=07186de5a1b1df55a31329b2ca9c53ad168438ff;hp=e48edb2a84ca10d9773df6ea152f7b8808f66e75;hpb=d2d581cf01d07f6a22f02f471d23e3d31919c695;p=gem5.git

diff --git a/src/cpu/base.cc b/src/cpu/base.cc
index e48edb2a8..ce440aeff 100644
--- a/src/cpu/base.cc
+++ b/src/cpu/base.cc
@@ -39,9 +39,8 @@
 #include "base/output.hh"
 #include "cpu/base.hh"
 #include "cpu/cpuevent.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "cpu/profile.hh"
-#include "cpu/sampler/sampler.hh"
 #include "sim/param.hh"
 #include "sim/process.hh"
 #include "sim/sim_events.hh"
@@ -60,11 +59,11 @@ int maxThreadsPerCPU = 1;
 
 #if FULL_SYSTEM
 BaseCPU::BaseCPU(Params *p)
-    : SimObject(p->name), clock(p->clock), checkInterrupts(true),
+    : MemObject(p->name), clock(p->clock), checkInterrupts(true),
       params(p), number_of_threads(p->numberOfThreads), system(p->system)
 #else
 BaseCPU::BaseCPU(Params *p)
-    : SimObject(p->name), clock(p->clock), params(p),
+    : MemObject(p->name), clock(p->clock), params(p),
       number_of_threads(p->numberOfThreads), system(p->system)
 #endif
 {
@@ -89,8 +88,8 @@ BaseCPU::BaseCPU(Params *p)
     //
     if (p->max_insts_any_thread != 0)
         for (int i = 0; i < number_of_threads; ++i)
-            new SimExitEvent(comInstEventQueue[i], p->max_insts_any_thread,
-                "a thread reached the max instruction count");
+            new SimLoopExitEvent(comInstEventQueue[i], p->max_insts_any_thread,
+                                 "a thread reached the max instruction count");
 
     if (p->max_insts_all_threads != 0) {
         // allocate & initialize shared downcounter: each event will
@@ -114,8 +113,8 @@ BaseCPU::BaseCPU(Params *p)
     //
     if (p->max_loads_any_thread != 0)
         for (int i = 0; i < number_of_threads; ++i)
-            new SimExitEvent(comLoadEventQueue[i], p->max_loads_any_thread,
-                "a thread reached the max load count");
+            new SimLoopExitEvent(comLoadEventQueue[i], p->max_loads_any_thread,
+                                 "a thread reached the max load count");
 
     if (p->max_loads_all_threads != 0) {
         // allocate & initialize shared downcounter: each event will
@@ -179,7 +178,7 @@ void
 BaseCPU::init()
 {
     if (!params->deferRegistration)
-        registerExecContexts();
+        registerThreadContexts();
 }
 
 void
@@ -202,15 +201,15 @@ BaseCPU::regStats()
         .desc("number of cpu cycles simulated")
         ;
 
-    int size = execContexts.size();
+    int size = threadContexts.size();
     if (size > 1) {
         for (int i = 0; i < size; ++i) {
             stringstream namestr;
             ccprintf(namestr, "%s.ctx%d", name(), i);
-            execContexts[i]->regStats(namestr.str());
+            threadContexts[i]->regStats(namestr.str());
         }
     } else if (size == 1)
-        execContexts[0]->regStats(name());
+        threadContexts[0]->regStats(name());
 
 #if FULL_SYSTEM
 #endif
@@ -218,26 +217,26 @@ BaseCPU::regStats()
 
 
 void
-BaseCPU::registerExecContexts()
+BaseCPU::registerThreadContexts()
 {
-    for (int i = 0; i < execContexts.size(); ++i) {
-        ExecContext *xc = execContexts[i];
+    for (int i = 0; i < threadContexts.size(); ++i) {
+        ThreadContext *tc = threadContexts[i];
 
 #if FULL_SYSTEM
         int id = params->cpu_id;
         if (id != -1)
             id += i;
 
-        xc->setCpuId(system->registerExecContext(xc, id));
+        tc->setCpuId(system->registerThreadContext(tc, id));
 #else
-        xc->setCpuId(xc->getProcessPtr()->registerExecContext(xc));
+        tc->setCpuId(tc->getProcessPtr()->registerThreadContext(tc));
 #endif
     }
 }
 
 
 void
-BaseCPU::switchOut(Sampler *sampler)
+BaseCPU::switchOut()
 {
     panic("This CPU doesn't support sampling!");
 }
@@ -245,22 +244,22 @@ BaseCPU::switchOut(Sampler *sampler)
 void
 BaseCPU::takeOverFrom(BaseCPU *oldCPU)
 {
-    assert(execContexts.size() == oldCPU->execContexts.size());
+    assert(threadContexts.size() == oldCPU->threadContexts.size());
 
-    for (int i = 0; i < execContexts.size(); ++i) {
-        ExecContext *newXC = execContexts[i];
-        ExecContext *oldXC = oldCPU->execContexts[i];
+    for (int i = 0; i < threadContexts.size(); ++i) {
+        ThreadContext *newTC = threadContexts[i];
+        ThreadContext *oldTC = oldCPU->threadContexts[i];
 
-        newXC->takeOverFrom(oldXC);
+        newTC->takeOverFrom(oldTC);
 
-        CpuEvent::replaceExecContext(oldXC, newXC);
+        CpuEvent::replaceThreadContext(oldTC, newTC);
 
-        assert(newXC->readCpuId() == oldXC->readCpuId());
+        assert(newTC->readCpuId() == oldTC->readCpuId());
 #if FULL_SYSTEM
-        system->replaceExecContext(newXC, newXC->readCpuId());
+        system->replaceThreadContext(newTC, newTC->readCpuId());
 #else
-        assert(newXC->getProcessPtr() == oldXC->getProcessPtr());
-        newXC->getProcessPtr()->replaceExecContext(newXC, newXC->readCpuId());
+        assert(newTC->getProcessPtr() == oldTC->getProcessPtr());
+        newTC->getProcessPtr()->replaceThreadContext(newTC, newTC->readCpuId());
 #endif
     }
 
@@ -269,8 +268,8 @@ BaseCPU::takeOverFrom(BaseCPU *oldCPU)
         interrupts[i] = oldCPU->interrupts[i];
     intstatus = oldCPU->intstatus;
 
-    for (int i = 0; i < execContexts.size(); ++i)
-        execContexts[i]->profileClear();
+    for (int i = 0; i < threadContexts.size(); ++i)
+        threadContexts[i]->profileClear();
 
     if (profileEvent)
         profileEvent->schedule(curTick);
@@ -286,9 +285,9 @@ BaseCPU::ProfileEvent::ProfileEvent(BaseCPU *_cpu, int _interval)
 void
 BaseCPU::ProfileEvent::process()
 {
-    for (int i = 0, size = cpu->execContexts.size(); i < size; ++i) {
-        ExecContext *xc = cpu->execContexts[i];
-        xc->profileSample();
+    for (int i = 0, size = cpu->threadContexts.size(); i < size; ++i) {
+        ThreadContext *tc = cpu->threadContexts[i];
+        tc->profileSample();
     }
 
     schedule(curTick + interval);