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
  29 ///
  30 /// @file sim/main.cc
  31 ///
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34 #include <errno.h>
  35 #include <libgen.h>
  36 #include <stdlib.h>
  37 #include <signal.h>
  38
  39 #include <list>
  40 #include <string>
  41 #include <vector>
  42
  43 #include "base/copyright.hh"
  44 #include "base/embedfile.hh"
  45 #include "base/inifile.hh"
  46 #include "base/misc.hh"
  47 #include "base/output.hh"
  48 #include "base/pollevent.hh"
  49 #include "base/statistics.hh"
  50 #include "base/str.hh"
  51 #include "base/time.hh"
  52 #include "cpu/base.hh"
  53 #include "cpu/smt.hh"
  54 #include "python/pyconfig.hh"
  55 #include "sim/async.hh"
  56 #include "sim/builder.hh"
  57 #include "sim/configfile.hh"
  58 #include "sim/host.hh"
  59 #include "sim/sim_events.hh"
  60 #include "sim/sim_exit.hh"
  61 #include "sim/sim_object.hh"
  62 #include "sim/stat_control.hh"
  63 #include "sim/stats.hh"
  64 #include "sim/root.hh"
  65
  66 using namespace std;
  67
  68 // See async.h.
  69 volatile bool async_event = false;
  70 volatile bool async_dump = false;
  71 volatile bool async_dumpreset = false;
  72 volatile bool async_exit = false;
  73 volatile bool async_io = false;
  74 volatile bool async_alarm = false;
  75
  76 /// Stats signal handler.
  77 void
  78 dumpStatsHandler(int sigtype)
  79 {
  80     async_event = true;
  81     async_dump = true;
  82 }
  83
  84 void
  85 dumprstStatsHandler(int sigtype)
  86 {
  87     async_event = true;
  88     async_dumpreset = true;
  89 }
  90
  91 /// Exit signal handler.
  92 void
  93 exitNowHandler(int sigtype)
  94 {
  95     async_event = true;
  96     async_exit = true;
  97 }
  98
  99 /// Abort signal handler.
 100 void
 101 abortHandler(int sigtype)
 102 {
 103     cerr << "Program aborted at cycle " << curTick << endl;
 104
 105 #if TRACING_ON
 106     // dump trace buffer, if there is one
 107     Trace::theLog.dump(cerr);
 108 #endif
 109 }
 110
 111 /// Simulator executable name
 112 char *myProgName = "";
 113
 114 /// Show brief help message.
 115 void
 116 showBriefHelp(ostream &out)
 117 {
 118     char *prog = basename(myProgName);
 119
 120     ccprintf(out, "Usage:\n");
 121     ccprintf(out,
 122 "%s [-d <dir>] [-E <var>[=<val>]] [-I <dir>] [-P <python>]\n"
 123 "        [--<var>=<val>] <config file>\n"
 124 "\n"
 125 "   -d            set the output directory to <dir>\n"
 126 "   -E            set the environment variable <var> to <val> (or 'True')\n"
 127 "   -I            add the directory <dir> to python's path\n"
 128 "   -P            execute <python> directly in the configuration\n"
 129 "   --var=val     set the python variable <var> to '<val>'\n"
 130 "   <configfile>  config file name (ends in .py)\n\n",
 131              prog);
 132
 133     ccprintf(out, "%s -X\n   -X            extract embedded files\n\n", prog);
 134     ccprintf(out, "%s -h\n   -h            print short help\n\n", prog);
 135 }
 136
 137 /// Print welcome message.
 138 void
 139 sayHello(ostream &out)
 140 {
 141     extern const char *compileDate;     // from date.cc
 142
 143     ccprintf(out, "M5 Simulator System\n");
 144     // display copyright
 145     ccprintf(out, "%s\n", briefCopyright);
 146     ccprintf(out, "M5 compiled on %d\n", compileDate);
 147
 148     char *host = getenv("HOSTNAME");
 149     if (!host)
 150         host = getenv("HOST");
 151
 152     if (host)
 153         ccprintf(out, "M5 executing on %s\n", host);
 154
 155     ccprintf(out, "M5 simulation started %s\n", Time::start);
 156 }
 157
 158 ///
 159 /// Echo the command line for posterity in such a way that it can be
 160 /// used to rerun the same simulation (given the same .ini files).
 161 ///
 162 void
 163 echoCommandLine(int argc, char **argv, ostream &out)
 164 {
 165     out << "command line: " << argv[0];
 166     for (int i = 1; i < argc; i++) {
 167         string arg(argv[i]);
 168
 169         out << ' ';
 170
 171         // If the arg contains spaces, we need to quote it.
 172         // The rest of this is overkill to make it look purty.
 173
 174         // print dashes first outside quotes
 175         int non_dash_pos = arg.find_first_not_of("-");
 176         out << arg.substr(0, non_dash_pos);     // print dashes
 177         string body = arg.substr(non_dash_pos); // the rest
 178
 179         // if it's an assignment, handle the lhs & rhs separately
 180         int eq_pos = body.find("=");
 181         if (eq_pos == string::npos) {
 182             out << quote(body);
 183         }
 184         else {
 185             string lhs(body.substr(0, eq_pos));
 186             string rhs(body.substr(eq_pos + 1));
 187
 188             out << quote(lhs) << "=" << quote(rhs);
 189         }
 190     }
 191     out << endl << endl;
 192 }
 193
 194 char *
 195 getOptionString(int &index, int argc, char **argv)
 196 {
 197     char *option = argv[index] + 2;
 198     if (*option != '\0')
 199         return option;
 200
 201     // We didn't find an argument, it must be in the next variable.
 202     if (++index >= argc)
 203         panic("option string for option '%s' not found", argv[index - 1]);
 204
 205     return argv[index];
 206 }
 207
 208 int
 209 main(int argc, char **argv)
 210 {
 211     // Save off program name
 212     myProgName = argv[0];
 213
 214     signal(SIGFPE, SIG_IGN);            // may occur on misspeculated paths
 215     signal(SIGTRAP, SIG_IGN);
 216     signal(SIGUSR1, dumpStatsHandler);          // dump intermediate stats
 217     signal(SIGUSR2, dumprstStatsHandler);       // dump and reset stats
 218     signal(SIGINT, exitNowHandler);             // dump final stats and exit
 219     signal(SIGABRT, abortHandler);
 220
 221     bool configfile_found = false;
 222     PythonConfig pyconfig;
 223     string outdir;
 224
 225     if (argc < 2) {
 226         showBriefHelp(cerr);
 227         exit(1);
 228     }
 229
 230     sayHello(cerr);
 231
 232     // Parse command-line options.
 233     // Since most of the complex options are handled through the
 234     // config database, we don't mess with getopts, and just parse
 235     // manually.
 236     for (int i = 1; i < argc; ++i) {
 237         char *arg_str = argv[i];
 238
 239         // if arg starts with '--', parse as a special python option
 240         // of the format --<python var>=<string value>, if the arg
 241         // starts with '-', it should be a simulator option with a
 242         // format similar to getopt.  In any other case, treat the
 243         // option as a configuration file name and load it.
 244         if (arg_str[0] == '-' && arg_str[1] == '-') {
 245             string str = &arg_str[2];
 246             string var, val;
 247
 248             if (!split_first(str, var, val, '='))
 249                 panic("Could not parse configuration argument '%s'\n"
 250                       "Expecting --<variable>=<value>\n", arg_str);
 251
 252             pyconfig.setVariable(var, val);
 253         } else if (arg_str[0] == '-') {
 254             char *option;
 255             string var, val;
 256
 257             // switch on second char
 258             switch (arg_str[1]) {
 259               case 'd':
 260                 outdir = getOptionString(i, argc, argv);
 261                 break;
 262
 263               case 'h':
 264                 showBriefHelp(cerr);
 265                 exit(1);
 266
 267               case 'E':
 268                 option = getOptionString(i, argc, argv);
 269                 if (!split_first(option, var, val, '='))
 270                     val = "True";
 271
 272                 if (setenv(var.c_str(), val.c_str(), true) == -1)
 273                     panic("setenv: %s\n", strerror(errno));
 274                 break;
 275
 276               case 'I':
 277                 option = getOptionString(i, argc, argv);
 278                 pyconfig.addPath(option);
 279                 break;
 280
 281               case 'P':
 282                 option = getOptionString(i, argc, argv);
 283                 pyconfig.writeLine(option);
 284                 break;
 285
 286               case 'X': {
 287                   list<EmbedFile> lst;
 288                   EmbedMap::all(lst);
 289                   list<EmbedFile>::iterator i = lst.begin();
 290                   list<EmbedFile>::iterator end = lst.end();
 291
 292                   while (i != end) {
 293                       cprintf("Embedded File: %s\n", i->name);
 294                       cout.write(i->data, i->length);
 295                       ++i;
 296                   }
 297
 298                   return 0;
 299               }
 300
 301               default:
 302                 showBriefHelp(cerr);
 303                 panic("invalid argument '%s'\n", arg_str);
 304             }
 305         } else {
 306             string file(arg_str);
 307             string base, ext;
 308
 309             if (!split_last(file, base, ext, '.') || ext != "py")
 310                 panic("Config file '%s' must end in '.py'\n", file);
 311
 312             pyconfig.load(file);
 313             configfile_found = true;
 314         }
 315     }
 316
 317     if (outdir.empty()) {
 318         char *env = getenv("OUTPUT_DIR");
 319         outdir = env ? env : ".";
 320     }
 321
 322     simout.setDirectory(outdir);
 323
 324     char *env = getenv("CONFIG_OUTPUT");
 325     if (!env)
 326         env = "config.out";
 327     configStream = simout.find(env);
 328
 329     if (!configfile_found)
 330         panic("no configuration file specified!");
 331
 332     // The configuration database is now complete; start processing it.
 333     IniFile inifile;
 334     if (!pyconfig.output(inifile))
 335         panic("Error processing python code");
 336
 337     // Initialize statistics database
 338     Stats::InitSimStats();
 339
 340     // Now process the configuration hierarchy and create the SimObjects.
 341     ConfigHierarchy configHierarchy(inifile);
 342     configHierarchy.build();
 343     configHierarchy.createSimObjects();
 344
 345     // Parse and check all non-config-hierarchy parameters.
 346     ParamContext::parseAllContexts(inifile);
 347     ParamContext::checkAllContexts();
 348
 349     // Print hello message to stats file if it's actually a file.  If
 350     // it's not (i.e. it's cout or cerr) then we already did it above.
 351     if (simout.isFile(*outputStream))
 352         sayHello(*outputStream);
 353
 354     // Echo command line and all parameter settings to stats file as well.
 355     echoCommandLine(argc, argv, *outputStream);
 356     ParamContext::showAllContexts(*configStream);
 357
 358     // Do a second pass to finish initializing the sim objects
 359     SimObject::initAll();
 360
 361     // Restore checkpointed state, if any.
 362     configHierarchy.unserializeSimObjects();
 363
 364     // Done processing the configuration database.
 365     // Check for unreferenced entries.
 366     if (inifile.printUnreferenced())
 367         panic("unreferenced sections/entries in the intermediate ini file");
 368
 369     SimObject::regAllStats();
 370
 371     // uncomment the following to get PC-based execution-time profile
 372 #ifdef DO_PROFILE
 373     init_profile((char *)&_init, (char *)&_fini);
 374 #endif
 375
 376     // Check to make sure that the stats package is properly initialized
 377     Stats::check();
 378
 379     // Reset to put the stats in a consistent state.
 380     Stats::reset();
 381
 382     warn("Entering event queue.  Starting simulation...\n");
 383     SimStartup();
 384     while (!mainEventQueue.empty()) {
 385         assert(curTick <= mainEventQueue.nextTick() &&
 386                "event scheduled in the past");
 387
 388         // forward current cycle to the time of the first event on the
 389         // queue
 390         curTick = mainEventQueue.nextTick();
 391         mainEventQueue.serviceOne();
 392
 393         if (async_event) {
 394             async_event = false;
 395             if (async_dump) {
 396                 async_dump = false;
 397
 398                 using namespace Stats;
 399                 SetupEvent(Dump, curTick);
 400             }
 401
 402             if (async_dumpreset) {
 403                 async_dumpreset = false;
 404
 405                 using namespace Stats;
 406                 SetupEvent(Dump | Reset, curTick);
 407             }
 408
 409             if (async_exit) {
 410                 async_exit = false;
 411                 new SimExitEvent("User requested STOP");
 412             }
 413
 414             if (async_io || async_alarm) {
 415                 async_io = false;
 416                 async_alarm = false;
 417                 pollQueue.service();
 418             }
 419         }
 420     }
 421
 422     // This should never happen... every conceivable way for the
 423     // simulation to terminate (hit max cycles/insts, signal,
 424     // simulated system halts/exits) generates an exit event, so we
 425     // should never run out of events on the queue.
 426     exitNow("no events on event loop!  All CPUs must be idle.", 1);
 427
 428     return 0;
 429 }