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_CORE_PROCESS_HH__ 31#define __SYSTEMC_CORE_PROCESS_HH__ 32 33#include <functional> 34#include <memory> 35#include <vector> 36 37#include "base/fiber.hh" 38#include "sim/eventq.hh" 39#include "systemc/core/bindinfo.hh"
| 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_CORE_PROCESS_HH__ 31#define __SYSTEMC_CORE_PROCESS_HH__ 32 33#include <functional> 34#include <memory> 35#include <vector> 36 37#include "base/fiber.hh" 38#include "sim/eventq.hh" 39#include "systemc/core/bindinfo.hh"
|
40#include "systemc/core/list.hh" 41#include "systemc/core/object.hh" 42#include "systemc/core/sched_event.hh" 43#include "systemc/ext/core/sc_event.hh" 44#include "systemc/ext/core/sc_export.hh" 45#include "systemc/ext/core/sc_interface.hh" 46#include "systemc/ext/core/sc_module.hh" 47#include "systemc/ext/core/sc_port.hh" 48#include "systemc/ext/core/sc_process_handle.hh" 49#include "systemc/ext/utils/sc_report.hh" 50 51namespace sc_gem5 52{ 53 54class Sensitivity 55{ 56 protected: 57 Process *process; 58 59 public: 60 Sensitivity(Process *p) : process(p) {} 61 virtual ~Sensitivity() {} 62 63 virtual void notifyWork(Event *e); 64 void notify(Event *e); 65 void notify() { notify(nullptr); } 66 67 const std::string name(); 68}; 69 70class SensitivityTimeout : virtual public Sensitivity 71{ 72 private: 73 void timeout(); 74 ScEvent timeoutEvent; 75 76 public: 77 SensitivityTimeout(Process *p, ::sc_core::sc_time t); 78 ~SensitivityTimeout(); 79}; 80 81class SensitivityEvent : virtual public Sensitivity 82{ 83 private: 84 const ::sc_core::sc_event *event; 85 86 public: 87 SensitivityEvent(Process *p, const ::sc_core::sc_event *e); 88 ~SensitivityEvent(); 89}; 90 91//XXX This sensitivity can't be reused. To reset it, it has to be deleted and 92//recreated. That works for dynamic sensitivities, but not for static. 93//Fortunately processes can't be statically sensitive to sc_event_and_lists. 94class SensitivityEventAndList : virtual public Sensitivity 95{ 96 private: 97 const ::sc_core::sc_event_and_list *list; 98 int count; 99 100 public: 101 SensitivityEventAndList( 102 Process *p, const ::sc_core::sc_event_and_list *list); 103 ~SensitivityEventAndList(); 104 105 void notifyWork(Event *e) override; 106}; 107 108class SensitivityEventOrList : virtual public Sensitivity 109{ 110 private: 111 const ::sc_core::sc_event_or_list *list; 112 113 public: 114 SensitivityEventOrList( 115 Process *p, const ::sc_core::sc_event_or_list *list); 116 ~SensitivityEventOrList(); 117}; 118 119// Combined sensitivities. These trigger when any of their parts do. 120 121class SensitivityTimeoutAndEvent : 122 public SensitivityTimeout, public SensitivityEvent 123{ 124 public: 125 SensitivityTimeoutAndEvent( 126 Process *p, ::sc_core::sc_time t, const ::sc_core::sc_event *e) : 127 Sensitivity(p), SensitivityTimeout(p, t), SensitivityEvent(p, e) 128 {} 129}; 130 131class SensitivityTimeoutAndEventAndList : 132 public SensitivityTimeout, public SensitivityEventAndList 133{ 134 public: 135 SensitivityTimeoutAndEventAndList( 136 Process *p, ::sc_core::sc_time t, 137 const ::sc_core::sc_event_and_list *eal) : 138 Sensitivity(p), SensitivityTimeout(p, t), 139 SensitivityEventAndList(p, eal) 140 {} 141 142 void notifyWork(Event *e) override; 143}; 144 145class SensitivityTimeoutAndEventOrList : 146 public SensitivityTimeout, public SensitivityEventOrList 147{ 148 public: 149 SensitivityTimeoutAndEventOrList( 150 Process *p, ::sc_core::sc_time t, 151 const ::sc_core::sc_event_or_list *eol) : 152 Sensitivity(p), SensitivityTimeout(p, t), 153 SensitivityEventOrList(p, eol) 154 {} 155}; 156 157typedef std::vector<Sensitivity *> Sensitivities; 158 159 160/* 161 * Pending sensitivities. These are records of sensitivities to install later, 162 * once all the information to configure them is available. 163 */ 164 165class PendingSensitivity 166{ 167 protected: 168 Process *process; 169 170 public: 171 virtual void finalize(Sensitivities &s) = 0; 172 PendingSensitivity(Process *p) : process(p) {} 173 virtual ~PendingSensitivity() {} 174}; 175 176class PendingSensitivityEvent : public PendingSensitivity 177{ 178 private: 179 const sc_core::sc_event *event; 180 181 public: 182 PendingSensitivityEvent(Process *p, const sc_core::sc_event *e) : 183 PendingSensitivity(p), event(e) {} 184 185 void 186 finalize(Sensitivities &s) override 187 { 188 s.push_back(new SensitivityEvent(process, event)); 189 } 190}; 191 192class PendingSensitivityInterface : public PendingSensitivity 193{ 194 private: 195 const sc_core::sc_interface *interface; 196 197 public: 198 PendingSensitivityInterface(Process *p, const sc_core::sc_interface *i) : 199 PendingSensitivity(p), interface(i) 200 {} 201 202 void 203 finalize(Sensitivities &s) override 204 { 205 s.push_back(new SensitivityEvent(process, 206 &interface->default_event())); 207 } 208}; 209 210class PendingSensitivityPort : public PendingSensitivity 211{ 212 private: 213 const sc_core::sc_port_base *port; 214 215 public: 216 PendingSensitivityPort(Process *p, const sc_core::sc_port_base *pb) : 217 PendingSensitivity(p), port(pb) 218 {} 219 220 void 221 finalize(Sensitivities &s) override 222 { 223 for (int i = 0; i < port->size(); i++) { 224 const ::sc_core::sc_event *e = 225 &port->_gem5Interface(i)->default_event(); 226 s.push_back(new SensitivityEvent(process, e)); 227 } 228 } 229}; 230 231class PendingSensitivityExport : public PendingSensitivity 232{ 233 private: 234 const sc_core::sc_export_base *exp; 235 236 public: 237 PendingSensitivityExport(Process *p, const sc_core::sc_export_base *exp) : 238 PendingSensitivity(p), exp(exp) 239 {} 240 241 void 242 finalize(Sensitivities &s) override 243 { 244 s.push_back(new SensitivityEvent(process, 245 &exp->get_interface()->default_event())); 246 } 247}; 248 249class PendingSensitivityFinder : public PendingSensitivity 250{ 251 private: 252 const sc_core::sc_event_finder *finder; 253 254 public: 255 PendingSensitivityFinder(Process *p, const sc_core::sc_event_finder *f) : 256 PendingSensitivity(p), finder(f) 257 {} 258 259 void 260 finalize(Sensitivities &s) override 261 {
| 41#include "systemc/core/list.hh" 42#include "systemc/core/object.hh" 43#include "systemc/core/sched_event.hh" 44#include "systemc/ext/core/sc_event.hh" 45#include "systemc/ext/core/sc_export.hh" 46#include "systemc/ext/core/sc_interface.hh" 47#include "systemc/ext/core/sc_module.hh" 48#include "systemc/ext/core/sc_port.hh" 49#include "systemc/ext/core/sc_process_handle.hh" 50#include "systemc/ext/utils/sc_report.hh" 51 52namespace sc_gem5 53{ 54 55class Sensitivity 56{ 57 protected: 58 Process *process; 59 60 public: 61 Sensitivity(Process *p) : process(p) {} 62 virtual ~Sensitivity() {} 63 64 virtual void notifyWork(Event *e); 65 void notify(Event *e); 66 void notify() { notify(nullptr); } 67 68 const std::string name(); 69}; 70 71class SensitivityTimeout : virtual public Sensitivity 72{ 73 private: 74 void timeout(); 75 ScEvent timeoutEvent; 76 77 public: 78 SensitivityTimeout(Process *p, ::sc_core::sc_time t); 79 ~SensitivityTimeout(); 80}; 81 82class SensitivityEvent : virtual public Sensitivity 83{ 84 private: 85 const ::sc_core::sc_event *event; 86 87 public: 88 SensitivityEvent(Process *p, const ::sc_core::sc_event *e); 89 ~SensitivityEvent(); 90}; 91 92//XXX This sensitivity can't be reused. To reset it, it has to be deleted and 93//recreated. That works for dynamic sensitivities, but not for static. 94//Fortunately processes can't be statically sensitive to sc_event_and_lists. 95class SensitivityEventAndList : virtual public Sensitivity 96{ 97 private: 98 const ::sc_core::sc_event_and_list *list; 99 int count; 100 101 public: 102 SensitivityEventAndList( 103 Process *p, const ::sc_core::sc_event_and_list *list); 104 ~SensitivityEventAndList(); 105 106 void notifyWork(Event *e) override; 107}; 108 109class SensitivityEventOrList : virtual public Sensitivity 110{ 111 private: 112 const ::sc_core::sc_event_or_list *list; 113 114 public: 115 SensitivityEventOrList( 116 Process *p, const ::sc_core::sc_event_or_list *list); 117 ~SensitivityEventOrList(); 118}; 119 120// Combined sensitivities. These trigger when any of their parts do. 121 122class SensitivityTimeoutAndEvent : 123 public SensitivityTimeout, public SensitivityEvent 124{ 125 public: 126 SensitivityTimeoutAndEvent( 127 Process *p, ::sc_core::sc_time t, const ::sc_core::sc_event *e) : 128 Sensitivity(p), SensitivityTimeout(p, t), SensitivityEvent(p, e) 129 {} 130}; 131 132class SensitivityTimeoutAndEventAndList : 133 public SensitivityTimeout, public SensitivityEventAndList 134{ 135 public: 136 SensitivityTimeoutAndEventAndList( 137 Process *p, ::sc_core::sc_time t, 138 const ::sc_core::sc_event_and_list *eal) : 139 Sensitivity(p), SensitivityTimeout(p, t), 140 SensitivityEventAndList(p, eal) 141 {} 142 143 void notifyWork(Event *e) override; 144}; 145 146class SensitivityTimeoutAndEventOrList : 147 public SensitivityTimeout, public SensitivityEventOrList 148{ 149 public: 150 SensitivityTimeoutAndEventOrList( 151 Process *p, ::sc_core::sc_time t, 152 const ::sc_core::sc_event_or_list *eol) : 153 Sensitivity(p), SensitivityTimeout(p, t), 154 SensitivityEventOrList(p, eol) 155 {} 156}; 157 158typedef std::vector<Sensitivity *> Sensitivities; 159 160 161/* 162 * Pending sensitivities. These are records of sensitivities to install later, 163 * once all the information to configure them is available. 164 */ 165 166class PendingSensitivity 167{ 168 protected: 169 Process *process; 170 171 public: 172 virtual void finalize(Sensitivities &s) = 0; 173 PendingSensitivity(Process *p) : process(p) {} 174 virtual ~PendingSensitivity() {} 175}; 176 177class PendingSensitivityEvent : public PendingSensitivity 178{ 179 private: 180 const sc_core::sc_event *event; 181 182 public: 183 PendingSensitivityEvent(Process *p, const sc_core::sc_event *e) : 184 PendingSensitivity(p), event(e) {} 185 186 void 187 finalize(Sensitivities &s) override 188 { 189 s.push_back(new SensitivityEvent(process, event)); 190 } 191}; 192 193class PendingSensitivityInterface : public PendingSensitivity 194{ 195 private: 196 const sc_core::sc_interface *interface; 197 198 public: 199 PendingSensitivityInterface(Process *p, const sc_core::sc_interface *i) : 200 PendingSensitivity(p), interface(i) 201 {} 202 203 void 204 finalize(Sensitivities &s) override 205 { 206 s.push_back(new SensitivityEvent(process, 207 &interface->default_event())); 208 } 209}; 210 211class PendingSensitivityPort : public PendingSensitivity 212{ 213 private: 214 const sc_core::sc_port_base *port; 215 216 public: 217 PendingSensitivityPort(Process *p, const sc_core::sc_port_base *pb) : 218 PendingSensitivity(p), port(pb) 219 {} 220 221 void 222 finalize(Sensitivities &s) override 223 { 224 for (int i = 0; i < port->size(); i++) { 225 const ::sc_core::sc_event *e = 226 &port->_gem5Interface(i)->default_event(); 227 s.push_back(new SensitivityEvent(process, e)); 228 } 229 } 230}; 231 232class PendingSensitivityExport : public PendingSensitivity 233{ 234 private: 235 const sc_core::sc_export_base *exp; 236 237 public: 238 PendingSensitivityExport(Process *p, const sc_core::sc_export_base *exp) : 239 PendingSensitivity(p), exp(exp) 240 {} 241 242 void 243 finalize(Sensitivities &s) override 244 { 245 s.push_back(new SensitivityEvent(process, 246 &exp->get_interface()->default_event())); 247 } 248}; 249 250class PendingSensitivityFinder : public PendingSensitivity 251{ 252 private: 253 const sc_core::sc_event_finder *finder; 254 255 public: 256 PendingSensitivityFinder(Process *p, const sc_core::sc_event_finder *f) : 257 PendingSensitivity(p), finder(f) 258 {} 259 260 void 261 finalize(Sensitivities &s) override 262 {
|