Merge vm1.(none):/home/stever/bk/newmem

into  vm1.(none):/home/stever/bk/newmem-py

src/python/m5/__init__.py:
src/sim/syscall_emul.cc:
    Hand merge.

--HG--
extra : convert_revision : e2542735323e648383c89382421d98a7d1d761bf

11 files changed, 273 insertions, 111 deletions

diff --git a/src/sim/eventq.cc b/src/sim/eventq.cc
index d90d0923a..6ae838897 100644
--- a/src/sim/eventq.cc
+++ b/src/sim/eventq.cc
@@ -102,7 +102,7 @@ EventQueue::remove(Event *event)
         prev->next = curr->next;
 }
 
-void
+Event *
 EventQueue::serviceOne()
 {
     Event *event = head;
@@ -110,13 +110,20 @@ EventQueue::serviceOne()
     head = event->next;
 
     // handle action
-    if (!event->squashed())
+    if (!event->squashed()) {
         event->process();
-    else
+        if (event->isExitEvent()) {
+            assert(!event->getFlags(Event::AutoDelete)); // would be silly
+            return event;
+        }
+    } else {
         event->clearFlags(Event::Squashed);
+    }
 
     if (event->getFlags(Event::AutoDelete) && !event->scheduled())
         delete event;
+
+    return NULL;
 }
 
 
diff --git a/src/sim/eventq.hh b/src/sim/eventq.hh
index a5cc0c1b6..430473df3 100644
--- a/src/sim/eventq.hh
+++ b/src/sim/eventq.hh
@@ -90,7 +90,8 @@ class Event : public Serializable, public FastAlloc
         Squashed = 0x1,
         Scheduled = 0x2,
         AutoDelete = 0x4,
-        AutoSerialize = 0x8
+        AutoSerialize = 0x8,
+        IsExitEvent = 0x10
     };
 
     bool getFlags(Flags f) const { return (_flags & f) == f; }
@@ -214,6 +215,9 @@ class Event : public Serializable, public FastAlloc
     /// Check whether the event is squashed
     bool squashed() { return getFlags(Squashed); }
 
+    /// See if this is a SimExitEvent (without resorting to RTTI)
+    bool isExitEvent() { return getFlags(IsExitEvent); }
+
     /// Get the time that the event is scheduled
     Tick when() const { return _when; }
 
@@ -298,7 +302,7 @@ class EventQueue : public Serializable
     void reschedule(Event *ev);
 
     Tick nextTick() { return head->when(); }
-    void serviceOne();
+    Event *serviceOne();
 
     // process all events up to the given timestamp.  we inline a
     // quick test to see if there are any events to process; if so,
diff --git a/src/sim/host.hh b/src/sim/host.hh
index 84870714a..9c79580b1 100644
--- a/src/sim/host.hh
+++ b/src/sim/host.hh
@@ -56,6 +56,8 @@ typedef int64_t Counter;
  */
 typedef int64_t Tick;
 
+const Tick MaxTick = (1LL << 62);
+
 /**
  * Address type
  * This will probably be moved somewhere else in the near future.
diff --git a/src/sim/main.cc b/src/sim/main.cc
index 7728e258a..741926056 100644
--- a/src/sim/main.cc
+++ b/src/sim/main.cc
@@ -41,11 +41,13 @@
 #include <libgen.h>
 #include <stdlib.h>
 #include <signal.h>
+#include <unistd.h>
 
 #include <list>
 #include <string>
 #include <vector>
 
+#include "base/callback.hh"
 #include "base/inifile.hh"
 #include "base/misc.hh"
 #include "base/output.hh"
@@ -111,50 +113,39 @@ abortHandler(int sigtype)
 #endif
 }
 
-/// Simulator executable name
-char *myProgName = "";
 
-///
-/// Echo the command line for posterity in such a way that it can be
-/// used to rerun the same simulation (given the same .ini files).
-///
+const char *briefCopyright =
+"Copyright (c) 2001-2006\n"
+"The Regents of The University of Michigan\n"
+"All Rights Reserved\n";
+
+/// Print welcome message.
 void
-echoCommandLine(int argc, char **argv, ostream &out)
+sayHello(ostream &out)
 {
-    out << "command line: " << argv[0];
-    for (int i = 1; i < argc; i++) {
-        string arg(argv[i]);
+    extern const char *compileDate;     // from date.cc
 
-        out << ' ';
+    ccprintf(out, "M5 Simulator System\n");
+    // display copyright
+    ccprintf(out, "%s\n", briefCopyright);
+    ccprintf(out, "M5 compiled %d\n", compileDate);
+    ccprintf(out, "M5 started %s\n", Time::start);
 
-        // If the arg contains spaces, we need to quote it.
-        // The rest of this is overkill to make it look purty.
+    char *host = getenv("HOSTNAME");
+    if (!host)
+        host = getenv("HOST");
 
-        // print dashes first outside quotes
-        int non_dash_pos = arg.find_first_not_of("-");
-        out << arg.substr(0, non_dash_pos);	// print dashes
-        string body = arg.substr(non_dash_pos);	// the rest
+    if (host)
+        ccprintf(out, "M5 executing on %s\n", host);
+}
 
-        // if it's an assignment, handle the lhs & rhs separately
-        int eq_pos = body.find("=");
-        if (eq_pos == string::npos) {
-            out << quote(body);
-        }
-        else {
-            string lhs(body.substr(0, eq_pos));
-            string rhs(body.substr(eq_pos + 1));
 
-            out << quote(lhs) << "=" << quote(rhs);
-        }
-    }
-    out << endl << endl;
-}
+extern "C" { void init_main(); }
 
 int
 main(int argc, char **argv)
 {
-    // Save off program name
-    myProgName = argv[0];
+    sayHello(cerr);
 
     signal(SIGFPE, SIG_IGN);		// may occur on misspeculated paths
     signal(SIGTRAP, SIG_IGN);
@@ -163,37 +154,108 @@ main(int argc, char **argv)
     signal(SIGINT, exitNowHandler);		// dump final stats and exit
     signal(SIGABRT, abortHandler);
 
-    // Python embedded interpreter invocation
     Py_SetProgramName(argv[0]);
-    const char *fileName = Py_GetProgramFullPath();
+
+    // default path to m5 python code is the currently executing
+    // file... Python ZipImporter will find embedded zip archive
+    char *pythonpath = argv[0];
+
+    bool interactive = false;
+    bool getopt_done = false;
+    do {
+        switch (getopt(argc, argv, "+p:i")) {
+            // -p <path> prepends <path> to PYTHONPATH instead of
+            // using built-in zip archive.  Useful when
+            // developing/debugging changes to built-in Python
+            // libraries, as the new Python can be tested without
+            // building a new m5 binary.
+          case 'p':
+            pythonpath = optarg;
+            break;
+
+            // -i forces entry into interactive mode after the
+            // supplied script is executed (just like the -i option to
+            // the Python interpreter).
+          case 'i':
+            interactive = true;
+            break;
+
+          case -1:
+            getopt_done = true;
+            break;
+
+          default:
+            fatal("Unrecognized option %c\n", optopt);
+        }
+    } while (!getopt_done);
+
+    // Fix up argc & argv to hide arguments we just processed.
+    // getopt() sets optind to the index of the first non-processed
+    // argv element.
+    argc -= optind;
+    argv += optind;
+
+    // Set up PYTHONPATH to make sure the m5 module is found
+    string newpath(pythonpath);
+
+    char *oldpath = getenv("PYTHONPATH");
+    if (oldpath != NULL) {
+        newpath += ":";
+        newpath += oldpath;
+    }
+
+    if (setenv("PYTHONPATH", newpath.c_str(), true) == -1)
+        fatal("setenv: %s\n", strerror(errno));
+
+    // initialize embedded Python interpreter
     Py_Initialize();
     PySys_SetArgv(argc, argv);
 
-    // loadSwigModules();
-
-    // Set Python module path to include current file to find embedded
-    // zip archive
-    if (PyRun_SimpleString("import sys") != 0)
-        panic("Python error importing 'sys' module\n");
-    string pathCmd = csprintf("sys.path[1:1] = ['%s']", fileName);
-    if (PyRun_SimpleString(pathCmd.c_str()) != 0)
-        panic("Python error setting sys.path\n");
-
-    // Pass compile timestamp string to Python
-    extern const char *compileDate;	// from date.cc
-    string setCompileDate = csprintf("compileDate = '%s'", compileDate);
-    if (PyRun_SimpleString(setCompileDate.c_str()) != 0)
-        panic("Python error setting compileDate\n");
-
-    // PyRun_InteractiveLoop(stdin, "stdin");
-    // m5/__init__.py currently contains main argv parsing loop etc.,
-    // and will write out config.ini file before returning.
-    if (PyImport_ImportModule("defines") == NULL)
-        panic("Python error importing 'defines.py'\n");
-    if (PyImport_ImportModule("m5") == NULL)
-        panic("Python error importing 'm5' module\n");
+    // initialize SWIG 'main' module
+    init_main();
+
+    if (argc > 0) {
+        // extra arg(s): first is script file, remaining ones are args
+        // to script file
+        char *filename = argv[0];
+        FILE *fp = fopen(filename, "r");
+        if (!fp) {
+            fatal("cannot open file '%s'\n", filename);
+        }
+
+        PyRun_AnyFile(fp, filename);
+    } else {
+        // no script file argument... force interactive prompt
+        interactive = true;
+    }
+
+    if (interactive) {
+        // The following code to import readline was copied from Python
+        // 2.4.3's Modules/main.c.
+        // Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006
+        // Python Software Foundation; All Rights Reserved
+        // We should only enable this if we're actually using an
+        // interactive prompt.
+        PyObject *v;
+        v = PyImport_ImportModule("readline");
+        if (v == NULL)
+            PyErr_Clear();
+        else
+            Py_DECREF(v);
+
+        PyRun_InteractiveLoop(stdin, "stdin");
+    }
+
+    // clean up Python intepreter.
     Py_Finalize();
+}
+
 
+/// Initialize C++ configuration.  Exported to Python via SWIG; invoked
+/// from m5.instantiate().
+void
+initialize()
+{
     configStream = simout.find("config.out");
 
     // The configuration database is now complete; start processing it.
@@ -212,8 +274,7 @@ main(int argc, char **argv)
     ParamContext::parseAllContexts(inifile);
     ParamContext::checkAllContexts();
 
-    // Echo command line and all parameter settings to stats file as well.
-    echoCommandLine(argc, argv, *outputStream);
+    // Echo all parameter settings to stats file as well.
     ParamContext::showAllContexts(*configStream);
 
     // Any objects that can't connect themselves until after construction should
@@ -244,16 +305,61 @@ main(int argc, char **argv)
     // Reset to put the stats in a consistent state.
     Stats::reset();
 
-    warn("Entering event queue.  Starting simulation...\n");
     SimStartup();
-    while (!mainEventQueue.empty()) {
+}
+
+
+/** Simulate for num_cycles additional cycles.  If num_cycles is -1
+ * (the default), do not limit simulation; some other event must
+ * terminate the loop.  Exported to Python via SWIG.
+ * @return The SimLoopExitEvent that caused the loop to exit.
+ */
+SimLoopExitEvent *
+simulate(Tick num_cycles = -1)
+{
+    warn("Entering event queue @ %d.  Starting simulation...\n", curTick);
+
+    // Fix up num_cycles.  Special default value -1 means simulate
+    // "forever"... schedule event at MaxTick just to be safe.
+    // Otherwise it's a delta for additional cycles to simulate past
+    // curTick, and thus must be non-negative.
+    if (num_cycles == -1)
+        num_cycles = MaxTick;
+    else if (num_cycles < 0)
+        fatal("simulate: num_cycles must be >= 0 (was %d)\n", num_cycles);
+    else
+        num_cycles = curTick + num_cycles;
+
+    Event *limit_event = new SimLoopExitEvent(num_cycles,
+                                              "simulate() limit reached");
+
+    while (1) {
+        // there should always be at least one event (the SimLoopExitEvent
+        // we just scheduled) in the queue
+        assert(!mainEventQueue.empty());
         assert(curTick <= mainEventQueue.nextTick() &&
                "event scheduled in the past");
 
         // forward current cycle to the time of the first event on the
         // queue
         curTick = mainEventQueue.nextTick();
-        mainEventQueue.serviceOne();
+        Event *exit_event = mainEventQueue.serviceOne();
+        if (exit_event != NULL) {
+            // hit some kind of exit event; return to Python
+            // event must be subclass of SimLoopExitEvent...
+            SimLoopExitEvent *se_event = dynamic_cast<SimLoopExitEvent *>(exit_event);
+            if (se_event == NULL)
+                panic("Bogus exit event class!");
+
+            // if we didn't hit limit_event, delete it
+            if (se_event != limit_event) {
+                assert(limit_event->scheduled());
+                limit_event->deschedule();
+                delete limit_event;
+            }
+
+            return se_event;
+        }
 
         if (async_event) {
             async_event = false;
@@ -273,7 +379,7 @@ main(int argc, char **argv)
 
             if (async_exit) {
                 async_exit = false;
-                new SimExitEvent("User requested STOP");
+                exitSimLoop("user interrupt received");
             }
 
             if (async_io || async_alarm) {
@@ -284,11 +390,37 @@ main(int argc, char **argv)
         }
     }
 
-    // This should never happen... every conceivable way for the
-    // simulation to terminate (hit max cycles/insts, signal,
-    // simulated system halts/exits) generates an exit event, so we
-    // should never run out of events on the queue.
-    exitNow("no events on event loop!  All CPUs must be idle.", 1);
+    // not reached... only exit is return on SimLoopExitEvent
+}
+
+/**
+ * Queue of C++ callbacks to invoke on simulator exit.
+ */
+CallbackQueue exitCallbacks;
+
+/**
+ * Register an exit callback.
+ */
+void
+registerExitCallback(Callback *callback)
+{
+    exitCallbacks.add(callback);
+}
+
+/**
+ * Do C++ simulator exit processing.  Exported to SWIG to be invoked
+ * when simulator terminates via Python's atexit mechanism.
+ */
+void
+doExitCleanup()
+{
+    exitCallbacks.process();
+    exitCallbacks.clear();
+
+    cout.flush();
+
+    ParamContext::cleanupAllContexts();
 
-    return 0;
+    // print simulation stats
+    Stats::DumpNow();
 }
diff --git a/src/sim/pseudo_inst.cc b/src/sim/pseudo_inst.cc
index 50d949f53..ae52cdd41 100644
--- a/src/sim/pseudo_inst.cc
+++ b/src/sim/pseudo_inst.cc
@@ -140,14 +140,14 @@ namespace AlphaPseudo
     void
     m5exit_old(ThreadContext *tc)
     {
-        SimExit(curTick, "m5_exit_old instruction encountered");
+        exitSimLoop(curTick, "m5_exit_old instruction encountered");
     }
 
     void
     m5exit(ThreadContext *tc, Tick delay)
     {
         Tick when = curTick + delay * Clock::Int::ns;
-        SimExit(when, "m5_exit instruction encountered");
+        exitSimLoop(when, "m5_exit instruction encountered");
     }
 
     void
diff --git a/src/sim/root.cc b/src/sim/root.cc
index 37b768bf0..ec5e2f7e2 100644
--- a/src/sim/root.cc
+++ b/src/sim/root.cc
@@ -40,6 +40,7 @@
 #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"
 
@@ -99,7 +100,7 @@ void
 Root::startup()
 {
     if (max_tick != 0)
-        new SimExitEvent(curTick + max_tick, "reached maximum cycle count");
+        exitSimLoop(curTick + max_tick, "reached maximum cycle count");
 
     if (progress_interval != 0)
         new ProgressEvent(&mainEventQueue, progress_interval);
diff --git a/src/sim/serialize.cc b/src/sim/serialize.cc
index 3c86826a6..5270802d1 100644
--- a/src/sim/serialize.cc
+++ b/src/sim/serialize.cc
@@ -248,7 +248,7 @@ Serializable::serializeAll()
     assert(Serializable::ckptPrevCount + 1 == Serializable::ckptCount);
     Serializable::ckptPrevCount++;
     if (ckptMaxCount && ++ckptCount >= ckptMaxCount)
-        SimExit(curTick + 1, "Maximum number of checkpoints dropped");
+        exitSimLoop(curTick + 1, "Maximum number of checkpoints dropped");
 
 }
 
diff --git a/src/sim/sim_events.cc b/src/sim/sim_events.cc
index 2aa0508ef..b7901832d 100644
--- a/src/sim/sim_events.cc
+++ b/src/sim/sim_events.cc
@@ -45,26 +45,37 @@ using namespace std;
 // handle termination event
 //
 void
-SimExitEvent::process()
+SimLoopExitEvent::process()
 {
-    // This event does not autodelete because exitNow may be called,
-    // and the function will never be allowed to finish.
-    if (theQueue() == &mainEventQueue) {
-        string _cause = cause;
-        int _code = code;
-        delete this;
-        exitNow(_cause, _code);
-    } else {
-        new SimExitEvent(cause, code);
+    // 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) {
+        exitSimLoop(cause, code);
         delete this;
     }
+
+    // otherwise do nothing... the IsExitEvent flag takes care of
+    // exiting the simulation loop and returning this object to Python
 }
 
 
 const char *
-SimExitEvent::description()
+SimLoopExitEvent::description()
+{
+    return "simulation loop exit";
+}
+
+void
+exitSimLoop(Tick when, const std::string &message, int exit_code)
+{
+    new SimLoopExitEvent(when, message, exit_code);
+}
+
+void
+exitSimLoop(const std::string &message, int exit_code)
 {
-    return "simulation termination";
+    exitSimLoop(curTick, message, exit_code);
 }
 
 //
@@ -90,7 +101,7 @@ void
 CountedExitEvent::process()
 {
     if (--downCounter == 0) {
-        new SimExitEvent(cause, 0);
+        exitSimLoop(cause, 0);
     }
 }
 
@@ -119,7 +130,7 @@ CheckSwapEvent::process()
 
     if (swap < 100) {
         cerr << "\a\aAborting Simulation! Inadequate swap space!\n\n";
-        new SimExitEvent("Lack of swap space");
+        exitSimLoop("Lack of swap space");
     }
 
     schedule(curTick + interval);
diff --git a/src/sim/sim_events.hh b/src/sim/sim_events.hh
index 89bf83fc9..4f305ad38 100644
--- a/src/sim/sim_events.hh
+++ b/src/sim/sim_events.hh
@@ -36,7 +36,7 @@
 //
 // Event to terminate simulation at a particular cycle/instruction
 //
-class SimExitEvent : public Event
+class SimLoopExitEvent : public Event
 {
   private:
     // string explaining why we're terminating
@@ -44,24 +44,18 @@ class SimExitEvent : public Event
     int code;
 
   public:
-    SimExitEvent(const std::string &_cause, int c = 0)
+    SimLoopExitEvent(Tick _when, const std::string &_cause, int c = 0)
         : Event(&mainEventQueue, Sim_Exit_Pri), cause(_cause),
           code(c)
-        { schedule(curTick); }
+    { setFlags(IsExitEvent); schedule(_when); }
 
-    SimExitEvent(Tick _when, const std::string &_cause, int c = 0)
-        : Event(&mainEventQueue, Sim_Exit_Pri), cause(_cause),
-          code(c)
-        { schedule(_when); }
-
-    SimExitEvent(EventQueue *q, const std::string &_cause, int c = 0)
+    SimLoopExitEvent(EventQueue *q,
+                     Tick _when, const std::string &_cause, int c = 0)
         : Event(q, Sim_Exit_Pri), cause(_cause), code(c)
-        { schedule(curTick); }
+    { setFlags(IsExitEvent); schedule(_when); }
 
-    SimExitEvent(EventQueue *q, Tick _when, const std::string &_cause,
-                 int c = 0)
-        : Event(q, Sim_Exit_Pri), cause(_cause), code(c)
-        { schedule(_when); }
+    std::string getCause() { return cause; }
+    int getCode() { return code; }
 
     void process();	// process event
 
diff --git a/src/sim/sim_exit.hh b/src/sim/sim_exit.hh
index f1cf4b5fc..545bf4ae0 100644
--- a/src/sim/sim_exit.hh
+++ b/src/sim/sim_exit.hh
@@ -36,12 +36,23 @@
 
 #include "sim/host.hh"
 
+// forward declaration
 class Callback;
 
+/// Register a callback to be called when Python exits.  Defined in
+/// sim/main.cc.
 void registerExitCallback(Callback *);
 
-void exitNow(const std::string &cause, int exit_code);
-void exitNow(const char *cause, int exit_code);
-void SimExit(Tick when, const char *message);
+/// Schedule an event to exit the simulation loop (returning to
+/// 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);
+
+/// 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);
 
 #endif // __SIM_EXIT_HH__
diff --git a/src/sim/syscall_emul.cc b/src/sim/syscall_emul.cc
index 319b38581..848b6f869 100644
--- a/src/sim/syscall_emul.cc
+++ b/src/sim/syscall_emul.cc
@@ -44,7 +44,7 @@
 #include "mem/page_table.hh"
 #include "sim/process.hh"
 
-#include "sim/sim_events.hh"
+#include "sim/sim_exit.hh"
 
 using namespace std;
 using namespace TheISA;
@@ -92,7 +92,7 @@ SyscallReturn
 exitFunc(SyscallDesc *desc, int callnum, Process *process,
          ThreadContext *tc)
 {
-    new SimExitEvent("target called exit()", tc->getSyscallArg(0) & 0xff);
+    exitSimLoop("target called exit()", tc->getSyscallArg(0) & 0xff);
 
     return 1;
 }