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 "cpu/base.hh"
  59 #include "cpu/smt.hh"
  60 #include "mem/mem_object.hh"
  61 #include "mem/port.hh"
  62 #include "sim/async.hh"
  63 #include "sim/builder.hh"
  64 #include "sim/host.hh"
  65 #include "sim/serialize.hh"
  66 #include "sim/sim_events.hh"
  67 #include "sim/sim_exit.hh"
  68 #include "sim/sim_object.hh"
  69 #include "sim/system.hh"
  70 #include "sim/stat_control.hh"
  71 #include "sim/stats.hh"
  72 #include "sim/root.hh"
  73
  74 using namespace std;
  75
  76 // See async.h.
  77 volatile bool async_event = false;
  78 volatile bool async_dump = false;
  79 volatile bool async_dumpreset = false;
  80 volatile bool async_exit = false;
  81 volatile bool async_io = false;
  82 volatile bool async_alarm = false;
  83
  84 /// Stats signal handler.
  85 void
  86 dumpStatsHandler(int sigtype)
  87 {
  88     async_event = true;
  89     async_dump = true;
  90 }
  91
  92 void
  93 dumprstStatsHandler(int sigtype)
  94 {
  95     async_event = true;
  96     async_dumpreset = true;
  97 }
  98
  99 /// Exit signal handler.
 100 void
 101 exitNowHandler(int sigtype)
 102 {
 103     async_event = true;
 104     async_exit = true;
 105 }
 106
 107 /// Abort signal handler.
 108 void
 109 abortHandler(int sigtype)
 110 {
 111     cerr << "Program aborted at cycle " << curTick << endl;
 112
 113 #if TRACING_ON
 114     // dump trace buffer, if there is one
 115     Trace::theLog.dump(cerr);
 116 #endif
 117 }
 118
 119 extern "C" { void init_cc_main(); }
 120
 121 int
 122 main(int argc, char **argv)
 123 {
 124     signal(SIGFPE, SIG_IGN);            // may occur on misspeculated paths
 125     signal(SIGTRAP, SIG_IGN);
 126     signal(SIGUSR1, dumpStatsHandler);          // dump intermediate stats
 127     signal(SIGUSR2, dumprstStatsHandler);       // dump and reset stats
 128     signal(SIGINT, exitNowHandler);             // dump final stats and exit
 129     signal(SIGABRT, abortHandler);
 130
 131     Py_SetProgramName(argv[0]);
 132
 133     // default path to m5 python code is the currently executing
 134     // file... Python ZipImporter will find embedded zip archive.
 135     // The M5_ARCHIVE environment variable can be used to override this.
 136     char *m5_archive = getenv("M5_ARCHIVE");
 137     string pythonpath = m5_archive ? m5_archive : argv[0];
 138
 139     char *oldpath = getenv("PYTHONPATH");
 140     if (oldpath != NULL) {
 141         pythonpath += ":";
 142         pythonpath += oldpath;
 143     }
 144
 145     if (setenv("PYTHONPATH", pythonpath.c_str(), true) == -1)
 146         fatal("setenv: %s\n", strerror(errno));
 147
 148     // initialize embedded Python interpreter
 149     Py_Initialize();
 150     PySys_SetArgv(argc, argv);
 151
 152     // initialize SWIG 'cc_main' module
 153     init_cc_main();
 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 = -1)
 307 {
 308     warn("Entering event queue @ %d.  Starting simulation...\n", curTick);
 309
 310     // Fix up num_cycles.  Special default value -1 means simulate
 311     // "forever"... schedule event at MaxTick just to be safe.
 312     // Otherwise it's a delta for additional cycles to simulate past
 313     // curTick, and thus must be non-negative.
 314     if (num_cycles == -1)
 315         num_cycles = MaxTick;
 316     else if (num_cycles < 0)
 317         fatal("simulate: num_cycles must be >= 0 (was %d)\n", num_cycles);
 318     else
 319         num_cycles = curTick + num_cycles;
 320
 321     Event *limit_event = schedExitSimLoop("simulate() limit reached",
 322                                           num_cycles);
 323
 324     while (1) {
 325         // there should always be at least one event (the SimLoopExitEvent
 326         // we just scheduled) in the queue
 327         assert(!mainEventQueue.empty());
 328         assert(curTick <= mainEventQueue.nextTick() &&
 329                "event scheduled in the past");
 330
 331         // forward current cycle to the time of the first event on the
 332         // queue
 333         curTick = mainEventQueue.nextTick();
 334         Event *exit_event = mainEventQueue.serviceOne();
 335         if (exit_event != NULL) {
 336             // hit some kind of exit event; return to Python
 337             // event must be subclass of SimLoopExitEvent...
 338             SimLoopExitEvent *se_event = dynamic_cast<SimLoopExitEvent *>(exit_event);
 339             if (se_event == NULL)
 340                 panic("Bogus exit event class!");
 341
 342             // if we didn't hit limit_event, delete it
 343             if (se_event != limit_event) {
 344                 assert(limit_event->scheduled());
 345                 limit_event->deschedule();
 346                 delete limit_event;
 347             }
 348
 349             return se_event;
 350         }
 351
 352         if (async_event) {
 353             async_event = false;
 354             if (async_dump) {
 355                 async_dump = false;
 356
 357                 using namespace Stats;
 358                 SetupEvent(Dump, curTick);
 359             }
 360
 361             if (async_dumpreset) {
 362                 async_dumpreset = false;
 363
 364                 using namespace Stats;
 365                 SetupEvent(Dump | Reset, curTick);
 366             }
 367
 368             if (async_exit) {
 369                 async_exit = false;
 370                 exitSimLoop("user interrupt received");
 371             }
 372
 373             if (async_io || async_alarm) {
 374                 async_io = false;
 375                 async_alarm = false;
 376                 pollQueue.service();
 377             }
 378         }
 379     }
 380
 381     // not reached... only exit is return on SimLoopExitEvent
 382 }
 383
 384 Event *
 385 createCountedDrain()
 386 {
 387     return new CountedDrainEvent();
 388 }
 389
 390 void
 391 cleanupCountedDrain(Event *counted_drain)
 392 {
 393     CountedDrainEvent *event =
 394         dynamic_cast<CountedDrainEvent *>(counted_drain);
 395     if (event == NULL) {
 396         fatal("Called cleanupCountedDrain() on an event that was not "
 397               "a CountedDrainEvent.");
 398     }
 399     assert(event->getCount() == 0);
 400     delete event;
 401 }
 402
 403 void
 404 serializeAll(const std::string &cpt_dir)
 405 {
 406     Serializable::serializeAll(cpt_dir);
 407 }
 408
 409 void
 410 unserializeAll(const std::string &cpt_dir)
 411 {
 412     Serializable::unserializeAll(cpt_dir);
 413 }
 414
 415 /**
 416  * Queue of C++ callbacks to invoke on simulator exit.
 417  */
 418 CallbackQueue&
 419 exitCallbacks()
 420 {
 421     static CallbackQueue theQueue;
 422     return theQueue;
 423 }
 424
 425 /**
 426  * Register an exit callback.
 427  */
 428 void
 429 registerExitCallback(Callback *callback)
 430 {
 431     exitCallbacks().add(callback);
 432 }
 433
 434 BaseCPU *
 435 convertToBaseCPUPtr(SimObject *obj)
 436 {
 437     BaseCPU *ptr = dynamic_cast<BaseCPU *>(obj);
 438
 439     if (ptr == NULL)
 440         warn("Casting to BaseCPU pointer failed");
 441     return ptr;
 442 }
 443
 444 System *
 445 convertToSystemPtr(SimObject *obj)
 446 {
 447     System *ptr = dynamic_cast<System *>(obj);
 448
 449     if (ptr == NULL)
 450         warn("Casting to System pointer failed");
 451     return ptr;
 452 }
 453
 454
 455 /**
 456  * Do C++ simulator exit processing.  Exported to SWIG to be invoked
 457  * when simulator terminates via Python's atexit mechanism.
 458  */
 459 void
 460 doExitCleanup()
 461 {
 462     exitCallbacks().process();
 463     exitCallbacks().clear();
 464
 465     cout.flush();
 466
 467     ParamContext::cleanupAllContexts();
 468
 469     // print simulation stats
 470     Stats::DumpNow();
 471 }