src/sim/main.cc

   1 /*
   2  * Copyright (c) 2000-2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Steve Raasch
  29  *          Nathan Binkert
  30  *          Steve Reinhardt
  31  */
  32
  33 ///
  34 /// @file sim/main.cc
  35 ///
  36 #include <Python.h>     // must be before system headers... see Python docs
  37
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <errno.h>
  41 #include <libgen.h>
  42 #include <stdlib.h>
  43 #include <signal.h>
  44 #include <getopt.h>
  45
  46 #include <list>
  47 #include <string>
  48 #include <vector>
  49
  50 #include "base/callback.hh"
  51 #include "base/inifile.hh"
  52 #include "base/misc.hh"
  53 #include "base/output.hh"
  54 #include "base/pollevent.hh"
  55 #include "base/statistics.hh"
  56 #include "base/str.hh"
  57 #include "base/time.hh"
  58 #include "config/pythonhome.hh"
  59 #include "cpu/base.hh"
  60 #include "cpu/smt.hh"
  61 #include "mem/mem_object.hh"
  62 #include "mem/port.hh"
  63 #include "python/swig/init.hh"
  64 #include "sim/async.hh"
  65 #include "sim/builder.hh"
  66 #include "sim/host.hh"
  67 #include "sim/serialize.hh"
  68 #include "sim/sim_events.hh"
  69 #include "sim/sim_exit.hh"
  70 #include "sim/sim_object.hh"
  71 #include "sim/system.hh"
  72 #include "sim/stat_control.hh"
  73 #include "sim/stats.hh"
  74 #include "sim/root.hh"
  75
  76 using namespace std;
  77
  78 // See async.h.
  79 volatile bool async_event = false;
  80 volatile bool async_dump = false;
  81 volatile bool async_dumpreset = false;
  82 volatile bool async_exit = false;
  83 volatile bool async_io = false;
  84 volatile bool async_alarm = false;
  85
  86 /// Stats signal handler.
  87 void
  88 dumpStatsHandler(int sigtype)
  89 {
  90     async_event = true;
  91     async_dump = true;
  92 }
  93
  94 void
  95 dumprstStatsHandler(int sigtype)
  96 {
  97     async_event = true;
  98     async_dumpreset = true;
  99 }
 100
 101 /// Exit signal handler.
 102 void
 103 exitNowHandler(int sigtype)
 104 {
 105     async_event = true;
 106     async_exit = true;
 107 }
 108
 109 /// Abort signal handler.
 110 void
 111 abortHandler(int sigtype)
 112 {
 113     cerr << "Program aborted at cycle " << curTick << endl;
 114 }
 115
 116 int
 117 main(int argc, char **argv)
 118 {
 119     signal(SIGFPE, SIG_IGN);            // may occur on misspeculated paths
 120     signal(SIGTRAP, SIG_IGN);
 121     signal(SIGUSR1, dumpStatsHandler);          // dump intermediate stats
 122     signal(SIGUSR2, dumprstStatsHandler);       // dump and reset stats
 123     signal(SIGINT, exitNowHandler);             // dump final stats and exit
 124     signal(SIGABRT, abortHandler);
 125
 126     Py_SetProgramName(argv[0]);
 127
 128     // default path to m5 python code is the currently executing
 129     // file... Python ZipImporter will find embedded zip archive.
 130     // The M5_ARCHIVE environment variable can be used to override this.
 131     char *m5_archive = getenv("M5_ARCHIVE");
 132     string pythonpath = m5_archive ? m5_archive : argv[0];
 133
 134     char *oldpath = getenv("PYTHONPATH");
 135     if (oldpath != NULL) {
 136         pythonpath += ":";
 137         pythonpath += oldpath;
 138     }
 139
 140     if (setenv("PYTHONPATH", pythonpath.c_str(), true) == -1)
 141         fatal("setenv: %s\n", strerror(errno));
 142
 143     char *python_home = getenv("PYTHONHOME");
 144     if (!python_home)
 145         python_home = PYTHONHOME;
 146     Py_SetPythonHome(python_home);
 147
 148     // initialize embedded Python interpreter
 149     Py_Initialize();
 150     PySys_SetArgv(argc, argv);
 151
 152     // initialize SWIG modules
 153     init_swig();
 154
 155     PyRun_SimpleString("import m5.main");
 156     PyRun_SimpleString("m5.main.main()");
 157
 158     // clean up Python intepreter.
 159     Py_Finalize();
 160 }
 161
 162
 163 void
 164 setOutputDir(const string &dir)
 165 {
 166     simout.setDirectory(dir);
 167 }
 168
 169
 170 IniFile inifile;
 171
 172 SimObject *
 173 createSimObject(const string &name)
 174 {
 175     return SimObjectClass::createObject(inifile, name);
 176 }
 177
 178
 179 /**
 180  * Pointer to the Python function that maps names to SimObjects.
 181  */
 182 PyObject *resolveFunc = NULL;
 183
 184 /**
 185  * Convert a pointer to the Python object that SWIG wraps around a C++
 186  * SimObject pointer back to the actual C++ pointer.  See main.i.
 187  */
 188 extern "C" SimObject *convertSwigSimObjectPtr(PyObject *);
 189
 190
 191 SimObject *
 192 resolveSimObject(const string &name)
 193 {
 194     PyObject *pyPtr = PyEval_CallFunction(resolveFunc, "(s)", name.c_str());
 195     if (pyPtr == NULL) {
 196         PyErr_Print();
 197         panic("resolveSimObject: failure on call to Python for %s", name);
 198     }
 199
 200     SimObject *simObj = convertSwigSimObjectPtr(pyPtr);
 201     if (simObj == NULL)
 202         panic("resolveSimObject: failure on pointer conversion for %s", name);
 203
 204     return simObj;
 205 }
 206
 207
 208 /**
 209  * Load config.ini into C++ database.  Exported to Python via SWIG;
 210  * invoked from m5.instantiate().
 211  */
 212 void
 213 loadIniFile(PyObject *_resolveFunc)
 214 {
 215     resolveFunc = _resolveFunc;
 216     configStream = simout.find("config.out");
 217
 218     // The configuration database is now complete; start processing it.
 219     inifile.load(simout.resolve("config.ini"));
 220
 221     // Initialize statistics database
 222     Stats::InitSimStats();
 223 }
 224
 225
 226 /**
 227  * Look up a MemObject port.  Helper function for connectPorts().
 228  */
 229 Port *
 230 lookupPort(SimObject *so, const std::string &name, int i)
 231 {
 232     MemObject *mo = dynamic_cast<MemObject *>(so);
 233     if (mo == NULL) {
 234         warn("error casting SimObject %s to MemObject", so->name());
 235         return NULL;
 236     }
 237
 238     Port *p = mo->getPort(name, i);
 239     if (p == NULL)
 240         warn("error looking up port %s on object %s", name, so->name());
 241     return p;
 242 }
 243
 244
 245 /**
 246  * Connect the described MemObject ports.  Called from Python via SWIG.
 247  */
 248 int
 249 connectPorts(SimObject *o1, const std::string &name1, int i1,
 250              SimObject *o2, const std::string &name2, int i2)
 251 {
 252     Port *p1 = lookupPort(o1, name1, i1);
 253     Port *p2 = lookupPort(o2, name2, i2);
 254
 255     if (p1 == NULL || p2 == NULL) {
 256         warn("connectPorts: port lookup error");
 257         return 0;
 258     }
 259
 260     p1->setPeer(p2);
 261     p2->setPeer(p1);
 262
 263     return 1;
 264 }
 265
 266 /**
 267  * Do final initialization steps after object construction but before
 268  * start of simulation.
 269  */
 270 void
 271 finalInit()
 272 {
 273     // Parse and check all non-config-hierarchy parameters.
 274     ParamContext::parseAllContexts(inifile);
 275     ParamContext::checkAllContexts();
 276
 277     // Echo all parameter settings to stats file as well.
 278     ParamContext::showAllContexts(*configStream);
 279
 280     // Do a second pass to finish initializing the sim objects
 281     SimObject::initAll();
 282
 283     // Restore checkpointed state, if any.
 284 #if 0
 285     configHierarchy.unserializeSimObjects();
 286 #endif
 287
 288     SimObject::regAllStats();
 289
 290     // Check to make sure that the stats package is properly initialized
 291     Stats::check();
 292
 293     // Reset to put the stats in a consistent state.
 294     Stats::reset();
 295
 296     SimStartup();
 297 }
 298
 299
 300 /** Simulate for num_cycles additional cycles.  If num_cycles is -1
 301  * (the default), do not limit simulation; some other event must
 302  * terminate the loop.  Exported to Python via SWIG.
 303  * @return The SimLoopExitEvent that caused the loop to exit.
 304  */
 305 SimLoopExitEvent *
 306 simulate(Tick num_cycles = MaxTick)
 307 {
 308     warn("Entering event queue @ %d.  Starting simulation...\n", curTick);
 309
 310     if (num_cycles < 0)
 311         fatal("simulate: num_cycles must be >= 0 (was %d)\n", num_cycles);
 312     else if (curTick + num_cycles < 0)  //Overflow
 313         num_cycles = MaxTick;
 314     else
 315         num_cycles = curTick + num_cycles;
 316
 317     Event *limit_event = schedExitSimLoop("simulate() limit reached",
 318                                           num_cycles);
 319
 320     while (1) {
 321         // there should always be at least one event (the SimLoopExitEvent
 322         // we just scheduled) in the queue
 323         assert(!mainEventQueue.empty());
 324         assert(curTick <= mainEventQueue.nextTick() &&
 325                "event scheduled in the past");
 326
 327         // forward current cycle to the time of the first event on the
 328         // queue
 329         curTick = mainEventQueue.nextTick();
 330         Event *exit_event = mainEventQueue.serviceOne();
 331         if (exit_event != NULL) {
 332             // hit some kind of exit event; return to Python
 333             // event must be subclass of SimLoopExitEvent...
 334             SimLoopExitEvent *se_event = dynamic_cast<SimLoopExitEvent *>(exit_event);
 335             if (se_event == NULL)
 336                 panic("Bogus exit event class!");
 337
 338             // if we didn't hit limit_event, delete it
 339             if (se_event != limit_event) {
 340                 assert(limit_event->scheduled());
 341                 limit_event->deschedule();
 342                 delete limit_event;
 343             }
 344
 345             return se_event;
 346         }
 347
 348         if (async_event) {
 349             async_event = false;
 350             if (async_dump) {
 351                 async_dump = false;
 352
 353                 using namespace Stats;
 354                 SetupEvent(Dump, curTick);
 355             }
 356
 357             if (async_dumpreset) {
 358                 async_dumpreset = false;
 359
 360                 using namespace Stats;
 361                 SetupEvent(Dump | Reset, curTick);
 362             }
 363
 364             if (async_exit) {
 365                 async_exit = false;
 366                 exitSimLoop("user interrupt received");
 367             }
 368
 369             if (async_io || async_alarm) {
 370                 async_io = false;
 371                 async_alarm = false;
 372                 pollQueue.service();
 373             }
 374         }
 375     }
 376
 377     // not reached... only exit is return on SimLoopExitEvent
 378 }
 379
 380 Event *
 381 createCountedDrain()
 382 {
 383     return new CountedDrainEvent();
 384 }
 385
 386 void
 387 cleanupCountedDrain(Event *counted_drain)
 388 {
 389     CountedDrainEvent *event =
 390         dynamic_cast<CountedDrainEvent *>(counted_drain);
 391     if (event == NULL) {
 392         fatal("Called cleanupCountedDrain() on an event that was not "
 393               "a CountedDrainEvent.");
 394     }
 395     assert(event->getCount() == 0);
 396     delete event;
 397 }
 398
 399 void
 400 serializeAll(const std::string &cpt_dir)
 401 {
 402     Serializable::serializeAll(cpt_dir);
 403 }
 404
 405 void
 406 unserializeAll(const std::string &cpt_dir)
 407 {
 408     Serializable::unserializeAll(cpt_dir);
 409 }
 410
 411 /**
 412  * Queue of C++ callbacks to invoke on simulator exit.
 413  */
 414 CallbackQueue&
 415 exitCallbacks()
 416 {
 417     static CallbackQueue theQueue;
 418     return theQueue;
 419 }
 420
 421 /**
 422  * Register an exit callback.
 423  */
 424 void
 425 registerExitCallback(Callback *callback)
 426 {
 427     exitCallbacks().add(callback);
 428 }
 429
 430 BaseCPU *
 431 convertToBaseCPUPtr(SimObject *obj)
 432 {
 433     BaseCPU *ptr = dynamic_cast<BaseCPU *>(obj);
 434
 435     if (ptr == NULL)
 436         warn("Casting to BaseCPU pointer failed");
 437     return ptr;
 438 }
 439
 440 System *
 441 convertToSystemPtr(SimObject *obj)
 442 {
 443     System *ptr = dynamic_cast<System *>(obj);
 444
 445     if (ptr == NULL)
 446         warn("Casting to System pointer failed");
 447     return ptr;
 448 }
 449
 450
 451 /**
 452  * Do C++ simulator exit processing.  Exported to SWIG to be invoked
 453  * when simulator terminates via Python's atexit mechanism.
 454  */
 455 void
 456 doExitCleanup()
 457 {
 458     exitCallbacks().process();
 459     exitCallbacks().clear();
 460
 461     cout.flush();
 462
 463     ParamContext::cleanupAllContexts();
 464
 465     // print simulation stats
 466     Stats::DumpNow();
 467 }