Implement more m5 pseduo opcodes:
authorNathan Binkert <binkertn@umich.edu>
Sun, 2 Nov 2003 23:02:58 +0000 (18:02 -0500)
committerNathan Binkert <binkertn@umich.edu>
Sun, 2 Nov 2003 23:02:58 +0000 (18:02 -0500)
resetstats
dumpstats
dumpresetstats
m5checkpoint

Lots of cleanup of serialization and stats dumping/resetting to
work with these new instructions

arch/alpha/isa_desc:
    Implement more m5 pseduo opcodes:
    resetstats
    dumpstats
    dumpresetstats
    m5checkpoint

    All of these functions take two optional parameters, the first is a delay,
    and the second is a period.  The delay tells the simulator to wait the
    specified number of nanoseconds before triggering the event, the period
    tells the simulator to repeat the event with a specified frequency
base/statistics.cc:
base/statistics.hh:
    regReset RegResetCallback
dev/disk_image.cc:
    serializeFilename -> CheckpointFile()
sim/debug.cc:
    Move this debugging statement to sim_stats.cc
sim/eventq.cc:
    Don't AutoDelete an event if it is scheduled since the process()
    function could potentially schedule the event again.
sim/main.cc:
    DumpStatsEvent is now Statistics::SetupEvent(Dump, curTick)
sim/serialize.cc:
    Change the serialize event so that it's possible to cause the
    event to repeat.  Also make the priority such that the event
    happens just before the simulator would exit if both events
    were scheduled for the same cycle.

    get rid of the serializeFilename variable and provide a CheckpointFile()
    function.  This function takes a basename that is set in the
    configuration, and appends the current cycle to the name so that
    multiple checkpoints can be dumped from the same simulation.

    Also, don't exit the simulation when a checkpoint file is dumped.
sim/serialize.hh:
    serializeFilename -> CheckpointFile()
    SetupCheckpoint function to tell the simulator to prepare
    to checkpoint at a certain time with a certain period
sim/sim_events.cc:
    DumpStatsEvent stuff gets move to sim_stats.(cc|hh)
    The context stuff gets moved into the already existing
    stats context in stat_context.cc
sim/sim_events.hh:
    DumpStatsEvent stuff gets move to sim_stats.(cc|hh)
sim/universe.cc:
    Provide some simple functions for converting times into
    ticks.  These use floating point math to get as close as
    possible to the real values.  Multipliers are set up ahead
    of time

--HG--
extra : convert_revision : d06ef26a9237529a1e5060cb1ac2dcc04d4ec252

12 files changed:
arch/alpha/isa_desc
base/statistics.cc
base/statistics.hh
dev/disk_image.cc
sim/debug.cc
sim/eventq.cc
sim/main.cc
sim/serialize.cc
sim/serialize.hh
sim/sim_events.cc
sim/sim_events.hh
sim/universe.cc

index aaf0cb0a768df4ee950112d1b1b82d89d8fd343c..e34739b86485943a34e6652abae202abe42ce6c0 100644 (file)
@@ -28,7 +28,9 @@ let {{
 #include "cpu/simple_cpu/simple_cpu.hh"
 #include "cpu/static_inst.hh"
 #include "sim/annotation.hh"
+#include "sim/serialize.hh"
 #include "sim/sim_events.hh"
+#include "sim/sim_stats.hh"
 
 #ifdef FULL_SYSTEM
 #include "targetarch/ev5.hh"
@@ -2431,20 +2433,58 @@ decode OPCODE default Unknown::unknown() {
            }}, No_OpClass);
            0x21: m5exit({{
                if (!xc->misspeculating()) {
-                   Tick when = curTick;
                    Tick delay = xc->regs.intRegFile[16];
-                   if (delay != 0) {
-                       delay *= ticksPerUS;
-                       delay /= 1000;
-                       when += delay;
-                   }
+                   Tick when = curTick + NS2Ticks(delay);
                    SimExit(when, "m5_exit instruction encountered");
                }
            }}, No_OpClass);
             0x30: initparam({{ Ra = xc->cpu->system->init_param; }});
             0x40: resetstats({{
-               if (!xc->misspeculating())
-                   Statistics::reset();
+               if (!xc->misspeculating()) {
+                   using namespace Statistics;
+                   Tick delay = xc->regs.intRegFile[16];
+                   Tick period = xc->regs.intRegFile[17];
+
+                   Tick when = curTick + NS2Ticks(delay);
+                   Tick repeat = NS2Ticks(period);
+
+                   SetupEvent(Reset, when, repeat);
+               }
+           }});
+            0x41: dumpstats({{
+               if (!xc->misspeculating()) {
+                   using namespace Statistics;
+                   Tick delay = xc->regs.intRegFile[16];
+                   Tick period = xc->regs.intRegFile[17];
+
+                   Tick when = curTick + NS2Ticks(delay);
+                   Tick repeat = NS2Ticks(period);
+
+                   SetupEvent(Dump, when, repeat);
+               }
+           }});
+            0x42: dumpresetstats({{
+               if (!xc->misspeculating()) {
+                   using namespace Statistics;
+                   Tick delay = xc->regs.intRegFile[16];
+                   Tick period = xc->regs.intRegFile[17];
+
+                   Tick when = curTick + NS2Ticks(delay);
+                   Tick repeat = NS2Ticks(period);
+
+                   SetupEvent(Dump|Reset, when, repeat);
+               }
+           }});
+            0x43: m5checkpoint({{
+               if (!xc->misspeculating()) {
+                   Tick delay = xc->regs.intRegFile[16];
+                   Tick period = xc->regs.intRegFile[17];
+
+                   Tick when = curTick + NS2Ticks(delay);
+                   Tick repeat = NS2Ticks(period);
+
+                   SetupCheckpoint(when, repeat);
+               }
            }});
        }
     }
index 8b2d8e5de5ed0233b40098dc3c64cacb55458a13..c1a5b2626ed6e1237ceec88c6ef11dccd7ef7f6d 100644 (file)
@@ -919,7 +919,7 @@ dump(ostream &stream)
 CallbackQueue resetQueue;
 
 void
-regReset(Callback *cb)
+RegResetCallback(Callback *cb)
 {
     resetQueue.add(cb);
 }
index db08f14f73556cf7d9f006632445d2a811de6ce2..2fe6988b0a8ed2726e130c08b355a0305f7a4a93 100644 (file)
@@ -2763,7 +2763,7 @@ class Formula : public Detail::VectorStat
 void check();
 void dump(std::ostream &stream);
 void reset();
-void regReset(Callback *cb);
+void RegResetCallback(Callback *cb);
 
 inline Detail::Temp
 operator+(Detail::Temp l, Detail::Temp r)
index 747e76965ab17443754722b8f93a1ab6c099828e..a1a220de14ab5ea4f98636c5a0fc4bb07ca6854e 100644 (file)
@@ -405,7 +405,7 @@ CowDiskImage::write(const uint8_t *data, off_t offset)
 void
 CowDiskImage::serialize(ostream &os)
 {
-    string cowFilename = serializeFilename + "." + name() + ".cow";
+    string cowFilename = CheckpointFile() + "." + name() + ".cow";
     SERIALIZE_SCALAR(cowFilename);
     save(cowFilename);
 }
index b18642942c9a02e179ef9a50faa5d0b4a50fff71..95187baff10653c4cdc47abe4d5a6d94c45379e9 100644 (file)
@@ -125,11 +125,6 @@ extern "C" void sched_break_cycle(Tick when)
     new DebugBreakEvent(&mainEventQueue, when);
 }
 
-extern "C" void dump_stats()
-{
-    new DumpStatsEvent();
-}
-
 extern "C" void eventq_dump()
 {
     mainEventQueue.dump();
index fda587dcb170d4c1bab0d2e07bc21603a6caa5b0..52f7dfaff11eca8eefe56af2c929065590d71595 100644 (file)
@@ -112,7 +112,7 @@ EventQueue::serviceOne()
     else
         event->clearFlags(Event::Squashed);
 
-    if (event->getFlags(Event::AutoDelete))
+    if (event->getFlags(Event::AutoDelete) && !event->scheduled())
         delete event;
 }
 
index ce9ef581948ce0d0a8ecdda5e5eead83a50a27b7..addedbc852a6c6e069fb6cce4e8ea8b46772dda0 100644 (file)
@@ -400,7 +400,9 @@ main(int argc, char **argv)
             async_event = false;
             if (async_dump) {
                 async_dump = false;
-                new DumpStatsEvent();
+
+                using namespace Statistics;
+                SetupEvent(Dump, curTick);
             }
 
             if (async_exit) {
index 84d400e164e22d9b8fd3671100114717d5797979..bd528c678eb3977343f596430f8eed951c850050 100644 (file)
@@ -245,14 +245,14 @@ Serializer::add_objects()
 }
 
 void
-Serializer::serialize(const string &f)
+Serializer::serialize()
 {
     if (Serializeable::serializer != NULL)
         panic("in process of serializing!");
 
     Serializeable::serializer = this;
 
-    file = f;
+    file = CheckpointFile();
     string cpt_file = file + ".cpt";
     output = new ofstream(cpt_file.c_str());
     time_t t = time(NULL);
@@ -286,38 +286,49 @@ class SerializeEvent : public Event
 {
   protected:
     string file;
+    Tick repeat;
 
   public:
-    SerializeEvent(EventQueue *q, Tick when, const string &file);
-    ~SerializeEvent();
-
+    SerializeEvent(Tick _when, Tick _repeat);
     virtual void process();
-    virtual void serialize(std::ostream &os);
+    virtual void serialize(std::ostream &os)
+    {
+        panic("Cannot serialize the SerializeEvent");
+    }
+
 };
 
-SerializeEvent::SerializeEvent(EventQueue *q, Tick when, const string &f)
-    : Event(q), file(f)
+SerializeEvent::SerializeEvent(Tick _when, Tick _repeat)
+    : Event(&mainEventQueue, 990), repeat(_repeat)
 {
     setFlags(AutoDelete);
-    schedule(when);
-}
-
-SerializeEvent::~SerializeEvent()
-{
+    schedule(_when);
 }
 
 void
 SerializeEvent::process()
 {
     Serializer serial;
-    serial.serialize(file);
-    new SimExitEvent("Serialization caused exit");
+    serial.serialize();
+    if (repeat)
+        schedule(curTick + repeat);
+}
+
+string __CheckpointFileBase;
+
+string
+CheckpointFile()
+{
+    if (__CheckpointFileBase.empty())
+        return __CheckpointFileBase;
+
+    return csprintf("%s.%d", __CheckpointFileBase, curTick);
 }
 
 void
-SerializeEvent::serialize(ostream &os)
+SetupCheckpoint(Tick when, Tick period)
 {
-    panic("Cannot serialize the SerializeEvent");
+    new SerializeEvent(when, period);
 }
 
 class SerializeParamContext : public ParamContext
@@ -333,18 +344,21 @@ class SerializeParamContext : public ParamContext
 
 SerializeParamContext serialParams("serialize");
 
+Param<string> serialize_file(&serialParams,
+                             "file",
+                             "file to write to", "m5");
+
 Param<Counter> serialize_cycle(&serialParams,
                                 "cycle",
                                 "cycle to serialize",
                                 0);
 
-Param<string> serialize_file(&serialParams,
-                             "file",
-                             "file to write to", "");
+Param<Counter> serialize_period(&serialParams,
+                                "period",
+                                "period to repeat serializations",
+                                0);
+
 
-// Copy filename into regular string so we can export it without
-// having to include param.hh all over the place.
-string serializeFilename;
 
 SerializeParamContext::SerializeParamContext(const string &section)
     : ParamContext(section), event(NULL)
@@ -357,22 +371,23 @@ SerializeParamContext::~SerializeParamContext()
 void
 SerializeParamContext::checkParams()
 {
-    serializeFilename = serialize_file;
-    if (!serializeFilename.empty() && serialize_cycle > 0)
-        event = new SerializeEvent(&mainEventQueue, serialize_cycle,
-                                   serializeFilename);
+    __CheckpointFileBase = serialize_file;
+    if (serialize_cycle > 0)
+        SetupCheckpoint(serialize_cycle, serialize_period);
 }
 
 void
-debug_serialize(const char *file)
+debug_serialize()
 {
     Serializer serial;
-    serial.serialize(file);
-    new SimExitEvent("Serialization caused exit");
+    serial.serialize();
 }
 
-
-
+void
+debug_serialize(Tick when)
+{
+    new SerializeEvent(when, 0);
+}
 
 ////////////////////////////////////////////////////////////////////////
 //
index a8fff7b6f57c9e423222b35cf220e0b889af84d5..78cbb702a7ade1af902d8972c0581b4cfb2018e4 100644 (file)
@@ -148,7 +148,7 @@ class Serializer
     void add_objects();
 
   public:
-    void serialize(const std::string &file);
+    void serialize();
     const std::string &filename() const { return file; }
 };
 
@@ -251,6 +251,7 @@ class Checkpoint
 // Export checkpoint filename param so other objects can derive
 // filenames from it (e.g., memory).
 //
-extern std::string serializeFilename;
+std::string CheckpointFile();
+void SetupCheckpoint(Tick when, Tick period = 0);
 
 #endif // __SERIALIZE_HH__
index 165bab2bf116dd8b41cf517c192f8dc7b2b7a35b..265bf63dc014ea95979cdadf19e34f21f6409b7e 100644 (file)
@@ -103,20 +103,6 @@ CountedExitEvent::description()
     return "counted exit";
 }
 
-
-void
-DumpStatsEvent::process()
-{
-    dumpStats();
-}
-
-const char *
-DumpStatsEvent::description()
-{
-    return "stats dump";
-}
-
-
 #ifdef CHECK_SWAP_CYCLES
 new CheckSwapEvent(&mainEventQueue, CHECK_SWAP_CYCLES);
 #endif
@@ -148,33 +134,6 @@ CheckSwapEvent::description()
 }
 
 
-class DumpStatsContext : public ParamContext
-{
-  public:
-    DumpStatsContext(const string &_iniSection)
-        : ParamContext(_iniSection) {}
-    void checkParams();
-};
-
-DumpStatsContext dumpStatsParams("stats");
-
-VectorParam<Tick> dump_cycle(&dumpStatsParams, "dump_cycles",
-                               "cycles on which to dump stats");
-
-void
-DumpStatsContext::checkParams()
-{
-    if (dump_cycle.isValid()) {
-        vector<Tick> &cycles = dump_cycle;
-
-        vector<Tick>::iterator i = cycles.begin();
-        vector<Tick>::iterator end = cycles.end();
-
-        for (; i < end; ++i)
-            new DumpStatsEvent(*i);
-    }
-}
-
 ///////////////////////////////////////////////////
 //
 // Simulation termination parameters
index bca978ce114b9ab1df46bd99a2b0841ab79d57c8..8a420e419f35fa7a83cc9a5872a9b9163dad29b9 100644 (file)
@@ -91,30 +91,6 @@ class CountedExitEvent : public Event
 //
 // Event to cause a statistics dump
 //
-class DumpStatsEvent : public Event
-{
-  public:
-    DumpStatsEvent()
-        : Event(&mainEventQueue)
-        { setFlags(AutoDelete); schedule(curTick, 999); }
-
-    DumpStatsEvent(EventQueue *q)
-        : Event(q)
-        { setFlags(AutoDelete); schedule(curTick, 999); }
-
-    DumpStatsEvent(Tick when)
-        : Event(&mainEventQueue)
-        { setFlags(AutoDelete); schedule(when, 999); }
-
-    DumpStatsEvent(EventQueue *q, Tick when)
-        : Event(q)
-        { setFlags(AutoDelete); schedule(when, 999); }
-
-    void process();
-
-    virtual const char *description();
-};
-
 class CheckSwapEvent : public Event
 {
   private:
index 4cfcdc563fbe23424d416e30e11b5f70bfaf753d..b75b1f78af27afe3346f40eab1a4f99e258945fb 100644 (file)
@@ -38,9 +38,9 @@ using namespace std;
 
 Tick curTick = 0;
 Tick ticksPerSecond;
-Tick ticksPerMS;
-Tick ticksPerUS;
-Tick ticksPerNS;
+double __ticksPerMS;
+double __ticksPerUS;
+double __ticksPerNS;
 
 class UniverseParamContext : public ParamContext
 {
@@ -58,7 +58,8 @@ void
 UniverseParamContext::checkParams()
 {
     ticksPerSecond = universe_freq;
-    ticksPerMS = universe_freq / 1000;
-    ticksPerUS = universe_freq / (1000 * 1000);
-    ticksPerNS = universe_freq / (1000 * 1000 * 1000);
+    double freq = double(ticksPerSecond);
+    __ticksPerMS = freq / 1.0e3;
+    __ticksPerUS = freq / 1.0e6;
+    __ticksPerNS = freq / 1.0e9;
 }