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 "base/types.hh"
32#include "sim/core.hh"
33#include "sim/eventq.hh"
34#include "systemc/core/kernel.hh"
35#include "systemc/core/process_types.hh"
36#include "systemc/core/sched_event.hh"
37#include "systemc/core/scheduler.hh"
38#include "systemc/ext/channel/sc_clock.hh"
39#include "systemc/ext/core/sc_module.hh" // for sc_gen_unique_name
40
41namespace sc_gem5
42{
43
44class ClockTick : public ScEvent
45{
46 private:
47 ::sc_core::sc_clock *clock;
48 ::sc_core::sc_time _period;
| 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 "base/types.hh"
32#include "sim/core.hh"
33#include "sim/eventq.hh"
34#include "systemc/core/kernel.hh"
35#include "systemc/core/process_types.hh"
36#include "systemc/core/sched_event.hh"
37#include "systemc/core/scheduler.hh"
38#include "systemc/ext/channel/sc_clock.hh"
39#include "systemc/ext/core/sc_module.hh" // for sc_gen_unique_name
40
41namespace sc_gem5
42{
43
44class ClockTick : public ScEvent
45{
46 private:
47 ::sc_core::sc_clock *clock;
48 ::sc_core::sc_time _period;
|
49 std::string _name;
| 49 std::string name;
|
50 Process *p;
51 ProcessMemberFuncWrapper<::sc_core::sc_clock> funcWrapper;
| 50 Process *p;
51 ProcessMemberFuncWrapper<::sc_core::sc_clock> funcWrapper;
|
52 std::string _procName;
| |
53
54 public:
55 ClockTick(::sc_core::sc_clock *clock, bool to,
56 ::sc_core::sc_time _period) :
57 ScEvent([this]() { tick(); }),
| 52
53 public:
54 ClockTick(::sc_core::sc_clock *clock, bool to,
55 ::sc_core::sc_time _period) :
56 ScEvent([this]() { tick(); }),
|
58 clock(clock), _period(_period), _name(clock->name()),
| 57 clock(clock), _period(_period), name(clock->basename()), p(nullptr),
|
59 funcWrapper(clock, to ? &::sc_core::sc_clock::tickUp :
60 &::sc_core::sc_clock::tickDown)
61 {
| 58 funcWrapper(clock, to ? &::sc_core::sc_clock::tickUp :
59 &::sc_core::sc_clock::tickDown)
60 {
|
62 _name += (to ? ".up_tick" : ".down_tick");
63 _procName = _name + ".p";
64 p = new Method(_procName.c_str(), &funcWrapper, true);
| 61 name += std::string(to ? "_posedge_action" : "_negedge_action");
62 name = ::sc_core::sc_gen_unique_name(name.c_str());
63 }
64
65 void
66 createProcess()
67 {
68 p = new Method(name.c_str(), &funcWrapper, true);
|
65 scheduler.reg(p);
66 scheduler.dontInitialize(p);
67 }
68
69 ~ClockTick()
70 {
71 if (scheduled())
72 scheduler.deschedule(this);
| 69 scheduler.reg(p);
70 scheduler.dontInitialize(p);
71 }
72
73 ~ClockTick()
74 {
75 if (scheduled())
76 scheduler.deschedule(this);
|
73 p->popListNode();
| 77 if (p)
78 p->popListNode();
|
74 }
75
76 void
77 tick()
78 {
79 scheduler.schedule(this, _period);
80 p->ready();
81 }
82};
83
84};
85
86namespace sc_core
87{
88
89sc_clock::sc_clock() :
90 sc_clock(sc_gen_unique_name("clock"), sc_time(1.0, SC_NS),
91 0.5, SC_ZERO_TIME, true)
92{}
93
94sc_clock::sc_clock(const char *name) :
95 sc_clock(name, sc_time(1.0, SC_NS), 0.5, SC_ZERO_TIME, true)
96{}
97
98sc_clock::sc_clock(const char *name, const sc_time &period,
99 double duty_cycle, const sc_time &start_time,
100 bool posedge_first) :
101 sc_interface(), sc_signal<bool>(name, posedge_first ? false : true),
102 _period(period), _dutyCycle(duty_cycle), _startTime(start_time),
103 _posedgeFirst(posedge_first)
104{
105 _gem5UpEdge = new ::sc_gem5::ClockTick(this, true, period);
106 _gem5DownEdge = new ::sc_gem5::ClockTick(this, false, period);
107}
108
109sc_clock::sc_clock(const char *name, double period_v, sc_time_unit period_tu,
110 double duty_cycle) :
111 sc_clock(name, sc_time(period_v, period_tu), duty_cycle, SC_ZERO_TIME,
112 true)
113{}
114
115sc_clock::sc_clock(const char *name, double period_v, sc_time_unit period_tu,
116 double duty_cycle, double start_time_v,
117 sc_time_unit start_time_tu, bool posedge_first) :
118 sc_clock(name, sc_time(period_v, period_tu), duty_cycle,
119 sc_time(start_time_v, start_time_tu), posedge_first)
120{}
121
122sc_clock::sc_clock(const char *name, double period, double duty_cycle,
123 double start_time, bool posedge_first) :
124 sc_clock(name, sc_time(period, true), duty_cycle,
125 sc_time(start_time, true), posedge_first)
126{}
127
128sc_clock::~sc_clock()
129{
130 if (_gem5UpEdge->scheduled())
131 ::sc_gem5::scheduler.deschedule(_gem5UpEdge);
132 if (_gem5DownEdge->scheduled())
133 ::sc_gem5::scheduler.deschedule(_gem5DownEdge);
134 delete _gem5UpEdge;
135 delete _gem5DownEdge;
136}
137
138void
139sc_clock::write(const bool &)
140{
141 panic("write() called on sc_clock.");
142}
143
144const sc_time &sc_clock::period() const { return _period; }
145double sc_clock::duty_cycle() const { return _dutyCycle; }
146const sc_time &sc_clock::start_time() const { return _startTime; }
147bool sc_clock::posedge_first() const { return _posedgeFirst; }
148
149const sc_time &
150sc_clock::time_stamp()
151{
152 warn("%s not implemented.\n", __PRETTY_FUNCTION__);
153 return *(const sc_time *)nullptr;
154}
155
156void
157sc_clock::before_end_of_elaboration()
158{
| 79 }
80
81 void
82 tick()
83 {
84 scheduler.schedule(this, _period);
85 p->ready();
86 }
87};
88
89};
90
91namespace sc_core
92{
93
94sc_clock::sc_clock() :
95 sc_clock(sc_gen_unique_name("clock"), sc_time(1.0, SC_NS),
96 0.5, SC_ZERO_TIME, true)
97{}
98
99sc_clock::sc_clock(const char *name) :
100 sc_clock(name, sc_time(1.0, SC_NS), 0.5, SC_ZERO_TIME, true)
101{}
102
103sc_clock::sc_clock(const char *name, const sc_time &period,
104 double duty_cycle, const sc_time &start_time,
105 bool posedge_first) :
106 sc_interface(), sc_signal<bool>(name, posedge_first ? false : true),
107 _period(period), _dutyCycle(duty_cycle), _startTime(start_time),
108 _posedgeFirst(posedge_first)
109{
110 _gem5UpEdge = new ::sc_gem5::ClockTick(this, true, period);
111 _gem5DownEdge = new ::sc_gem5::ClockTick(this, false, period);
112}
113
114sc_clock::sc_clock(const char *name, double period_v, sc_time_unit period_tu,
115 double duty_cycle) :
116 sc_clock(name, sc_time(period_v, period_tu), duty_cycle, SC_ZERO_TIME,
117 true)
118{}
119
120sc_clock::sc_clock(const char *name, double period_v, sc_time_unit period_tu,
121 double duty_cycle, double start_time_v,
122 sc_time_unit start_time_tu, bool posedge_first) :
123 sc_clock(name, sc_time(period_v, period_tu), duty_cycle,
124 sc_time(start_time_v, start_time_tu), posedge_first)
125{}
126
127sc_clock::sc_clock(const char *name, double period, double duty_cycle,
128 double start_time, bool posedge_first) :
129 sc_clock(name, sc_time(period, true), duty_cycle,
130 sc_time(start_time, true), posedge_first)
131{}
132
133sc_clock::~sc_clock()
134{
135 if (_gem5UpEdge->scheduled())
136 ::sc_gem5::scheduler.deschedule(_gem5UpEdge);
137 if (_gem5DownEdge->scheduled())
138 ::sc_gem5::scheduler.deschedule(_gem5DownEdge);
139 delete _gem5UpEdge;
140 delete _gem5DownEdge;
141}
142
143void
144sc_clock::write(const bool &)
145{
146 panic("write() called on sc_clock.");
147}
148
149const sc_time &sc_clock::period() const { return _period; }
150double sc_clock::duty_cycle() const { return _dutyCycle; }
151const sc_time &sc_clock::start_time() const { return _startTime; }
152bool sc_clock::posedge_first() const { return _posedgeFirst; }
153
154const sc_time &
155sc_clock::time_stamp()
156{
157 warn("%s not implemented.\n", __PRETTY_FUNCTION__);
158 return *(const sc_time *)nullptr;
159}
160
161void
162sc_clock::before_end_of_elaboration()
163{
|
| 164 _gem5UpEdge->createProcess();
165 _gem5DownEdge->createProcess();
|
159 if (_posedgeFirst) {
160 ::sc_gem5::scheduler.schedule(_gem5UpEdge, _startTime);
161 ::sc_gem5::scheduler.schedule(_gem5DownEdge,
162 _startTime + _period * _dutyCycle);
163 } else {
164 ::sc_gem5::scheduler.schedule(_gem5DownEdge, _startTime);
165 ::sc_gem5::scheduler.schedule(_gem5UpEdge,
166 _startTime + _period * (1.0 - _dutyCycle));
167 }
168}
169
170} // namespace sc_core
| 166 if (_posedgeFirst) {
167 ::sc_gem5::scheduler.schedule(_gem5UpEdge, _startTime);
168 ::sc_gem5::scheduler.schedule(_gem5DownEdge,
169 _startTime + _period * _dutyCycle);
170 } else {
171 ::sc_gem5::scheduler.schedule(_gem5DownEdge, _startTime);
172 ::sc_gem5::scheduler.schedule(_gem5UpEdge,
173 _startTime + _period * (1.0 - _dutyCycle));
174 }
175}
176
177} // namespace sc_core
|