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#ifndef __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
31#define __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
32
33#include <iostream>
| 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#ifndef __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
31#define __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
32
33#include <iostream>
|
| 34#include <sstream>
|
34#include <string>
35#include <vector>
36
37#include "../core/sc_event.hh"
38#include "../core/sc_module.hh" // for sc_gen_unique_name
39#include "../core/sc_prim.hh"
40#include "../dt/bit/sc_logic.hh"
41#include "sc_signal_inout_if.hh"
| 35#include <string>
36#include <vector>
37
38#include "../core/sc_event.hh"
39#include "../core/sc_module.hh" // for sc_gen_unique_name
40#include "../core/sc_prim.hh"
41#include "../dt/bit/sc_logic.hh"
42#include "sc_signal_inout_if.hh"
|
42#include "warn_unimpl.hh" // for warn_unimpl
| |
43
44namespace sc_core
45{
46
47class sc_port_base;
48
49template <class T, sc_writer_policy WRITER_POLICY=SC_ONE_WRITER>
50class sc_signal : public sc_signal_inout_if<T>,
51 public sc_prim_channel
52{
53 public:
54 sc_signal() : sc_signal_inout_if<T>(),
55 sc_prim_channel(sc_gen_unique_name("signal")),
| 43
44namespace sc_core
45{
46
47class sc_port_base;
48
49template <class T, sc_writer_policy WRITER_POLICY=SC_ONE_WRITER>
50class sc_signal : public sc_signal_inout_if<T>,
51 public sc_prim_channel
52{
53 public:
54 sc_signal() : sc_signal_inout_if<T>(),
55 sc_prim_channel(sc_gen_unique_name("signal")),
|
56 m_cur_val(T()), m_new_val(T()), _changeStamp(~0ULL)
| 56 m_cur_val(T()), m_new_val(T()), _changeStamp(~0ULL),
57 _gem5Writer(NULL)
|
57 {}
58 explicit sc_signal(const char *name) :
59 sc_signal_inout_if<T>(), sc_prim_channel(name),
| 58 {}
59 explicit sc_signal(const char *name) :
60 sc_signal_inout_if<T>(), sc_prim_channel(name),
|
60 m_cur_val(T()), m_new_val(T()), _changeStamp(~0ULL)
| 61 m_cur_val(T()), m_new_val(T()), _changeStamp(~0ULL),
62 _gem5Writer(NULL)
|
61 {}
62 explicit sc_signal(const char *name, const T &initial_value) :
63 sc_signal_inout_if<T>(), sc_prim_channel(name),
| 63 {}
64 explicit sc_signal(const char *name, const T &initial_value) :
65 sc_signal_inout_if<T>(), sc_prim_channel(name),
|
64 m_cur_val(initial_value), m_new_val(initial_value), _changeStamp(~0ULL)
| 66 m_cur_val(initial_value), m_new_val(initial_value),
67 _changeStamp(~0ULL), _gem5Writer(NULL)
|
65 {}
66 virtual ~sc_signal() {}
67
68 virtual void
| 68 {}
69 virtual ~sc_signal() {}
70
71 virtual void
|
69 register_port(sc_port_base &, const char *)
| 72 register_port(sc_port_base &port, const char *iface_type_name)
|
70 {
| 73 {
|
71 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
| 74 if (WRITER_POLICY == SC_ONE_WRITER &&
75 std::string(iface_type_name) ==
76 typeid(sc_signal_inout_if<T>).name()) {
77 if (_gem5Writer) {
78 std::ostringstream ss;
79 ss << "\n signal " << "`" << name() << "' (" <<
80 kind() << ")";
81 ss << "\n first driver `" << _gem5Writer->name() << "' (" <<
82 _gem5Writer->kind() << ")";
83 ss << "\n second driver `" << port.name() << "' (" <<
84 port.kind() << ")";
85 SC_REPORT_ERROR(
86 "(E115) sc_signal<T> cannot have more than one driver",
87 ss.str().c_str());
88 }
89 _gem5Writer = &port;
90 }
|
72 }
73
74 virtual const T &read() const { return m_cur_val; }
75 operator const T&() const { return read(); }
76
77 virtual sc_writer_policy
78 get_writer_policy() const
79 {
80 return WRITER_POLICY;
81 }
82 virtual void
83 write(const T &t)
84 {
85 m_new_val = t;
86 bool changed = !(m_cur_val == m_new_val);
87 //TODO check whether this write follows the write policy.
88 if (changed)
89 request_update();
90 }
91 sc_signal<T, WRITER_POLICY> &
92 operator = (const T &t)
93 {
94 write(t);
95 return *this;
96 }
97 sc_signal<T, WRITER_POLICY> &
98 operator = (const sc_signal<T, WRITER_POLICY> &s)
99 {
100 write(s.read());
101 return *this;
102 }
103
104 virtual const sc_event &
105 default_event() const
106 {
107 return value_changed_event();
108 }
109 virtual const sc_event &
110 value_changed_event() const
111 {
112 return _valueChangedEvent;
113 }
114 virtual bool
115 event() const
116 {
117 return _changeStamp == ::sc_gem5::getChangeStamp();
118 }
119
120 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
121 virtual void
122 dump(std::ostream &os=std::cout) const
123 {
124 os << " name = " << name() << ::std::endl;
125 os << " value = " << m_cur_val << ::std::endl;
126 os << "new value = " << m_new_val << ::std::endl;
127 }
128 virtual const char *kind() const { return "sc_signal"; }
129
130 protected:
131 virtual void
132 update()
133 {
134 if (m_new_val == m_cur_val)
135 return;
136
137 m_cur_val = m_new_val;
138 _signalChange();
139 _changeStamp = ::sc_gem5::getChangeStamp();
140 _valueChangedEvent.notify(SC_ZERO_TIME);
141 }
142
143 void
144 _signalChange()
145 {
146 _changeStamp = ::sc_gem5::getChangeStamp();
147 _valueChangedEvent.notify(SC_ZERO_TIME);
148 }
149
150 // These members which store the current and future value of the signal
151 // are not specified in the standard but are referred to directly by one
152 // of the tests.
153 T m_cur_val;
154 T m_new_val;
155
156 private:
157 sc_event _valueChangedEvent;
158 uint64_t _changeStamp;
| 91 }
92
93 virtual const T &read() const { return m_cur_val; }
94 operator const T&() const { return read(); }
95
96 virtual sc_writer_policy
97 get_writer_policy() const
98 {
99 return WRITER_POLICY;
100 }
101 virtual void
102 write(const T &t)
103 {
104 m_new_val = t;
105 bool changed = !(m_cur_val == m_new_val);
106 //TODO check whether this write follows the write policy.
107 if (changed)
108 request_update();
109 }
110 sc_signal<T, WRITER_POLICY> &
111 operator = (const T &t)
112 {
113 write(t);
114 return *this;
115 }
116 sc_signal<T, WRITER_POLICY> &
117 operator = (const sc_signal<T, WRITER_POLICY> &s)
118 {
119 write(s.read());
120 return *this;
121 }
122
123 virtual const sc_event &
124 default_event() const
125 {
126 return value_changed_event();
127 }
128 virtual const sc_event &
129 value_changed_event() const
130 {
131 return _valueChangedEvent;
132 }
133 virtual bool
134 event() const
135 {
136 return _changeStamp == ::sc_gem5::getChangeStamp();
137 }
138
139 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
140 virtual void
141 dump(std::ostream &os=std::cout) const
142 {
143 os << " name = " << name() << ::std::endl;
144 os << " value = " << m_cur_val << ::std::endl;
145 os << "new value = " << m_new_val << ::std::endl;
146 }
147 virtual const char *kind() const { return "sc_signal"; }
148
149 protected:
150 virtual void
151 update()
152 {
153 if (m_new_val == m_cur_val)
154 return;
155
156 m_cur_val = m_new_val;
157 _signalChange();
158 _changeStamp = ::sc_gem5::getChangeStamp();
159 _valueChangedEvent.notify(SC_ZERO_TIME);
160 }
161
162 void
163 _signalChange()
164 {
165 _changeStamp = ::sc_gem5::getChangeStamp();
166 _valueChangedEvent.notify(SC_ZERO_TIME);
167 }
168
169 // These members which store the current and future value of the signal
170 // are not specified in the standard but are referred to directly by one
171 // of the tests.
172 T m_cur_val;
173 T m_new_val;
174
175 private:
176 sc_event _valueChangedEvent;
177 uint64_t _changeStamp;
|
| 178 sc_port_base *_gem5Writer;
|
159
160 // Disabled
161 sc_signal(const sc_signal<T, WRITER_POLICY> &) :
162 sc_signal_inout_if<T>(), sc_prim_channel("")
163 {}
164};
165
166template <class T, sc_writer_policy WRITER_POLICY>
167inline std::ostream &
168operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &s)
169{
170 os << s.read();
171 return os;
172}
173
174template <sc_writer_policy WRITER_POLICY>
175class sc_signal<bool, WRITER_POLICY> :
176 public sc_signal_inout_if<bool>, public sc_prim_channel
177{
178 public:
179 sc_signal() : sc_signal_inout_if<bool>(),
180 sc_prim_channel(sc_gen_unique_name("signal")),
181 m_cur_val(bool()), m_new_val(bool()),
| 179
180 // Disabled
181 sc_signal(const sc_signal<T, WRITER_POLICY> &) :
182 sc_signal_inout_if<T>(), sc_prim_channel("")
183 {}
184};
185
186template <class T, sc_writer_policy WRITER_POLICY>
187inline std::ostream &
188operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &s)
189{
190 os << s.read();
191 return os;
192}
193
194template <sc_writer_policy WRITER_POLICY>
195class sc_signal<bool, WRITER_POLICY> :
196 public sc_signal_inout_if<bool>, public sc_prim_channel
197{
198 public:
199 sc_signal() : sc_signal_inout_if<bool>(),
200 sc_prim_channel(sc_gen_unique_name("signal")),
201 m_cur_val(bool()), m_new_val(bool()),
|
182 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL)
| 202 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL),
203 _gem5Writer(NULL)
|
183 {}
184 explicit sc_signal(const char *name) :
185 sc_signal_inout_if<bool>(), sc_prim_channel(name),
186 m_cur_val(bool()), m_new_val(bool()),
| 204 {}
205 explicit sc_signal(const char *name) :
206 sc_signal_inout_if<bool>(), sc_prim_channel(name),
207 m_cur_val(bool()), m_new_val(bool()),
|
187 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL)
| 208 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL),
209 _gem5Writer(NULL)
|
188 {}
189 explicit sc_signal(const char *name, const bool &initial_value) :
190 sc_signal_inout_if<bool>(), sc_prim_channel(name),
191 m_cur_val(initial_value), m_new_val(initial_value),
| 210 {}
211 explicit sc_signal(const char *name, const bool &initial_value) :
212 sc_signal_inout_if<bool>(), sc_prim_channel(name),
213 m_cur_val(initial_value), m_new_val(initial_value),
|
192 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL)
| 214 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL),
215 _gem5Writer(NULL)
|
193 {}
194 virtual ~sc_signal() {}
195
196 virtual void
| 216 {}
217 virtual ~sc_signal() {}
218
219 virtual void
|
197 register_port(sc_port_base &, const char *)
| 220 register_port(sc_port_base &port, const char *iface_type_name)
|
198 {
| 221 {
|
199 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
| 222 if (WRITER_POLICY == SC_ONE_WRITER &&
223 std::string(iface_type_name) ==
224 typeid(sc_signal_inout_if<bool>).name()) {
225 if (_gem5Writer) {
226 std::ostringstream ss;
227 ss << "\n signal " << "`" << name() << "' (" <<
228 kind() << ")";
229 ss << "\n first driver `" << _gem5Writer->name() << "' (" <<
230 _gem5Writer->kind() << ")";
231 ss << "\n second driver `" << port.name() << "' (" <<
232 port.kind() << ")";
233 SC_REPORT_ERROR(
234 "(E115) sc_signal<T> cannot have more than one driver",
235 ss.str().c_str());
236 }
237 _gem5Writer = &port;
238 }
|
200 }
201
202 virtual const bool &read() const { return m_cur_val; }
203 operator const bool &() const { return read(); }
204
205 virtual sc_writer_policy
206 get_writer_policy() const
207 {
208 return WRITER_POLICY;
209 }
210 virtual void
211 write(const bool &b)
212 {
213 m_new_val = b;
214 bool changed = !(m_cur_val == m_new_val);
215 //TODO check whether this write follows the write policy.
216 if (changed)
217 request_update();
218 }
219 sc_signal<bool, WRITER_POLICY> &
220 operator = (const bool &b)
221 {
222 write(b);
223 return *this;
224 }
225 sc_signal<bool, WRITER_POLICY> &
226 operator = (const sc_signal<bool, WRITER_POLICY> &s)
227 {
228 write(s.read());
229 return *this;
230 }
231
232 virtual const sc_event &
233 default_event() const
234 {
235 return value_changed_event();
236 }
237
238 virtual const sc_event &
239 value_changed_event() const
240 {
241 return _valueChangedEvent;
242 }
243 virtual const sc_event &
244 posedge_event() const
245 {
246 return _posedgeEvent;
247 }
248 virtual const sc_event &
249 negedge_event() const
250 {
251 return _negedgeEvent;
252 }
253
254 virtual bool
255 event() const
256 {
257 return _changeStamp == ::sc_gem5::getChangeStamp();
258 }
259 virtual bool
260 posedge() const
261 {
262 return _posStamp == ::sc_gem5::getChangeStamp();
263 }
264 virtual bool
265 negedge() const
266 {
267 return _negStamp == ::sc_gem5::getChangeStamp();
268 }
269
270 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
271 virtual void
272 dump(std::ostream &os=std::cout) const
273 {
274 os << " name = " << name() << ::std::endl;
275 os << " value = " << m_cur_val << ::std::endl;
276 os << "new value = " << m_new_val << ::std::endl;
277 }
278 virtual const char *kind() const { return "sc_signal"; }
279
280 protected:
281 virtual void
282 update()
283 {
284 if (m_new_val == m_cur_val)
285 return;
286
287 m_cur_val = m_new_val;
288 _signalChange();
289 if (m_cur_val) {
290 _posStamp = ::sc_gem5::getChangeStamp();
291 _posedgeEvent.notify(SC_ZERO_TIME);
292 } else {
293 _negStamp = ::sc_gem5::getChangeStamp();
294 _negedgeEvent.notify(SC_ZERO_TIME);
295 }
296 }
297
298 void
299 _signalChange()
300 {
301 _changeStamp = ::sc_gem5::getChangeStamp();
302 _valueChangedEvent.notify(SC_ZERO_TIME);
303 }
304
305 bool m_cur_val;
306 bool m_new_val;
307
308 private:
309 sc_event _valueChangedEvent;
310 sc_event _posedgeEvent;
311 sc_event _negedgeEvent;
312
313 uint64_t _changeStamp;
314 uint64_t _posStamp;
315 uint64_t _negStamp;
316
| 239 }
240
241 virtual const bool &read() const { return m_cur_val; }
242 operator const bool &() const { return read(); }
243
244 virtual sc_writer_policy
245 get_writer_policy() const
246 {
247 return WRITER_POLICY;
248 }
249 virtual void
250 write(const bool &b)
251 {
252 m_new_val = b;
253 bool changed = !(m_cur_val == m_new_val);
254 //TODO check whether this write follows the write policy.
255 if (changed)
256 request_update();
257 }
258 sc_signal<bool, WRITER_POLICY> &
259 operator = (const bool &b)
260 {
261 write(b);
262 return *this;
263 }
264 sc_signal<bool, WRITER_POLICY> &
265 operator = (const sc_signal<bool, WRITER_POLICY> &s)
266 {
267 write(s.read());
268 return *this;
269 }
270
271 virtual const sc_event &
272 default_event() const
273 {
274 return value_changed_event();
275 }
276
277 virtual const sc_event &
278 value_changed_event() const
279 {
280 return _valueChangedEvent;
281 }
282 virtual const sc_event &
283 posedge_event() const
284 {
285 return _posedgeEvent;
286 }
287 virtual const sc_event &
288 negedge_event() const
289 {
290 return _negedgeEvent;
291 }
292
293 virtual bool
294 event() const
295 {
296 return _changeStamp == ::sc_gem5::getChangeStamp();
297 }
298 virtual bool
299 posedge() const
300 {
301 return _posStamp == ::sc_gem5::getChangeStamp();
302 }
303 virtual bool
304 negedge() const
305 {
306 return _negStamp == ::sc_gem5::getChangeStamp();
307 }
308
309 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
310 virtual void
311 dump(std::ostream &os=std::cout) const
312 {
313 os << " name = " << name() << ::std::endl;
314 os << " value = " << m_cur_val << ::std::endl;
315 os << "new value = " << m_new_val << ::std::endl;
316 }
317 virtual const char *kind() const { return "sc_signal"; }
318
319 protected:
320 virtual void
321 update()
322 {
323 if (m_new_val == m_cur_val)
324 return;
325
326 m_cur_val = m_new_val;
327 _signalChange();
328 if (m_cur_val) {
329 _posStamp = ::sc_gem5::getChangeStamp();
330 _posedgeEvent.notify(SC_ZERO_TIME);
331 } else {
332 _negStamp = ::sc_gem5::getChangeStamp();
333 _negedgeEvent.notify(SC_ZERO_TIME);
334 }
335 }
336
337 void
338 _signalChange()
339 {
340 _changeStamp = ::sc_gem5::getChangeStamp();
341 _valueChangedEvent.notify(SC_ZERO_TIME);
342 }
343
344 bool m_cur_val;
345 bool m_new_val;
346
347 private:
348 sc_event _valueChangedEvent;
349 sc_event _posedgeEvent;
350 sc_event _negedgeEvent;
351
352 uint64_t _changeStamp;
353 uint64_t _posStamp;
354 uint64_t _negStamp;
355
|
| 356 sc_port_base *_gem5Writer;
357
|
317 // Disabled
318 sc_signal(const sc_signal<bool, WRITER_POLICY> &) :
319 sc_signal_inout_if<bool>(), sc_prim_channel("")
320 {}
321};
322
323template <sc_writer_policy WRITER_POLICY>
324class sc_signal<sc_dt::sc_logic, WRITER_POLICY> :
325 public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel
326{
327 public:
328 sc_signal() : sc_signal_inout_if<sc_dt::sc_logic>(),
329 sc_prim_channel(sc_gen_unique_name("signal")),
330 m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic()),
| 358 // Disabled
359 sc_signal(const sc_signal<bool, WRITER_POLICY> &) :
360 sc_signal_inout_if<bool>(), sc_prim_channel("")
361 {}
362};
363
364template <sc_writer_policy WRITER_POLICY>
365class sc_signal<sc_dt::sc_logic, WRITER_POLICY> :
366 public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel
367{
368 public:
369 sc_signal() : sc_signal_inout_if<sc_dt::sc_logic>(),
370 sc_prim_channel(sc_gen_unique_name("signal")),
371 m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic()),
|
331 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL)
| 372 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL),
373 _gem5Writer(NULL)
|
332 {}
333 explicit sc_signal(const char *name) :
334 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name),
335 m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic()),
| 374 {}
375 explicit sc_signal(const char *name) :
376 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name),
377 m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic()),
|
336 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL)
| 378 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL),
379 _gem5Writer(NULL)
|
337 {}
338 explicit sc_signal(const char *name,
339 const sc_dt::sc_logic &initial_value) :
340 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name),
341 m_cur_val(initial_value), m_new_val(initial_value),
| 380 {}
381 explicit sc_signal(const char *name,
382 const sc_dt::sc_logic &initial_value) :
383 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name),
384 m_cur_val(initial_value), m_new_val(initial_value),
|
342 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL)
| 385 _changeStamp(~0ULL), _posStamp(~0ULL), _negStamp(~0ULL),
386 _gem5Writer(NULL)
|
343 {}
344 virtual ~sc_signal() {}
345
346 virtual void
| 387 {}
388 virtual ~sc_signal() {}
389
390 virtual void
|
347 register_port(sc_port_base &, const char *)
| 391 register_port(sc_port_base &port, const char *iface_type_name)
|
348 {
| 392 {
|
349 sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
| 393 if (WRITER_POLICY == SC_ONE_WRITER &&
394 std::string(iface_type_name) ==
395 typeid(sc_signal_inout_if<sc_dt::sc_logic>).name()) {
396 if (_gem5Writer) {
397 std::ostringstream ss;
398 ss << "\n signal " << "`" << name() << "' (" <<
399 kind() << ")";
400 ss << "\n first driver `" << _gem5Writer->name() << "' (" <<
401 _gem5Writer->kind() << ")";
402 ss << "\n second driver `" << port.name() << "' (" <<
403 port.kind() << ")";
404 SC_REPORT_ERROR(
405 "(E115) sc_signal<T> cannot have more than one driver",
406 ss.str().c_str());
407 }
408 _gem5Writer = &port;
409 }
|
350 }
351
352 virtual const sc_dt::sc_logic &read() const { return m_cur_val; }
353 operator const sc_dt::sc_logic &() const { return read(); }
354
355 virtual sc_writer_policy
356 get_writer_policy() const
357 {
358 return WRITER_POLICY;
359 }
360 virtual void
361 write(const sc_dt::sc_logic &l)
362 {
363 m_new_val = l;
364 bool changed = !(m_cur_val == m_new_val);
365 //TODO check whether this write follows the write policy.
366 if (changed)
367 request_update();
368 }
369 sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
370 operator = (const sc_dt::sc_logic &l)
371 {
372 write(l);
373 return *this;
374 }
375 sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
376 operator = (const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &s)
377 {
378 write(s.read());
379 return *this;
380 }
381
382 virtual const sc_event &
383 default_event() const
384 {
385 return value_changed_event();
386 }
387
388 virtual const sc_event &
389 value_changed_event() const
390 {
391 return _valueChangedEvent;
392 }
393 virtual const sc_event &
394 posedge_event() const
395 {
396 return _posedgeEvent;
397 }
398 virtual const sc_event &
399 negedge_event() const
400 {
401 return _negedgeEvent;
402 }
403
404 virtual bool
405 event() const
406 {
407 return _changeStamp == ::sc_gem5::getChangeStamp();
408 }
409 virtual bool
410 posedge() const
411 {
412 return _posStamp == ::sc_gem5::getChangeStamp();
413 }
414 virtual bool
415 negedge() const
416 {
417 return _negStamp == ::sc_gem5::getChangeStamp();
418 }
419
420 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
421 virtual void
422 dump(std::ostream &os=std::cout) const
423 {
424 os << " name = " << name() << ::std::endl;
425 os << " value = " << m_cur_val << ::std::endl;
426 os << "new value = " << m_new_val << ::std::endl;
427 }
428 virtual const char *kind() const { return "sc_signal"; }
429
430 protected:
431 virtual void
432 update()
433 {
434 if (m_new_val == m_cur_val)
435 return;
436
437 m_cur_val = m_new_val;
438 _signalChange();
439 if (m_cur_val == sc_dt::SC_LOGIC_1) {
440 _posStamp = ::sc_gem5::getChangeStamp();
441 _posedgeEvent.notify(SC_ZERO_TIME);
442 } else if (m_cur_val == sc_dt::SC_LOGIC_0) {
443 _negStamp = ::sc_gem5::getChangeStamp();
444 _negedgeEvent.notify(SC_ZERO_TIME);
445 }
446 }
447
448 void
449 _signalChange()
450 {
451 _changeStamp = ::sc_gem5::getChangeStamp();
452 _valueChangedEvent.notify(SC_ZERO_TIME);
453 }
454
455 sc_dt::sc_logic m_cur_val;
456 sc_dt::sc_logic m_new_val;
457
458 private:
459 sc_event _valueChangedEvent;
460 sc_event _posedgeEvent;
461 sc_event _negedgeEvent;
462
463 uint64_t _changeStamp;
464 uint64_t _posStamp;
465 uint64_t _negStamp;
466
| 410 }
411
412 virtual const sc_dt::sc_logic &read() const { return m_cur_val; }
413 operator const sc_dt::sc_logic &() const { return read(); }
414
415 virtual sc_writer_policy
416 get_writer_policy() const
417 {
418 return WRITER_POLICY;
419 }
420 virtual void
421 write(const sc_dt::sc_logic &l)
422 {
423 m_new_val = l;
424 bool changed = !(m_cur_val == m_new_val);
425 //TODO check whether this write follows the write policy.
426 if (changed)
427 request_update();
428 }
429 sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
430 operator = (const sc_dt::sc_logic &l)
431 {
432 write(l);
433 return *this;
434 }
435 sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
436 operator = (const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &s)
437 {
438 write(s.read());
439 return *this;
440 }
441
442 virtual const sc_event &
443 default_event() const
444 {
445 return value_changed_event();
446 }
447
448 virtual const sc_event &
449 value_changed_event() const
450 {
451 return _valueChangedEvent;
452 }
453 virtual const sc_event &
454 posedge_event() const
455 {
456 return _posedgeEvent;
457 }
458 virtual const sc_event &
459 negedge_event() const
460 {
461 return _negedgeEvent;
462 }
463
464 virtual bool
465 event() const
466 {
467 return _changeStamp == ::sc_gem5::getChangeStamp();
468 }
469 virtual bool
470 posedge() const
471 {
472 return _posStamp == ::sc_gem5::getChangeStamp();
473 }
474 virtual bool
475 negedge() const
476 {
477 return _negStamp == ::sc_gem5::getChangeStamp();
478 }
479
480 virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
481 virtual void
482 dump(std::ostream &os=std::cout) const
483 {
484 os << " name = " << name() << ::std::endl;
485 os << " value = " << m_cur_val << ::std::endl;
486 os << "new value = " << m_new_val << ::std::endl;
487 }
488 virtual const char *kind() const { return "sc_signal"; }
489
490 protected:
491 virtual void
492 update()
493 {
494 if (m_new_val == m_cur_val)
495 return;
496
497 m_cur_val = m_new_val;
498 _signalChange();
499 if (m_cur_val == sc_dt::SC_LOGIC_1) {
500 _posStamp = ::sc_gem5::getChangeStamp();
501 _posedgeEvent.notify(SC_ZERO_TIME);
502 } else if (m_cur_val == sc_dt::SC_LOGIC_0) {
503 _negStamp = ::sc_gem5::getChangeStamp();
504 _negedgeEvent.notify(SC_ZERO_TIME);
505 }
506 }
507
508 void
509 _signalChange()
510 {
511 _changeStamp = ::sc_gem5::getChangeStamp();
512 _valueChangedEvent.notify(SC_ZERO_TIME);
513 }
514
515 sc_dt::sc_logic m_cur_val;
516 sc_dt::sc_logic m_new_val;
517
518 private:
519 sc_event _valueChangedEvent;
520 sc_event _posedgeEvent;
521 sc_event _negedgeEvent;
522
523 uint64_t _changeStamp;
524 uint64_t _posStamp;
525 uint64_t _negStamp;
526
|
| 527 sc_port_base *_gem5Writer;
528
|
467 // Disabled
468 sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) :
469 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("")
470 {}
471};
472
473} // namespace sc_core
474
475#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
| 529 // Disabled
530 sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) :
531 sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("")
532 {}
533};
534
535} // namespace sc_core
536
537#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
|