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