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 "systemc/core/sensitivity.hh" 31 32#include "systemc/core/event.hh" 33#include "systemc/core/port.hh" 34#include "systemc/core/process.hh" 35#include "systemc/core/scheduler.hh" 36#include "systemc/ext/channel/sc_in.hh" 37#include "systemc/ext/channel/sc_inout.hh" 38#include "systemc/ext/channel/sc_out.hh" 39#include "systemc/ext/core/sc_export.hh" 40#include "systemc/ext/core/sc_interface.hh" 41#include "systemc/ext/core/sc_port.hh" 42 43namespace sc_gem5 44{ 45 46/* 47 * Common sensitivity interface. 48 */ 49 50void 51Sensitivity::satisfy() 52{ 53 process->satisfySensitivity(this); 54} 55 56bool 57Sensitivity::notify(Event *e) 58{ 59 if (process->disabled()) 60 return false;
| 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 "systemc/core/sensitivity.hh" 31 32#include "systemc/core/event.hh" 33#include "systemc/core/port.hh" 34#include "systemc/core/process.hh" 35#include "systemc/core/scheduler.hh" 36#include "systemc/ext/channel/sc_in.hh" 37#include "systemc/ext/channel/sc_inout.hh" 38#include "systemc/ext/channel/sc_out.hh" 39#include "systemc/ext/core/sc_export.hh" 40#include "systemc/ext/core/sc_interface.hh" 41#include "systemc/ext/core/sc_port.hh" 42 43namespace sc_gem5 44{ 45 46/* 47 * Common sensitivity interface. 48 */ 49 50void 51Sensitivity::satisfy() 52{ 53 process->satisfySensitivity(this); 54} 55 56bool 57Sensitivity::notify(Event *e) 58{ 59 if (process->disabled()) 60 return false;
|
61 return notifyWork(e);
| 61 satisfy(); 62 return true;
|
62} 63 64bool 65Sensitivity::ofMethod() 66{ 67 return process->procKind() == sc_core::SC_METHOD_PROC_; 68} 69 70 71/* 72 * Dynamic vs. static sensitivity. 73 */ 74 75void 76DynamicSensitivity::addToEvent(const ::sc_core::sc_event *e) 77{ 78 Event::getFromScEvent(e)->addSensitivity(this); 79} 80 81void 82DynamicSensitivity::delFromEvent(const ::sc_core::sc_event *e) 83{ 84 Event::getFromScEvent(e)->delSensitivity(this); 85} 86 87void 88StaticSensitivity::addToEvent(const ::sc_core::sc_event *e) 89{ 90 Event::getFromScEvent(e)->addSensitivity(this); 91} 92 93void 94StaticSensitivity::delFromEvent(const ::sc_core::sc_event *e) 95{ 96 Event::getFromScEvent(e)->delSensitivity(this); 97} 98 99void 100ResetSensitivity::addToEvent(const ::sc_core::sc_event *e) 101{ 102 Event::getFromScEvent(e)->addSensitivity(this); 103} 104 105void 106ResetSensitivity::delFromEvent(const ::sc_core::sc_event *e) 107{ 108 Event::getFromScEvent(e)->delSensitivity(this); 109} 110 111 112/* 113 * Static sensitivities. 114 */ 115 116void 117newStaticSensitivityEvent(Process *p, const sc_core::sc_event *e) 118{ 119 auto s = new StaticSensitivityEvent(p, e); 120 s->addToEvent(s->event); 121 p->addStatic(s); 122} 123 124void 125newStaticSensitivityInterface(Process *p, const sc_core::sc_interface *i) 126{ 127 auto s = new StaticSensitivityInterface(p, i); 128 s->addToEvent(s->event); 129 p->addStatic(s); 130} 131 132void 133newStaticSensitivityPort(Process *p, const sc_core::sc_port_base *pb) 134{ 135 auto s = new StaticSensitivityPort(p); 136 Port *port = Port::fromPort(pb); 137 port->sensitive(s); 138 p->addStatic(s); 139} 140 141void 142newStaticSensitivityExport(Process *p, const sc_core::sc_export_base *exp) 143{ 144 auto s = new StaticSensitivityExport(p, exp); 145 s->addToEvent(s->event); 146 p->addStatic(s); 147} 148 149void 150newStaticSensitivityFinder(Process *p, const sc_core::sc_event_finder *f) 151{ 152 auto s = new StaticSensitivityFinder(p, f); 153 Port *port = Port::fromPort(f->port()); 154 port->sensitive(s); 155 p->addStatic(s); 156} 157 158 159StaticSensitivityInterface::StaticSensitivityInterface( 160 Process *p, const sc_core::sc_interface *i) : 161 Sensitivity(p), StaticSensitivity(p), 162 SensitivityEvent(p, &i->default_event()) 163{} 164 165StaticSensitivityExport::StaticSensitivityExport( 166 Process *p, const sc_core::sc_export_base *exp) : 167 Sensitivity(p), StaticSensitivity(p), 168 SensitivityEvent(p, &exp->get_interface()->default_event()) 169{} 170 171const ::sc_core::sc_event & 172StaticSensitivityFinder::find(::sc_core::sc_interface *i) 173{ 174 return finder->find_event(i); 175} 176 177 178/* 179 * Dynamic sensitivities. 180 */ 181 182void 183newDynamicSensitivityEvent(Process *p, const sc_core::sc_event *e) 184{ 185 auto s = new DynamicSensitivityEvent(p, e); 186 s->addToEvent(s->event); 187 p->setDynamic(s); 188} 189 190void 191newDynamicSensitivityEventOrList( 192 Process *p, const sc_core::sc_event_or_list *eol) 193{ 194 auto s = new DynamicSensitivityEventOrList(p, eol); 195 for (auto event: s->events) 196 s->addToEvent(event); 197 p->setDynamic(s); 198} 199 200void newDynamicSensitivityEventAndList( 201 Process *p, const sc_core::sc_event_and_list *eal) 202{ 203 auto s = new DynamicSensitivityEventAndList(p, eal); 204 for (auto event: s->events) 205 s->addToEvent(event); 206 p->setDynamic(s); 207} 208 209 210DynamicSensitivityEventOrList::DynamicSensitivityEventOrList( 211 Process *p, const sc_core::sc_event_or_list *eol) : 212 Sensitivity(p), DynamicSensitivity(p), SensitivityEvents(p, eol->events) 213{} 214 215bool
| 63} 64 65bool 66Sensitivity::ofMethod() 67{ 68 return process->procKind() == sc_core::SC_METHOD_PROC_; 69} 70 71 72/* 73 * Dynamic vs. static sensitivity. 74 */ 75 76void 77DynamicSensitivity::addToEvent(const ::sc_core::sc_event *e) 78{ 79 Event::getFromScEvent(e)->addSensitivity(this); 80} 81 82void 83DynamicSensitivity::delFromEvent(const ::sc_core::sc_event *e) 84{ 85 Event::getFromScEvent(e)->delSensitivity(this); 86} 87 88void 89StaticSensitivity::addToEvent(const ::sc_core::sc_event *e) 90{ 91 Event::getFromScEvent(e)->addSensitivity(this); 92} 93 94void 95StaticSensitivity::delFromEvent(const ::sc_core::sc_event *e) 96{ 97 Event::getFromScEvent(e)->delSensitivity(this); 98} 99 100void 101ResetSensitivity::addToEvent(const ::sc_core::sc_event *e) 102{ 103 Event::getFromScEvent(e)->addSensitivity(this); 104} 105 106void 107ResetSensitivity::delFromEvent(const ::sc_core::sc_event *e) 108{ 109 Event::getFromScEvent(e)->delSensitivity(this); 110} 111 112 113/* 114 * Static sensitivities. 115 */ 116 117void 118newStaticSensitivityEvent(Process *p, const sc_core::sc_event *e) 119{ 120 auto s = new StaticSensitivityEvent(p, e); 121 s->addToEvent(s->event); 122 p->addStatic(s); 123} 124 125void 126newStaticSensitivityInterface(Process *p, const sc_core::sc_interface *i) 127{ 128 auto s = new StaticSensitivityInterface(p, i); 129 s->addToEvent(s->event); 130 p->addStatic(s); 131} 132 133void 134newStaticSensitivityPort(Process *p, const sc_core::sc_port_base *pb) 135{ 136 auto s = new StaticSensitivityPort(p); 137 Port *port = Port::fromPort(pb); 138 port->sensitive(s); 139 p->addStatic(s); 140} 141 142void 143newStaticSensitivityExport(Process *p, const sc_core::sc_export_base *exp) 144{ 145 auto s = new StaticSensitivityExport(p, exp); 146 s->addToEvent(s->event); 147 p->addStatic(s); 148} 149 150void 151newStaticSensitivityFinder(Process *p, const sc_core::sc_event_finder *f) 152{ 153 auto s = new StaticSensitivityFinder(p, f); 154 Port *port = Port::fromPort(f->port()); 155 port->sensitive(s); 156 p->addStatic(s); 157} 158 159 160StaticSensitivityInterface::StaticSensitivityInterface( 161 Process *p, const sc_core::sc_interface *i) : 162 Sensitivity(p), StaticSensitivity(p), 163 SensitivityEvent(p, &i->default_event()) 164{} 165 166StaticSensitivityExport::StaticSensitivityExport( 167 Process *p, const sc_core::sc_export_base *exp) : 168 Sensitivity(p), StaticSensitivity(p), 169 SensitivityEvent(p, &exp->get_interface()->default_event()) 170{} 171 172const ::sc_core::sc_event & 173StaticSensitivityFinder::find(::sc_core::sc_interface *i) 174{ 175 return finder->find_event(i); 176} 177 178 179/* 180 * Dynamic sensitivities. 181 */ 182 183void 184newDynamicSensitivityEvent(Process *p, const sc_core::sc_event *e) 185{ 186 auto s = new DynamicSensitivityEvent(p, e); 187 s->addToEvent(s->event); 188 p->setDynamic(s); 189} 190 191void 192newDynamicSensitivityEventOrList( 193 Process *p, const sc_core::sc_event_or_list *eol) 194{ 195 auto s = new DynamicSensitivityEventOrList(p, eol); 196 for (auto event: s->events) 197 s->addToEvent(event); 198 p->setDynamic(s); 199} 200 201void newDynamicSensitivityEventAndList( 202 Process *p, const sc_core::sc_event_and_list *eal) 203{ 204 auto s = new DynamicSensitivityEventAndList(p, eal); 205 for (auto event: s->events) 206 s->addToEvent(event); 207 p->setDynamic(s); 208} 209 210 211DynamicSensitivityEventOrList::DynamicSensitivityEventOrList( 212 Process *p, const sc_core::sc_event_or_list *eol) : 213 Sensitivity(p), DynamicSensitivity(p), SensitivityEvents(p, eol->events) 214{} 215 216bool
|
216DynamicSensitivityEventOrList::notifyWork(Event *e)
| 217DynamicSensitivityEventOrList::notify(Event *e)
|
217{
| 218{
|
| 219 if (process->disabled()) 220 return false; 221
|
218 events.erase(e->sc_event()); 219 220 // All the other events need this deleted from their lists since this 221 // sensitivity has been satisfied without them triggering. 222 for (auto le: events) 223 delFromEvent(le); 224 225 satisfy(); 226 return true; 227} 228 229DynamicSensitivityEventAndList::DynamicSensitivityEventAndList( 230 Process *p, const sc_core::sc_event_and_list *eal) : 231 Sensitivity(p), DynamicSensitivity(p), SensitivityEvents(p, eal->events) 232{} 233 234bool
| 222 events.erase(e->sc_event()); 223 224 // All the other events need this deleted from their lists since this 225 // sensitivity has been satisfied without them triggering. 226 for (auto le: events) 227 delFromEvent(le); 228 229 satisfy(); 230 return true; 231} 232 233DynamicSensitivityEventAndList::DynamicSensitivityEventAndList( 234 Process *p, const sc_core::sc_event_and_list *eal) : 235 Sensitivity(p), DynamicSensitivity(p), SensitivityEvents(p, eal->events) 236{} 237 238bool
|
235DynamicSensitivityEventAndList::notifyWork(Event *e)
| 239DynamicSensitivityEventAndList::notify(Event *e)
|
236{
| 240{
|
| 241 if (process->disabled()) 242 return false; 243
|
237 events.erase(e->sc_event()); 238 239 // This sensitivity is satisfied if all events have triggered. 240 if (events.empty()) 241 satisfy(); 242 243 return true; 244} 245 246/* 247 * Reset sensitivities. 248 */ 249 250void 251newResetSensitivitySignal( 252 Process *p, const sc_core::sc_signal_in_if<bool> *signal, 253 bool val, bool sync) 254{ 255 auto s = new ResetSensitivitySignal(p, signal, val, sync); 256 s->addToEvent(s->event); 257 p->addReset(s); 258} 259 260void 261newResetSensitivityPort(Process *p, const sc_core::sc_in<bool> *port, 262 bool val, bool sync) 263{ 264 auto s = new ResetSensitivityPort(p, port, val, sync); 265 Port::fromPort(port)->sensitive(s); 266 p->addReset(s); 267} 268void 269newResetSensitivityPort(Process *p, const sc_core::sc_inout<bool> *port, 270 bool val, bool sync) 271{ 272 auto s = new ResetSensitivityPort(p, port, val, sync); 273 Port::fromPort(port)->sensitive(s); 274 p->addReset(s); 275} 276void 277newResetSensitivityPort(Process *p, const sc_core::sc_out<bool> *port, 278 bool val, bool sync) 279{ 280 auto s = new ResetSensitivityPort(p, port, val, sync); 281 Port::fromPort(port)->sensitive(s); 282 p->addReset(s); 283} 284 285ResetSensitivitySignal::ResetSensitivitySignal( 286 Process *p, const sc_core::sc_signal_in_if<bool> *signal, 287 bool _val, bool _sync) : 288 Sensitivity(p), ResetSensitivity(p, _val, _sync), 289 SensitivityEvent(p, signal ? &signal->value_changed_event() : nullptr), 290 _signal(signal) 291{ 292 if (signal && signal->read() == val()) 293 process->signalReset(true, sync()); 294} 295 296bool
| 244 events.erase(e->sc_event()); 245 246 // This sensitivity is satisfied if all events have triggered. 247 if (events.empty()) 248 satisfy(); 249 250 return true; 251} 252 253/* 254 * Reset sensitivities. 255 */ 256 257void 258newResetSensitivitySignal( 259 Process *p, const sc_core::sc_signal_in_if<bool> *signal, 260 bool val, bool sync) 261{ 262 auto s = new ResetSensitivitySignal(p, signal, val, sync); 263 s->addToEvent(s->event); 264 p->addReset(s); 265} 266 267void 268newResetSensitivityPort(Process *p, const sc_core::sc_in<bool> *port, 269 bool val, bool sync) 270{ 271 auto s = new ResetSensitivityPort(p, port, val, sync); 272 Port::fromPort(port)->sensitive(s); 273 p->addReset(s); 274} 275void 276newResetSensitivityPort(Process *p, const sc_core::sc_inout<bool> *port, 277 bool val, bool sync) 278{ 279 auto s = new ResetSensitivityPort(p, port, val, sync); 280 Port::fromPort(port)->sensitive(s); 281 p->addReset(s); 282} 283void 284newResetSensitivityPort(Process *p, const sc_core::sc_out<bool> *port, 285 bool val, bool sync) 286{ 287 auto s = new ResetSensitivityPort(p, port, val, sync); 288 Port::fromPort(port)->sensitive(s); 289 p->addReset(s); 290} 291 292ResetSensitivitySignal::ResetSensitivitySignal( 293 Process *p, const sc_core::sc_signal_in_if<bool> *signal, 294 bool _val, bool _sync) : 295 Sensitivity(p), ResetSensitivity(p, _val, _sync), 296 SensitivityEvent(p, signal ? &signal->value_changed_event() : nullptr), 297 _signal(signal) 298{ 299 if (signal && signal->read() == val()) 300 process->signalReset(true, sync()); 301} 302 303bool
|
297ResetSensitivitySignal::notifyWork(Event *e)
| 304ResetSensitivitySignal::notify(Event *e)
|
298{ 299 process->signalReset(_signal->read() == val(), sync()); 300 return true; 301} 302 303void 304ResetSensitivityPort::setSignal(const ::sc_core::sc_signal_in_if<bool> *signal) 305{ 306 _signal = signal; 307 event = &_signal->value_changed_event(); 308 addToEvent(event); 309 if (signal->read() == val()) 310 process->signalReset(true, sync()); 311} 312 313} // namespace sc_gem5
| 305{ 306 process->signalReset(_signal->read() == val(), sync()); 307 return true; 308} 309 310void 311ResetSensitivityPort::setSignal(const ::sc_core::sc_signal_in_if<bool> *signal) 312{ 313 _signal = signal; 314 event = &_signal->value_changed_event(); 315 addToEvent(event); 316 if (signal->read() == val()) 317 process->signalReset(true, sync()); 318} 319 320} // namespace sc_gem5
|