sensitivity.cc revision 13208:6703cb024823
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/core/sc_export.hh" 37#include "systemc/ext/core/sc_interface.hh" 38#include "systemc/ext/core/sc_port.hh" 39 40namespace sc_gem5 41{ 42 43/* 44 * Common sensitivity interface. 45 */ 46 47void 48Sensitivity::satisfy() 49{ 50 process->satisfySensitivity(this); 51} 52 53bool 54Sensitivity::notify(Event *e) 55{ 56 if (process->disabled()) 57 return false; 58 return notifyWork(e); 59} 60 61bool 62Sensitivity::ofMethod() 63{ 64 return process->procKind() == sc_core::SC_METHOD_PROC_; 65} 66 67 68/* 69 * Dynamic vs. static sensitivity. 70 */ 71 72void 73DynamicSensitivity::addToEvent(const ::sc_core::sc_event *e) 74{ 75 Event::getFromScEvent(e)->addSensitivity(this); 76} 77 78void 79DynamicSensitivity::delFromEvent(const ::sc_core::sc_event *e) 80{ 81 Event::getFromScEvent(e)->delSensitivity(this); 82} 83 84void 85StaticSensitivity::addToEvent(const ::sc_core::sc_event *e) 86{ 87 Event::getFromScEvent(e)->addSensitivity(this); 88} 89 90void 91StaticSensitivity::delFromEvent(const ::sc_core::sc_event *e) 92{ 93 Event::getFromScEvent(e)->delSensitivity(this); 94} 95 96 97/* 98 * Static sensitivities. 99 */ 100 101void 102newStaticSensitivityEvent(Process *p, const sc_core::sc_event *e) 103{ 104 auto s = new StaticSensitivityEvent(p, e); 105 s->addToEvent(s->event); 106 p->addStatic(s); 107} 108 109void 110newStaticSensitivityInterface(Process *p, const sc_core::sc_interface *i) 111{ 112 auto s = new StaticSensitivityInterface(p, i); 113 s->addToEvent(s->event); 114 p->addStatic(s); 115} 116 117void 118newStaticSensitivityPort(Process *p, const sc_core::sc_port_base *pb) 119{ 120 auto s = new StaticSensitivityPort(p); 121 Port *port = Port::fromPort(pb); 122 port->sensitive(s); 123 p->addStatic(s); 124} 125 126void 127newStaticSensitivityExport(Process *p, const sc_core::sc_export_base *exp) 128{ 129 auto s = new StaticSensitivityExport(p, exp); 130 s->addToEvent(s->event); 131 p->addStatic(s); 132} 133 134void 135newStaticSensitivityFinder(Process *p, const sc_core::sc_event_finder *f) 136{ 137 auto s = new StaticSensitivityFinder(p, f); 138 Port *port = Port::fromPort(f->port()); 139 port->sensitive(s); 140 p->addStatic(s); 141} 142 143 144StaticSensitivityInterface::StaticSensitivityInterface( 145 Process *p, const sc_core::sc_interface *i) : 146 Sensitivity(p), StaticSensitivity(p), 147 SensitivityEvent(p, &i->default_event()) 148{} 149 150StaticSensitivityExport::StaticSensitivityExport( 151 Process *p, const sc_core::sc_export_base *exp) : 152 Sensitivity(p), StaticSensitivity(p), 153 SensitivityEvent(p, &exp->get_interface()->default_event()) 154{} 155 156const ::sc_core::sc_event & 157StaticSensitivityFinder::find(::sc_core::sc_interface *i) 158{ 159 return finder->find_event(i); 160} 161 162 163/* 164 * Dynamic sensitivities. 165 */ 166 167void 168newDynamicSensitivityEvent(Process *p, const sc_core::sc_event *e) 169{ 170 auto s = new DynamicSensitivityEvent(p, e); 171 s->addToEvent(s->event); 172 p->setDynamic(s); 173} 174 175void 176newDynamicSensitivityEventOrList( 177 Process *p, const sc_core::sc_event_or_list *eol) 178{ 179 auto s = new DynamicSensitivityEventOrList(p, eol); 180 for (auto event: s->events) 181 s->addToEvent(event); 182 p->setDynamic(s); 183} 184 185void newDynamicSensitivityEventAndList( 186 Process *p, const sc_core::sc_event_and_list *eal) 187{ 188 auto s = new DynamicSensitivityEventAndList(p, eal); 189 for (auto event: s->events) 190 s->addToEvent(event); 191 p->setDynamic(s); 192} 193 194 195DynamicSensitivityEventOrList::DynamicSensitivityEventOrList( 196 Process *p, const sc_core::sc_event_or_list *eol) : 197 Sensitivity(p), DynamicSensitivity(p), SensitivityEvents(p, eol->events) 198{} 199 200bool 201DynamicSensitivityEventOrList::notifyWork(Event *e) 202{ 203 events.erase(e->sc_event()); 204 205 // All the other events need this deleted from their lists since this 206 // sensitivity has been satisfied without them triggering. 207 for (auto le: events) 208 delFromEvent(le); 209 210 satisfy(); 211 return true; 212} 213 214DynamicSensitivityEventAndList::DynamicSensitivityEventAndList( 215 Process *p, const sc_core::sc_event_and_list *eal) : 216 Sensitivity(p), DynamicSensitivity(p), SensitivityEvents(p, eal->events) 217{} 218 219bool 220DynamicSensitivityEventAndList::notifyWork(Event *e) 221{ 222 events.erase(e->sc_event()); 223 224 // This sensitivity is satisfied if all events have triggered. 225 if (events.empty()) 226 satisfy(); 227 228 return true; 229} 230 231} // namespace sc_gem5 232