sc_main.cc revision 13212:4729f211fbae
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 45// A weak symbol to detect if sc_main has been defined, and if so where it is. 46[[gnu::weak]] int sc_main(int argc, char *argv[]); 47 48namespace sc_core 49{ 50 51namespace 52{ 53 54bool scMainCalled = false; 55 56int _argc = 0; 57char **_argv = NULL; 58 59class ScMainFiber : public Fiber 60{ 61 public: 62 std::string resultStr; 63 int resultInt; 64 65 ScMainFiber() : resultInt(1) {} 66 67 void 68 main() 69 { 70 if (::sc_main) { 71 try { 72 resultInt = ::sc_main(_argc, _argv); 73 if (resultInt) 74 resultStr = "sc_main returned non-zero"; 75 else 76 resultStr = "sc_main finished"; 77 // Make sure no systemc events/notifications are scheduled 78 // after sc_main returns. 79 } catch (const sc_report &r) { 80 // There was an exception nobody caught. 81 resultStr = r.what(); 82 } catch (...) { 83 // There was some other type of exception we need to wrap. 84 const sc_report *r = ::sc_gem5::reportifyException(); 85 resultStr = r->what(); 86 } 87 ::sc_gem5::Kernel::scMainFinished(true); 88 ::sc_gem5::scheduler.clear(); 89 } else { 90 // If python tries to call sc_main but no sc_main was defined... 91 fatal("sc_main called but not defined.\n"); 92 } 93 } 94}; 95 96ScMainFiber scMainFiber; 97 98// This wrapper adapts the python version of sc_main to the c++ version. 99void 100sc_main(pybind11::args args) 101{ 102 panic_if(scMainCalled, "sc_main called more than once."); 103 104 _argc = args.size(); 105 _argv = new char *[_argc]; 106 107 // Initialize all the _argvs to NULL so we can delete [] them 108 // unconditionally. 109 for (int idx = 0; idx < _argc; idx++) 110 _argv[idx] = NULL; 111 112 // Attempt to convert all the arguments to strings. If that fails, clean 113 // up after ourselves. Also don't count this as a call to sc_main since 114 // we never got to the c++ version of that function. 115 try { 116 for (int idx = 0; idx < _argc; idx++) { 117 std::string arg = args[idx].cast<std::string>(); 118 _argv[idx] = new char[arg.length() + 1]; 119 strcpy(_argv[idx], arg.c_str()); 120 } 121 } catch (...) { 122 // If that didn't work for some reason (probably a conversion error) 123 // blow away _argv and _argc and pass on the exception. 124 for (int idx = 0; idx < _argc; idx++) 125 delete [] _argv[idx]; 126 delete [] _argv; 127 _argc = 0; 128 throw; 129 } 130 131 // At this point we're going to call the c++ sc_main, so we can't try 132 // again later. 133 scMainCalled = true; 134 135 scMainFiber.run(); 136} 137 138int 139sc_main_result_code() 140{ 141 return scMainFiber.resultInt; 142} 143 144std::string 145sc_main_result_str() 146{ 147 return scMainFiber.resultStr; 148} 149 150// Make our sc_main wrapper available in the internal _m5 python module under 151// the systemc submodule. 152 153struct InstallScMain : public ::sc_gem5::PythonInitFunc 154{ 155 void 156 run(pybind11::module &systemc) override 157 { 158 systemc.def("sc_main", &sc_main); 159 systemc.def("sc_main_result_code", &sc_main_result_code); 160 systemc.def("sc_main_result_str", &sc_main_result_str); 161 } 162} installScMain; 163 164sc_stop_mode _stop_mode = SC_STOP_FINISH_DELTA; 165 166} // anonymous namespace 167 168int 169sc_argc() 170{ 171 return _argc; 172} 173 174const char *const * 175sc_argv() 176{ 177 return _argv; 178} 179 180void 181sc_start() 182{ 183 Tick now = ::sc_gem5::scheduler.getCurTick(); 184 sc_start(sc_time::from_value(MaxTick - now), SC_EXIT_ON_STARVATION); 185} 186 187void 188sc_pause() 189{ 190 if (::sc_gem5::Kernel::status() == SC_RUNNING) 191 ::sc_gem5::scheduler.schedulePause(); 192} 193 194void 195sc_start(const sc_time &time, sc_starvation_policy p) 196{ 197 if (time.value() == 0) { 198 ::sc_gem5::scheduler.oneCycle(); 199 } else { 200 Tick now = ::sc_gem5::scheduler.getCurTick(); 201 if (MaxTick - now < time.value()) { 202 SC_REPORT_ERROR("(E544) simulation time value overflow, " 203 "simulation aborted", ""); 204 } 205 ::sc_gem5::scheduler.start(now + time.value(), p == SC_RUN_TO_TIME); 206 } 207} 208 209void 210sc_set_stop_mode(sc_stop_mode mode) 211{ 212 if (sc_is_running()) { 213 SC_REPORT_ERROR("attempt to set sc_stop mode " 214 "after start will be ignored", ""); 215 return; 216 } 217 _stop_mode = mode; 218} 219 220sc_stop_mode 221sc_get_stop_mode() 222{ 223 return _stop_mode; 224} 225 226void 227sc_stop() 228{ 229 static bool stop_called = false; 230 if (stop_called) { 231 static bool stop_warned = false; 232 if (!stop_warned) 233 SC_REPORT_WARNING("(W545) sc_stop has already been called", ""); 234 stop_warned = true; 235 return; 236 } 237 stop_called = true; 238 239 if (::sc_gem5::Kernel::status() == SC_STOPPED) 240 return; 241 242 if ((sc_get_status() & SC_RUNNING)) { 243 bool finish_delta = (_stop_mode == SC_STOP_FINISH_DELTA); 244 ::sc_gem5::scheduler.scheduleStop(finish_delta); 245 } else { 246 ::sc_gem5::Kernel::stop(); 247 } 248} 249 250const sc_time & 251sc_time_stamp() 252{ 253 static sc_time tstamp; 254 Tick tick = ::sc_gem5::scheduler.getCurTick(); 255 //XXX We're assuming the systemc time resolution is in ps. 256 // If tick is zero, the time scale may not be fixed yet, and 257 // SimClock::Int::ps may be zero. 258 tstamp = sc_time::from_value(tick ? tick / SimClock::Int::ps : 0); 259 return tstamp; 260} 261 262sc_dt::uint64 263sc_delta_count() 264{ 265 return sc_gem5::scheduler.numCycles(); 266} 267 268bool 269sc_is_running() 270{ 271 return sc_get_status() & (SC_RUNNING | SC_PAUSED); 272} 273 274bool 275sc_pending_activity_at_current_time() 276{ 277 return ::sc_gem5::scheduler.pendingCurr(); 278} 279 280bool 281sc_pending_activity_at_future_time() 282{ 283 return ::sc_gem5::scheduler.pendingFuture(); 284} 285 286bool 287sc_pending_activity() 288{ 289 return sc_pending_activity_at_current_time() || 290 sc_pending_activity_at_future_time(); 291} 292 293sc_time 294sc_time_to_pending_activity() 295{ 296 return sc_time::from_value(::sc_gem5::scheduler.timeToPending()); 297} 298 299sc_status 300sc_get_status() 301{ 302 return ::sc_gem5::kernel ? ::sc_gem5::kernel->status() : SC_ELABORATION; 303} 304 305std::ostream & 306operator << (std::ostream &os, sc_status s) 307{ 308 switch (s) { 309 case SC_ELABORATION: 310 os << "SC_ELABORATION"; 311 break; 312 case SC_BEFORE_END_OF_ELABORATION: 313 os << "SC_BEFORE_END_OF_ELABORATION"; 314 break; 315 case SC_END_OF_ELABORATION: 316 os << "SC_END_OF_ELABORATION"; 317 break; 318 case SC_START_OF_SIMULATION: 319 os << "SC_START_OF_SIMULATION"; 320 break; 321 case SC_RUNNING: 322 os << "SC_RUNNING"; 323 break; 324 case SC_PAUSED: 325 os << "SC_PAUSED"; 326 break; 327 case SC_STOPPED: 328 os << "SC_STOPPED"; 329 break; 330 case SC_END_OF_SIMULATION: 331 os << "SC_END_OF_SIMULATION"; 332 break; 333 334 // Nonstandard 335 case SC_END_OF_INITIALIZATION: 336 os << "SC_END_OF_INITIALIZATION"; 337 break; 338 case SC_END_OF_UPDATE: 339 os << "SC_END_OF_UPDATE"; 340 break; 341 case SC_BEFORE_TIMESTEP: 342 os << "SC_BEFORE_TIMESTEP"; 343 break; 344 345 default: 346 if (s & SC_STATUS_ANY) { 347 const char *prefix = "("; 348 for (sc_status m = (sc_status)0x1; 349 m < SC_STATUS_ANY; m = (sc_status)(m << 1)) { 350 if (m & s) { 351 os << prefix; 352 prefix = "|"; 353 os << m; 354 } 355 } 356 os << ")"; 357 } else { 358 ccprintf(os, "%#x", s); 359 } 360 } 361 362 return os; 363} 364 365} // namespace sc_core 366