Merge zizzer:/z/m5/Bitkeeper/newmem

into  zazzer.eecs.umich.edu:/z/rdreslin/m5bk/newmemcleanest

--HG--
extra : convert_revision : 2f1bbe84c92879fd1bfa579adc62a367ece1cddd

6 files changed, 40 insertions, 19 deletions

diff --git a/src/sim/main.cc b/src/sim/main.cc
index 728b7b810..874d0ac85 100644
--- 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 b66c78b2c..addf897c6 100644
--- 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 ec5e2f7e2..565b57269 100644
--- 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 d9e8bdeaa..2ccc9dad2 100644
--- 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 3c4a9dd05..e1576b38c 100644
--- 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 545bf4ae0..d4b31d1ea 100644
--- 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__