there are two main thrusts of this changeset.

1) return the periodicity of checkpoints back into the code (i.e. make m5 checkpoint n m meaningful again).
2) to do this, i had to much around with being able to repeatedly schedule and SimLoopExitEvent, which led to changes in how exit simloop events are handled to make this easier.

src/arch/alpha/isa/decoder.isa:
src/mem/cache/cache_impl.hh:
    modify arg. order for new calling convention of exitSimLoop.
src/cpu/base.cc:
src/sim/main.cc:
src/sim/pseudo_inst.cc:
src/sim/root.cc:
    now, instead of creating a new SimLoopExitEvent, call a wrapper schedExitSimLoop which handles all the default args.
src/sim/sim_events.cc:
src/sim/sim_events.hh:
src/sim/sim_exit.hh:
    add the periodicity of checkpointing back into the code.

    to facilitate this, there are now two wrappers (instead of just overloading exitSimLoop).  exitSimLoop is only for exiting NOW (i.e. at curTick), while schedExitSimLoop schedules and exit event for the future.

--HG--
extra : convert_revision : c61f4bf05517172edd2c83368fd10bb0f0678029

diff --git a/src/arch/alpha/isa/decoder.isa b/src/arch/alpha/isa/decoder.isa
index 4fc9da3f3fbc37b3287bb8adbfbc8e67cb07201b..5bd19b6773cbc003778d329df5299dbc26d8893e 100644 (file)
--- a/src/arch/alpha/isa/decoder.isa
+++ b/src/arch/alpha/isa/decoder.isa
@@ -701,7 +701,7 @@ decode OPCODE default Unknown::unknown() {
     0x00: decode PALFUNC {
         format EmulatedCallPal {
             0x00: halt ({{
-                exitSimLoop(curTick, "halt instruction encountered");
+                exitSimLoop("halt instruction encountered");
             }}, IsNonSpeculative);
             0x83: callsys({{
                 xc->syscall(R0);

diff --git a/src/cpu/base.cc b/src/cpu/base.cc
index 513dd7c55868c4c79954ce3bfb4e44055507ad6a..ea4b03bf286a44f945c3279451e6c492345b132e 100644 (file)
--- a/src/cpu/base.cc
+++ b/src/cpu/base.cc
@@ -41,6 +41,7 @@
 #include "cpu/cpuevent.hh"
 #include "cpu/thread_context.hh"
 #include "cpu/profile.hh"
+#include "sim/sim_exit.hh"
 #include "sim/param.hh"
 #include "sim/process.hh"
 #include "sim/sim_events.hh"
@@ -125,8 +126,9 @@ BaseCPU::BaseCPU(Params *p)
     //
     if (p->max_insts_any_thread != 0)
         for (int i = 0; i < number_of_threads; ++i)
-            new SimLoopExitEvent(comInstEventQueue[i], p->max_insts_any_thread,
-                                 "a thread reached the max instruction count");
+            schedExitSimLoop("a thread reached the max instruction count",
+                             p->max_insts_any_thread, 0,
+                             comInstEventQueue[i]);
 
     if (p->max_insts_all_threads != 0) {
         // allocate & initialize shared downcounter: each event will
@@ -150,8 +152,9 @@ BaseCPU::BaseCPU(Params *p)
     //
     if (p->max_loads_any_thread != 0)
         for (int i = 0; i < number_of_threads; ++i)
-            new SimLoopExitEvent(comLoadEventQueue[i], p->max_loads_any_thread,
-                                 "a thread reached the max load count");
+            schedExitSimLoop("a thread reached the max load count",
+                             p->max_loads_any_thread, 0,
+                             comLoadEventQueue[i]);
 
     if (p->max_loads_all_threads != 0) {
         // allocate & initialize shared downcounter: each event will

diff --git a/src/mem/cache/cache_impl.hh b/src/mem/cache/cache_impl.hh
index 11cd84e88c4c5479cbf812dc65cbbe07ccd20982..593dbecf3af5b62ec54cff239295dfc007264ea5 100644 (file)
--- a/src/mem/cache/cache_impl.hh
+++ b/src/mem/cache/cache_impl.hh
@@ -51,7 +51,7 @@
 #include "mem/cache/miss/mshr.hh"
 #include "mem/cache/prefetch/prefetcher.hh"
 
-#include "sim/sim_events.hh" // for SimExitEvent
+#include "sim/sim_exit.hh" // for SimExitEvent
 
 template<class TagStore, class Buffering, class Coherence>
 bool
@@ -254,7 +254,7 @@ Cache<TagStore,Buffering,Coherence>::access(PacketPtr &pkt)
         if (missCount) {
             --missCount;
             if (missCount == 0)
-                new SimLoopExitEvent(curTick, "A cache reached the maximum miss count");
+                exitSimLoop("A cache reached the maximum miss count");
         }
     }
     missQueue->handleMiss(pkt, size, curTick + hitLatency);

diff --git a/src/sim/main.cc b/src/sim/main.cc
index 728b7b810fc66b83a5bd6ace57d63818433b9d23..874d0ac85ccfc925e7506072671b64469feba0ec 100644 (file)
--- a/src/sim/main.cc
+++ b/src/sim/main.cc
@@ -317,8 +317,8 @@ simulate(Tick num_cycles = -1)
     else
         num_cycles = curTick + num_cycles;
 
-    Event *limit_event = new SimLoopExitEvent(num_cycles,
-                                              "simulate() limit reached");
+    Event *limit_event = schedExitSimLoop("simulate() limit reached",
+                                          num_cycles);
 
     while (1) {
         // there should always be at least one event (the SimLoopExitEvent

diff --git a/src/sim/pseudo_inst.cc b/src/sim/pseudo_inst.cc
index b66c78b2c208e2c71c0ef5a2e73aacdf2a0fc7a6..addf897c605ac74c0b7e1ee598f0711da25593f1 100644 (file)
--- a/src/sim/pseudo_inst.cc
+++ b/src/sim/pseudo_inst.cc
@@ -138,14 +138,14 @@ namespace AlphaPseudo
     void
     m5exit_old(ThreadContext *tc)
     {
-        exitSimLoop(curTick, "m5_exit_old instruction encountered");
+        exitSimLoop("m5_exit_old instruction encountered");
     }
 
     void
     m5exit(ThreadContext *tc, Tick delay)
     {
         Tick when = curTick + delay * Clock::Int::ns;
-        exitSimLoop(when, "m5_exit instruction encountered");
+        schedExitSimLoop("m5_exit instruction encountered", when);
     }
 
     void
@@ -270,7 +270,11 @@ namespace AlphaPseudo
     {
         if (!doCheckpointInsts)
             return;
-        exitSimLoop("checkpoint");
+
+        Tick when = curTick + delay * Clock::Int::ns;
+        Tick repeat = period * Clock::Int::ns;
+
+        schedExitSimLoop("checkpoint", when, repeat);
     }
 
     uint64_t

diff --git a/src/sim/root.cc b/src/sim/root.cc
index ec5e2f7e2658c746f75b916193f20543bfc48354..565b57269ca0290ca8bfb19c271f14758b59f7d5 100644 (file)
--- a/src/sim/root.cc
+++ b/src/sim/root.cc
@@ -100,7 +100,7 @@ void
 Root::startup()
 {
     if (max_tick != 0)
-        exitSimLoop(curTick + max_tick, "reached maximum cycle count");
+        schedExitSimLoop("reached maximum cycle count", curTick + max_tick);
 
     if (progress_interval != 0)
         new ProgressEvent(&mainEventQueue, progress_interval);

diff --git a/src/sim/sim_events.cc b/src/sim/sim_events.cc
index d9e8bdeaac8f45f07badb63ee89387a5dc84a188..2ccc9dad20047236ffb795a694cbefc6fbde0d0d 100644 (file)
--- a/src/sim/sim_events.cc
+++ b/src/sim/sim_events.cc
@@ -57,6 +57,11 @@ SimLoopExitEvent::process()
 
     // otherwise do nothing... the IsExitEvent flag takes care of
     // exiting the simulation loop and returning this object to Python
+
+    // but if you are doing this on intervals, don't forget to make another
+    if (repeat) {
+        schedule(curTick + repeat);
+    }
 }
 
 
@@ -66,16 +71,20 @@ SimLoopExitEvent::description()
     return "simulation loop exit";
 }
 
-void
-exitSimLoop(Tick when, const std::string &message, int exit_code)
+SimLoopExitEvent *
+schedExitSimLoop(const std::string &message, Tick when, Tick repeat,
+                 EventQueue *q, int exit_code)
 {
-    new SimLoopExitEvent(when, message, exit_code);
+    if (q == NULL)
+        q = &mainEventQueue;
+
+    return new SimLoopExitEvent(q, when, repeat, message, exit_code);
 }
 
 void
 exitSimLoop(const std::string &message, int exit_code)
 {
-    exitSimLoop(curTick, message, exit_code);
+    schedExitSimLoop(message, curTick, 0, NULL, exit_code);
 }
 
 void

diff --git a/src/sim/sim_events.hh b/src/sim/sim_events.hh
index 3c4a9dd05f6814f960b737b880288530512e6859..e1576b38cb71396c5b53c41a523550f3bccd5a12 100644 (file)
--- a/src/sim/sim_events.hh
+++ b/src/sim/sim_events.hh
@@ -42,6 +42,7 @@ class SimLoopExitEvent : public Event
     // string explaining why we're terminating
     std::string cause;
     int code;
+    Tick repeat;
 
   public:
     // Default constructor.  Only really used for derived classes.
@@ -49,16 +50,19 @@ class SimLoopExitEvent : public Event
         : Event(&mainEventQueue, Sim_Exit_Pri)
     { }
 
-    SimLoopExitEvent(Tick _when, const std::string &_cause, int c = 0)
-        : Event(&mainEventQueue, Sim_Exit_Pri), cause(_cause),
-          code(c)
-    { setFlags(IsExitEvent); schedule(_when); }
-
     SimLoopExitEvent(EventQueue *q,
-                     Tick _when, const std::string &_cause, int c = 0)
-        : Event(q, Sim_Exit_Pri), cause(_cause), code(c)
+                     Tick _when, Tick _repeat, const std::string &_cause,
+                     int c = 0)
+        : Event(q, Sim_Exit_Pri), cause(_cause),
+          code(c), repeat(_repeat)
     { setFlags(IsExitEvent); schedule(_when); }
 
+//     SimLoopExitEvent(EventQueue *q,
+//                  Tick _when, const std::string &_cause,
+//                  Tick _repeat = 0, int c = 0)
+//     : Event(q, Sim_Exit_Pri), cause(_cause), code(c), repeat(_repeat)
+//     { setFlags(IsExitEvent); schedule(_when); }
+
     std::string getCause() { return cause; }
     int getCode() { return code; }
 

diff --git a/src/sim/sim_exit.hh b/src/sim/sim_exit.hh
index 545bf4ae066261fdc1077f5c45ca5ad38d2aff2f..d4b31d1eaf2d731eb6176077b0eb4508341c3a52 100644 (file)
--- a/src/sim/sim_exit.hh
+++ b/src/sim/sim_exit.hh
@@ -38,6 +38,8 @@
 
 // forward declaration
 class Callback;
+class EventQueue;
+class SimLoopExitEvent;
 
 /// Register a callback to be called when Python exits.  Defined in
 /// sim/main.cc.
@@ -47,12 +49,14 @@ void registerExitCallback(Callback *);
 /// Python) at the indicated tick.  The message and exit_code
 /// parameters are saved in the SimLoopExitEvent to indicate why the
 /// exit occurred.
-void exitSimLoop(Tick when, const std::string &message, int exit_code = 0);
+SimLoopExitEvent *schedExitSimLoop(const std::string &message, Tick when,
+                                   Tick repeat = 0, EventQueue *q = NULL,
+                                   int exit_code = 0);
 
 /// Schedule an event to exit the simulation loop (returning to
 /// Python) at the end of the current cycle (curTick).  The message
 /// and exit_code parameters are saved in the SimLoopExitEvent to
 /// indicate why the exit occurred.
-void exitSimLoop(const std::string &cause, int exit_code = 0);
+void exitSimLoop(const std::string &message, int exit_code = 0);
 
 #endif // __SIM_EXIT_HH__