sc_main.cc revision 13312
1/* 2 * Copyright 2018 Google, Inc. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer; 8 * redistributions in binary form must reproduce the above copyright 9 * notice, this list of conditions and the following disclaimer in the 10 * documentation and/or other materials provided with the distribution; 11 * neither the name of the copyright holders nor the names of its 12 * contributors may be used to endorse or promote products derived from 13 * this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 18 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 19 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 21 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * Authors: Gabe Black 28 */ 29 30#include <cstring> 31#include <string> 32 33#include "base/fiber.hh" 34#include "base/logging.hh" 35#include "base/types.hh" 36#include "sim/core.hh" 37#include "sim/eventq.hh" 38#include "sim/init.hh" 39#include "systemc/core/kernel.hh" 40#include "systemc/core/python.hh" 41#include "systemc/core/scheduler.hh" 42#include "systemc/ext/core/sc_main.hh" 43#include "systemc/ext/utils/sc_report_handler.hh" 44#include "systemc/utils/report.hh" 45 46// A weak symbol to detect if sc_main has been defined, and if so where it is. 47[[gnu::weak]] int sc_main(int argc, char *argv[]); 48 49namespace sc_core 50{ 51 52namespace 53{ 54 55bool scMainCalled = false; 56 57int _argc = 0; 58char **_argv = NULL; 59 60class ScMainFiber : public Fiber 61{ 62 public: 63 std::string resultStr; 64 int resultInt; 65 66 ScMainFiber() : resultInt(1) {} 67 68 void 69 main() 70 { 71 if (::sc_main) { 72 try { 73 resultInt = ::sc_main(_argc, _argv); 74 if (resultInt) 75 resultStr = "sc_main returned non-zero"; 76 else 77 resultStr = "sc_main finished"; 78 // Make sure no systemc events/notifications are scheduled 79 // after sc_main returns. 80 } catch (const sc_report &r) { 81 // There was an exception nobody caught. 82 resultStr = "uncaught sc_report"; 83 sc_gem5::reportHandlerProc( 84 r, sc_report_handler::get_catch_actions()); 85 } catch (...) { 86 // There was some other type of exception we need to wrap. 87 resultStr = "uncaught exception"; 88 sc_gem5::reportHandlerProc( 89 ::sc_gem5::reportifyException(), 90 sc_report_handler::get_catch_actions()); 91 } 92 ::sc_gem5::Kernel::scMainFinished(true); 93 ::sc_gem5::scheduler.clear(); 94 } else { 95 // If python tries to call sc_main but no sc_main was defined... 96 fatal("sc_main called but not defined.\n"); 97 } 98 } 99}; 100 101ScMainFiber scMainFiber; 102 103// This wrapper adapts the python version of sc_main to the c++ version. 104void 105sc_main(pybind11::args args) 106{ 107 panic_if(scMainCalled, "sc_main called more than once."); 108 109 _argc = args.size(); 110 _argv = new char *[_argc]; 111 112 // Initialize all the _argvs to NULL so we can delete [] them 113 // unconditionally. 114 for (int idx = 0; idx < _argc; idx++) 115 _argv[idx] = NULL; 116 117 // Attempt to convert all the arguments to strings. If that fails, clean 118 // up after ourselves. Also don't count this as a call to sc_main since 119 // we never got to the c++ version of that function. 120 try { 121 for (int idx = 0; idx < _argc; idx++) { 122 std::string arg = args[idx].cast<std::string>(); 123 _argv[idx] = new char[arg.length() + 1]; 124 strcpy(_argv[idx], arg.c_str()); 125 } 126 } catch (...) { 127 // If that didn't work for some reason (probably a conversion error) 128 // blow away _argv and _argc and pass on the exception. 129 for (int idx = 0; idx < _argc; idx++) 130 delete [] _argv[idx]; 131 delete [] _argv; 132 _argc = 0; 133 throw; 134 } 135 136 // At this point we're going to call the c++ sc_main, so we can't try 137 // again later. 138 scMainCalled = true; 139 140 scMainFiber.run(); 141} 142 143int 144sc_main_result_code() 145{ 146 return scMainFiber.resultInt; 147} 148 149std::string 150sc_main_result_str() 151{ 152 return scMainFiber.resultStr; 153} 154 155// Make our sc_main wrapper available in the internal _m5 python module under 156// the systemc submodule. 157 158struct InstallScMain : public ::sc_gem5::PythonInitFunc 159{ 160 void 161 run(pybind11::module &systemc) override 162 { 163 systemc.def("sc_main", &sc_main); 164 systemc.def("sc_main_result_code", &sc_main_result_code); 165 systemc.def("sc_main_result_str", &sc_main_result_str); 166 } 167} installScMain; 168 169sc_stop_mode _stop_mode = SC_STOP_FINISH_DELTA; 170 171} // anonymous namespace 172 173int 174sc_argc() 175{ 176 return _argc; 177} 178 179const char *const * 180sc_argv() 181{ 182 return _argv; 183} 184 185void 186sc_start() 187{ 188 Tick now = ::sc_gem5::scheduler.getCurTick(); 189 sc_start(sc_time::from_value(MaxTick - now), SC_EXIT_ON_STARVATION); 190} 191 192void 193sc_pause() 194{ 195 if (::sc_gem5::Kernel::status() == SC_RUNNING) 196 ::sc_gem5::scheduler.schedulePause(); 197} 198 199void 200sc_start(const sc_time &time, sc_starvation_policy p) 201{ 202 if (time.value() == 0) { 203 ::sc_gem5::scheduler.oneCycle(); 204 } else { 205 Tick now = ::sc_gem5::scheduler.getCurTick(); 206 if (MaxTick - now < time.value()) { 207 SC_REPORT_ERROR("(E544) simulation time value overflow, " 208 "simulation aborted", ""); 209 } 210 ::sc_gem5::scheduler.start(now + time.value(), p == SC_RUN_TO_TIME); 211 } 212} 213 214void 215sc_set_stop_mode(sc_stop_mode mode) 216{ 217 if (sc_is_running()) { 218 SC_REPORT_ERROR("attempt to set sc_stop mode " 219 "after start will be ignored", ""); 220 return; 221 } 222 _stop_mode = mode; 223} 224 225sc_stop_mode 226sc_get_stop_mode() 227{ 228 return _stop_mode; 229} 230 231void 232sc_stop() 233{ 234 static bool stop_called = false; 235 if (stop_called) { 236 static bool stop_warned = false; 237 if (!stop_warned) 238 SC_REPORT_WARNING("(W545) sc_stop has already been called", ""); 239 stop_warned = true; 240 return; 241 } 242 stop_called = true; 243 244 if (::sc_gem5::Kernel::status() == SC_STOPPED) 245 return; 246 247 if ((sc_get_status() & SC_RUNNING)) { 248 bool finish_delta = (_stop_mode == SC_STOP_FINISH_DELTA); 249 ::sc_gem5::scheduler.scheduleStop(finish_delta); 250 } else { 251 ::sc_gem5::Kernel::stop(); 252 } 253} 254 255const sc_time & 256sc_time_stamp() 257{ 258 static sc_time tstamp(1.0, SC_SEC); 259 tstamp = sc_time::from_value(::sc_gem5::scheduler.getCurTick()); 260 return tstamp; 261} 262 263sc_dt::uint64 264sc_delta_count() 265{ 266 return sc_gem5::scheduler.numCycles(); 267} 268 269bool 270sc_is_running() 271{ 272 return sc_get_status() & (SC_RUNNING | SC_PAUSED); 273} 274 275bool 276sc_pending_activity_at_current_time() 277{ 278 return ::sc_gem5::scheduler.pendingCurr(); 279} 280 281bool 282sc_pending_activity_at_future_time() 283{ 284 return ::sc_gem5::scheduler.pendingFuture(); 285} 286 287bool 288sc_pending_activity() 289{ 290 return sc_pending_activity_at_current_time() || 291 sc_pending_activity_at_future_time(); 292} 293 294sc_time 295sc_time_to_pending_activity() 296{ 297 return sc_time::from_value(::sc_gem5::scheduler.timeToPending()); 298} 299 300sc_status 301sc_get_status() 302{ 303 return ::sc_gem5::kernel ? ::sc_gem5::kernel->status() : SC_ELABORATION; 304} 305 306std::ostream & 307operator << (std::ostream &os, sc_status s) 308{ 309 switch (s) { 310 case SC_ELABORATION: 311 os << "SC_ELABORATION"; 312 break; 313 case SC_BEFORE_END_OF_ELABORATION: 314 os << "SC_BEFORE_END_OF_ELABORATION"; 315 break; 316 case SC_END_OF_ELABORATION: 317 os << "SC_END_OF_ELABORATION"; 318 break; 319 case SC_START_OF_SIMULATION: 320 os << "SC_START_OF_SIMULATION"; 321 break; 322 case SC_RUNNING: 323 os << "SC_RUNNING"; 324 break; 325 case SC_PAUSED: 326 os << "SC_PAUSED"; 327 break; 328 case SC_STOPPED: 329 os << "SC_STOPPED"; 330 break; 331 case SC_END_OF_SIMULATION: 332 os << "SC_END_OF_SIMULATION"; 333 break; 334 335 // Nonstandard 336 case SC_END_OF_INITIALIZATION: 337 os << "SC_END_OF_INITIALIZATION"; 338 break; 339 case SC_END_OF_UPDATE: 340 os << "SC_END_OF_UPDATE"; 341 break; 342 case SC_BEFORE_TIMESTEP: 343 os << "SC_BEFORE_TIMESTEP"; 344 break; 345 346 default: 347 if (s & SC_STATUS_ANY) { 348 const char *prefix = "("; 349 for (sc_status m = (sc_status)0x1; 350 m < SC_STATUS_ANY; m = (sc_status)(m << 1)) { 351 if (m & s) { 352 os << prefix; 353 prefix = "|"; 354 os << m; 355 } 356 } 357 os << ")"; 358 } else { 359 ccprintf(os, "%#x", s); 360 } 361 } 362 363 return os; 364} 365 366} // namespace sc_core 367