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