Move all of the parameters of the Root SimObject so they are

directly configured by python.  Move stuff from root.(cc|hh) to
core.(cc|hh) since it really belogs there now.
In the process, simplify how ticks are used in the python code.

--HG--
extra : convert_revision : cf82ee1ea20f9343924f30bacc2a38d4edee8df3

8 files changed, 119 insertions, 136 deletions

diff --git a/src/sim/builder.cc b/src/sim/builder.cc
index 8ef54ce52..532df36b1 100644
--- a/src/sim/builder.cc
+++ b/src/sim/builder.cc
@@ -35,7 +35,7 @@
 #include "sim/builder.hh"
 #include "sim/host.hh"
 #include "sim/sim_object.hh"
-#include "sim/root.hh"
+#include "sim/core.hh"
 
 using namespace std;
 
diff --git a/src/sim/core.cc b/src/sim/core.cc
index 24cc33da2..c961e9eb8 100644
--- a/src/sim/core.cc
+++ b/src/sim/core.cc
@@ -34,15 +34,78 @@
 
 #include "base/callback.hh"
 #include "base/output.hh"
+#include "sim/core.hh"
 
 using namespace std;
 
+Tick curTick = 0;
+
+namespace Clock {
+/// The simulated frequency of curTick. (In ticks per second)
+Tick Frequency;
+
+namespace Float {
+double s;
+double ms;
+double us;
+double ns;
+double ps;
+
+double Hz;
+double kHz;
+double MHz;
+double GHZ;
+/* namespace Float */ }
+
+namespace Int {
+Tick s;
+Tick ms;
+Tick us;
+Tick ns;
+Tick ps;
+/* namespace Float */ }
+
+/* namespace Clock */ }
+
+void
+setClockFrequency(Tick ticksPerSecond)
+{
+    using namespace Clock;
+    Frequency = ticksPerSecond;
+    Float::s = static_cast<double>(Frequency);
+    Float::ms = Float::s / 1.0e3;
+    Float::us = Float::s / 1.0e6;
+    Float::ns = Float::s / 1.0e9;
+    Float::ps = Float::s / 1.0e12;
+
+    Float::Hz  = 1.0 / Float::s;
+    Float::kHz = 1.0 / Float::ms;
+    Float::MHz = 1.0 / Float::us;
+    Float::GHZ = 1.0 / Float::ns;
+
+    Int::s  = Frequency;
+    Int::ms = Int::s / 1000;
+    Int::us = Int::ms / 1000;
+    Int::ns = Int::us / 1000;
+    Int::ps = Int::ns / 1000;
+
+}
+
 void
 setOutputDir(const string &dir)
 {
     simout.setDirectory(dir);
 }
 
+ostream *outputStream;
+ostream *configStream;
+
+void
+setOutputFile(const string &file)
+{
+    outputStream = simout.find(file);
+}
+
 /**
  * Queue of C++ callbacks to invoke on simulator exit.
  */
@@ -74,3 +137,4 @@ doExitCleanup()
 
     cout.flush();
 }
+
diff --git a/src/sim/core.hh b/src/sim/core.hh
index 2ef21c4b6..7360032c2 100644
--- a/src/sim/core.hh
+++ b/src/sim/core.hh
@@ -29,12 +29,57 @@
  *          Steve Reinhardt
  */
 
-#include <Python.h>
+#ifndef __SIM_CORE_HH__
+#define __SIM_CORE_HH__
+
 #include <string>
 
-#include "base/callback.hh"
+#include "sim/host.hh"
+
+/// The universal simulation clock.
+extern Tick curTick;
+const Tick retryTime = 1000;
+
+namespace Clock {
+/// The simulated frequency of curTick.
+extern Tick Frequency;
+
+namespace Float {
+extern double s;
+extern double ms;
+extern double us;
+extern double ns;
+extern double ps;
+
+extern double Hz;
+extern double kHz;
+extern double MHz;
+extern double GHZ;
+/* namespace Float */ }
 
+namespace Int {
+extern Tick s;
+extern Tick ms;
+extern Tick us;
+extern Tick ns;
+extern Tick ps;
+/* namespace Int */ }
+/* namespace Clock */ }
+
+void setClockFrequency(Tick ticksPerSecond);
+
+/// Output stream for simulator messages (e.g., cprintf()).  Also used
+/// as default stream for tracing and DPRINTF() messages (unless
+/// overridden with trace:file option).
+extern std::ostream *outputStream;
+void setOutputFile(const std::string &file);
 void setOutputDir(const std::string &dir);
 
+/// Output stream for configuration dump.
+extern std::ostream *configStream;
+
+struct Callback;
 void registerExitCallback(Callback *callback);
 void doExitCleanup();
+
+#endif /* __SIM_CORE_HH__ */
diff --git a/src/sim/eventq.cc b/src/sim/eventq.cc
index 356472d9a..bcd0d3df3 100644
--- a/src/sim/eventq.cc
+++ b/src/sim/eventq.cc
@@ -41,7 +41,7 @@
 
 #include "sim/eventq.hh"
 #include "base/trace.hh"
-#include "sim/root.hh"
+#include "sim/core.hh"
 
 using namespace std;
 
diff --git a/src/sim/main.cc b/src/sim/main.cc
index 0341b7d5f..5bf4add4b 100644
--- a/src/sim/main.cc
+++ b/src/sim/main.cc
@@ -40,7 +40,7 @@
 #include "python/swig/init.hh"
 #include "sim/async.hh"
 #include "sim/host.hh"
-#include "sim/root.hh"
+#include "sim/core.hh"
 
 using namespace std;
 
diff --git a/src/sim/root.cc b/src/sim/root.cc
index 565b57269..f4743af0a 100644
--- a/src/sim/root.cc
+++ b/src/sim/root.cc
@@ -36,91 +36,24 @@
 #include <vector>
 
 #include "base/misc.hh"
-#include "base/output.hh"
 #include "sim/builder.hh"
-#include "sim/host.hh"
-#include "sim/sim_events.hh"
-#include "sim/sim_exit.hh"
 #include "sim/sim_object.hh"
-#include "sim/root.hh"
-
-using namespace std;
-
-Tick curTick = 0;
-ostream *outputStream;
-ostream *configStream;
-
-/// The simulated frequency of curTick. (This is only here for a short time)
-Tick ticksPerSecond;
-
-namespace Clock {
-/// The simulated frequency of curTick. (In ticks per second)
-Tick Frequency;
-
-namespace Float {
-double s;
-double ms;
-double us;
-double ns;
-double ps;
-
-double Hz;
-double kHz;
-double MHz;
-double GHZ;
-/* namespace Float */ }
-
-namespace Int {
-Tick s;
-Tick ms;
-Tick us;
-Tick ns;
-Tick ps;
-/* namespace Float */ }
-
-/* namespace Clock */ }
-
 
 // Dummy Object
-class Root : public SimObject
+struct Root : public SimObject
 {
-  private:
-    Tick max_tick;
-    Tick progress_interval;
-
-  public:
-    Root(const std::string &name, Tick maxtick, Tick pi)
-        : SimObject(name), max_tick(maxtick), progress_interval(pi)
-    {}
-
-    virtual void startup();
+    Root(const std::string &name) : SimObject(name) {}
 };
 
-void
-Root::startup()
-{
-    if (max_tick != 0)
-        schedExitSimLoop("reached maximum cycle count", curTick + max_tick);
-
-    if (progress_interval != 0)
-        new ProgressEvent(&mainEventQueue, progress_interval);
-}
-
 BEGIN_DECLARE_SIM_OBJECT_PARAMS(Root)
 
-    Param<Tick> clock;
-    Param<Tick> max_tick;
-    Param<Tick> progress_interval;
-    Param<string> output_file;
+    Param<int> dummy; // needed below
 
 END_DECLARE_SIM_OBJECT_PARAMS(Root)
 
 BEGIN_INIT_SIM_OBJECT_PARAMS(Root)
 
-    INIT_PARAM(clock, "tick frequency"),
-    INIT_PARAM(max_tick, "maximum simulation time"),
-    INIT_PARAM(progress_interval, "print a progress message"),
-    INIT_PARAM(output_file, "file to dump simulator output to")
+    INIT_PARAM(dummy, "")  // All SimObjects must have params
 
 END_INIT_SIM_OBJECT_PARAMS(Root)
 
@@ -132,29 +65,7 @@ CREATE_SIM_OBJECT(Root)
 
     created = true;
 
-    outputStream = simout.find(output_file);
-    Root *root = new Root(getInstanceName(), max_tick, progress_interval);
-
-    using namespace Clock;
-    Frequency = clock;
-    Float::s = static_cast<double>(Frequency);
-    Float::ms = Float::s / 1.0e3;
-    Float::us = Float::s / 1.0e6;
-    Float::ns = Float::s / 1.0e9;
-    Float::ps = Float::s / 1.0e12;
-
-    Float::Hz  = 1.0 / Float::s;
-    Float::kHz = 1.0 / Float::ms;
-    Float::MHz = 1.0 / Float::us;
-    Float::GHZ = 1.0 / Float::ns;
-
-    Int::s  = Frequency;
-    Int::ms = Int::s / 1000;
-    Int::us = Int::ms / 1000;
-    Int::ns = Int::us / 1000;
-    Int::ps = Int::ns / 1000;
-
-    return root;
+    return  new Root(getInstanceName());
 }
 
 REGISTER_SIM_OBJECT("Root", Root)
diff --git a/src/sim/sim_events.cc b/src/sim/sim_events.cc
index 2ccc9dad2..a4457a11c 100644
--- a/src/sim/sim_events.cc
+++ b/src/sim/sim_events.cc
@@ -158,21 +158,3 @@ 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";
-}
diff --git a/src/sim/sim_events.hh b/src/sim/sim_events.hh
index e1576b38c..94e2540b1 100644
--- a/src/sim/sim_events.hh
+++ b/src/sim/sim_events.hh
@@ -125,23 +125,4 @@ class CheckSwapEvent : public Event
     virtual const char *description();
 };
 
-//
-// Progress event: print out cycle every so often so we know we're
-// making forward progress.
-//
-class ProgressEvent : public Event
-{
-  protected:
-    Tick interval;
-
-  public:
-    ProgressEvent(EventQueue *q, Tick ival)
-        : Event(q), interval(ival)
-    { schedule(curTick + interval); }
-
-    void process();	// process event
-
-    virtual const char *description();
-};
-
 #endif  // __SIM_SIM_EVENTS_HH__