sc_event.cc revision 13299:6bde86615f6f
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 "base/logging.hh" 31#include "systemc/core/event.hh" 32#include "systemc/ext/core/sc_event.hh" 33#include "systemc/ext/core/sc_module.hh" 34 35namespace sc_core 36{ 37 38 39/* 40 * sc_event_and_list 41 */ 42 43sc_event_and_list::sc_event_and_list() : autoDelete(false), busy(0) {} 44 45sc_event_and_list::sc_event_and_list(const sc_event_and_list &eal) : 46 events(eal.events), autoDelete(false), busy(0) 47{} 48 49sc_event_and_list::sc_event_and_list(const sc_event &e) : sc_event_and_list() 50{ 51 insert(e); 52} 53 54sc_event_and_list::sc_event_and_list(bool auto_delete) : 55 autoDelete(auto_delete), busy(0) 56{} 57 58sc_event_and_list::~sc_event_and_list() {} 59 60sc_event_and_list & 61sc_event_and_list::operator = (const sc_event_and_list &eal) 62{ 63 events = eal.events; 64 return *this; 65} 66 67int 68sc_event_and_list::size() const 69{ 70 return events.size(); 71} 72 73void 74sc_event_and_list::swap(sc_event_and_list &eal) 75{ 76 events.swap(eal.events); 77} 78 79sc_event_and_list & 80sc_event_and_list::operator &= (const sc_event &e) 81{ 82 insert(e); 83 return *this; 84} 85 86sc_event_and_list & 87sc_event_and_list::operator &= (const sc_event_and_list &eal) 88{ 89 insert(eal); 90 return *this; 91} 92 93sc_event_and_expr 94sc_event_and_list::operator & (const sc_event &e) const 95{ 96 sc_event_and_expr expr; 97 expr.insert(*this); 98 expr.insert(e); 99 return expr; 100} 101 102sc_event_and_expr 103sc_event_and_list::operator & (const sc_event_and_list &eal) 104{ 105 sc_event_and_expr expr; 106 expr.insert(*this); 107 expr.insert(eal); 108 return expr; 109} 110 111void 112sc_event_and_list::insert(sc_event const &e) 113{ 114 events.insert(&e); 115} 116 117void 118sc_event_and_list::insert(sc_event_and_list const &eal) 119{ 120 events.insert(eal.events.begin(), eal.events.end()); 121} 122 123 124/* 125 * sc_event_or_list 126 */ 127 128sc_event_or_list::sc_event_or_list() : autoDelete(false), busy(0) {} 129 130sc_event_or_list::sc_event_or_list(const sc_event_or_list &eol) : 131 events(eol.events), autoDelete(false), busy(0) 132{} 133 134sc_event_or_list::sc_event_or_list(const sc_event &e) : sc_event_or_list() 135{ 136 insert(e); 137} 138 139sc_event_or_list::sc_event_or_list(bool auto_delete) : 140 autoDelete(auto_delete), busy(0) 141{} 142 143sc_event_or_list & 144sc_event_or_list::operator = (const sc_event_or_list &eol) 145{ 146 events = eol.events; 147 return *this; 148} 149 150sc_event_or_list::~sc_event_or_list() {} 151 152int 153sc_event_or_list::size() const 154{ 155 return events.size(); 156} 157 158void 159sc_event_or_list::swap(sc_event_or_list &eol) 160{ 161 events.swap(eol.events); 162} 163 164sc_event_or_list & 165sc_event_or_list::operator |= (const sc_event &e) 166{ 167 insert(e); 168 return *this; 169} 170 171sc_event_or_list & 172sc_event_or_list::operator |= (const sc_event_or_list &eol) 173{ 174 insert(eol); 175 return *this; 176} 177 178sc_event_or_expr 179sc_event_or_list::operator | (const sc_event &e) const 180{ 181 sc_event_or_expr expr; 182 expr.insert(*this); 183 expr.insert(e); 184 return expr; 185} 186 187sc_event_or_expr 188sc_event_or_list::operator | (const sc_event_or_list &eol) const 189{ 190 sc_event_or_expr expr; 191 expr.insert(*this); 192 expr.insert(eol); 193 return expr; 194} 195 196void 197sc_event_or_list::insert(sc_event const &e) 198{ 199 events.insert(&e); 200} 201 202void 203sc_event_or_list::insert(sc_event_or_list const &eol) 204{ 205 events.insert(eol.events.begin(), eol.events.end()); 206} 207 208 209/* 210 * sc_event_and_expr 211 */ 212 213// Move semantics 214sc_event_and_expr::sc_event_and_expr(sc_event_and_expr const &e) : 215 list(e.list) 216{ 217 e.list = nullptr; 218} 219 220sc_event_and_expr::operator const sc_event_and_list &() const 221{ 222 sc_event_and_list *temp = list; 223 list = nullptr; 224 return *temp; 225} 226 227void 228sc_event_and_expr::insert(sc_event const &e) const 229{ 230 assert(list); 231 list->insert(e); 232} 233 234void 235sc_event_and_expr::insert(sc_event_and_list const &eal) const 236{ 237 assert(list); 238 list->insert(eal); 239} 240 241sc_event_and_expr::~sc_event_and_expr() { delete list; } 242 243sc_event_and_expr::sc_event_and_expr() : list(new sc_event_and_list(true)) {} 244 245sc_event_and_expr 246operator & (sc_event_and_expr expr, sc_event const &e) 247{ 248 expr.insert(e); 249 return expr; 250} 251 252sc_event_and_expr 253operator & (sc_event_and_expr expr, sc_event_and_list const &eal) 254{ 255 expr.insert(eal); 256 return expr; 257} 258 259 260/* 261 * sc_event_or_expr 262 */ 263 264// Move semantics 265sc_event_or_expr::sc_event_or_expr(sc_event_or_expr const &e) : 266 list(e.list) 267{ 268 e.list = nullptr; 269} 270 271sc_event_or_expr::operator const sc_event_or_list &() const 272{ 273 sc_event_or_list *temp = list; 274 list = NULL; 275 return *temp; 276} 277 278void 279sc_event_or_expr::insert(sc_event const &e) const 280{ 281 assert(list); 282 list->insert(e); 283} 284 285void 286sc_event_or_expr::insert(sc_event_or_list const &eol) const 287{ 288 assert(list); 289 list->insert(eol); 290} 291 292sc_event_or_expr::~sc_event_or_expr() { delete list; } 293 294sc_event_or_expr::sc_event_or_expr() : list(new sc_event_or_list(true)) {} 295 296sc_event_or_expr 297operator | (sc_event_or_expr expr, sc_event const &e) 298{ 299 expr.insert(e); 300 return expr; 301} 302 303sc_event_or_expr 304operator | (sc_event_or_expr expr, sc_event_or_list const &eol) 305{ 306 expr.insert(eol); 307 return expr; 308} 309 310 311/* 312 * sc_event 313 */ 314 315sc_event::sc_event() : 316 _gem5_event(new ::sc_gem5::Event( 317 this, sc_core::sc_gen_unique_name("event"))) 318{} 319 320sc_event::sc_event(const char *_name) : 321 _gem5_event(new ::sc_gem5::Event(this, _name)) 322{} 323 324sc_event::~sc_event() { delete _gem5_event; } 325 326const char *sc_event::name() const { return _gem5_event->name().c_str(); } 327const char * 328sc_event::basename() const 329{ 330 return _gem5_event->basename().c_str(); 331} 332bool sc_event::in_hierarchy() const { return _gem5_event->inHierarchy(); } 333 334sc_object * 335sc_event::get_parent_object() const 336{ 337 return _gem5_event->getParentObject(); 338} 339 340void sc_event::notify() { _gem5_event->notify(); } 341void sc_event::notify(const sc_time &t) { _gem5_event->notify(t); } 342void sc_event::notify(double d, sc_time_unit u) { _gem5_event->notify(d, u); } 343void sc_event::cancel() { _gem5_event->cancel(); } 344bool sc_event::triggered() const { return _gem5_event->triggered(); } 345void 346sc_event::notify_delayed() 347{ 348 _gem5_event->notifyDelayed(SC_ZERO_TIME); 349} 350void 351sc_event::notify_delayed(const sc_time &t) 352{ 353 _gem5_event->notifyDelayed(t); 354} 355 356sc_event_and_expr 357sc_event::operator & (const sc_event &e) const 358{ 359 sc_event_and_expr expr; 360 expr.insert(*this); 361 expr.insert(e); 362 return expr; 363} 364 365sc_event_and_expr 366sc_event::operator & (const sc_event_and_list &eal) const 367{ 368 sc_event_and_expr expr; 369 expr.insert(*this); 370 expr.insert(eal); 371 return expr; 372} 373 374sc_event_or_expr 375sc_event::operator | (const sc_event &e) const 376{ 377 sc_event_or_expr expr; 378 expr.insert(*this); 379 expr.insert(e); 380 return expr; 381} 382 383sc_event_or_expr 384sc_event::operator | (const sc_event_or_list &eol) const 385{ 386 sc_event_or_expr expr; 387 expr.insert(*this); 388 expr.insert(eol); 389 return expr; 390} 391 392const std::vector<sc_event *> & 393sc_get_top_level_events() 394{ 395 return ::sc_gem5::topLevelEvents; 396} 397 398sc_event * 399sc_find_event(const char *name) 400{ 401 std::string str(name); 402 ::sc_gem5::EventsIt it = ::sc_gem5::findEvent(str); 403 return it == ::sc_gem5::allEvents.end() ? nullptr : *it; 404} 405 406} // namespace sc_core 407