Time: Add a mechanism to prevent M5 from running faster than real time.

[gem5.git] / src / sim / sim_events.cc

diff --git a/src/sim/sim_events.cc b/src/sim/sim_events.cc
index b7901832dedbf220d4018fffa90042580fc32ed6..aac844429767ccc18e30e102baf3350cd6ad96a4 100644 (file)
--- a/src/sim/sim_events.cc
+++ b/src/sim/sim_events.cc
@@ -33,14 +33,19 @@
 #include "base/callback.hh"
 #include "base/hostinfo.hh"
 #include "sim/eventq.hh"
-#include "sim/param.hh"
 #include "sim/sim_events.hh"
 #include "sim/sim_exit.hh"
-#include "sim/startup.hh"
 #include "sim/stats.hh"
 
 using namespace std;
 
+SimLoopExitEvent::SimLoopExitEvent(const std::string &_cause, int c, Tick r)
+    : Event(Sim_Exit_Pri), cause(_cause), code(c), repeat(r)
+{
+    setFlags(IsExitEvent);
+}
+
+
 //
 // handle termination event
 //
@@ -50,47 +55,54 @@ SimLoopExitEvent::process()
     // if this got scheduled on a different queue (e.g. the committed
     // instruction queue) then make a corresponding event on the main
     // queue.
-    if (theQueue() != &mainEventQueue) {
+    if (!getFlags(IsMainQueue)) {
         exitSimLoop(cause, code);
         delete this;
     }
 
     // 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) {
+        assert(getFlags(IsMainQueue));
+        mainEventQueue.schedule(this, curTick() + repeat);
+    }
 }
 
 
 const char *
-SimLoopExitEvent::description()
+SimLoopExitEvent::description() const
 {
     return "simulation loop exit";
 }
 
 void
-exitSimLoop(Tick when, const std::string &message, int exit_code)
+exitSimLoop(const std::string &message, int exit_code, Tick when, Tick repeat)
 {
-    new SimLoopExitEvent(when, message, exit_code);
+    Event *event = new SimLoopExitEvent(message, exit_code, repeat);
+    mainEventQueue.schedule(event, when);
 }
 
+CountedDrainEvent::CountedDrainEvent()
+    : count(0)
+{ }
+
 void
-exitSimLoop(const std::string &message, int exit_code)
+CountedDrainEvent::process()
 {
-    exitSimLoop(curTick, message, exit_code);
+    if (--count == 0)
+        exitSimLoop("Finished drain", 0);
 }
 
 //
 // constructor: automatically schedules at specified time
 //
-CountedExitEvent::CountedExitEvent(EventQueue *q, const std::string &_cause,
-                                   Tick _when, int &_downCounter)
-    : Event(q, Sim_Exit_Pri),
-      cause(_cause),
-      downCounter(_downCounter)
+CountedExitEvent::CountedExitEvent(const std::string &_cause, int &counter)
+    : Event(Sim_Exit_Pri), cause(_cause), downCounter(counter)
 {
     // catch stupid mistakes
     assert(downCounter > 0);
-
-    schedule(_when);
 }
 
 
@@ -107,55 +119,7 @@ CountedExitEvent::process()
 
 
 const char *
-CountedExitEvent::description()
+CountedExitEvent::description() const
 {
     return "counted exit";
 }
-
-#ifdef CHECK_SWAP_CYCLES
-new CheckSwapEvent(&mainEventQueue, CHECK_SWAP_CYCLES);
-#endif
-
-void
-CheckSwapEvent::process()
-{
-    /*  Check the amount of free swap space  */
-    long swap;
-
-    /*  returns free swap in KBytes  */
-    swap = procInfo("/proc/meminfo", "SwapFree:");
-
-    if (swap < 1000)
-        ccprintf(cerr, "\a\a\aWarning! Swap space is low (%d)\n", swap);
-
-    if (swap < 100) {
-        cerr << "\a\aAborting Simulation! Inadequate swap space!\n\n";
-        exitSimLoop("Lack of swap space");
-    }
-
-    schedule(curTick + interval);
-}
-
-const char *
-CheckSwapEvent::description()
-{
-    return "check swap";
-}
-
-//
-// handle progress event: print message and reschedule
-//
-void
-ProgressEvent::process()
-{
-    DPRINTFN("ProgressEvent\n");
-    // reschedule for next interval
-    schedule(curTick + interval);
-}
-
-
-const char *
-ProgressEvent::description()
-{
-    return "progress message";
-}