src/systemc/ext/core/sc_module.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_EXT_SC_MODULE_HH__
  31 #define __SYSTEMC_CORE_EXT_SC_MODULE_HH__
  32
  33 #include <vector>
  34
  35 #include "sc_object.hh"
  36 #include "sc_sensitive.hh"
  37 #include "sc_time.hh"
  38
  39 namespace sc_dt
  40 {
  41
  42 class sc_logic;
  43
  44 } // namespace sc_dt
  45
  46 namespace sc_core
  47 {
  48
  49 template <class T>
  50 class sc_in;
  51 template <class T>
  52 class sc_out;
  53 template <class T>
  54 class sc_inout;
  55 template <class T>
  56 class sc_signal_in_if;
  57
  58 class sc_event;
  59 class sc_event_and_list;
  60 class sc_event_or_list;
  61 class sc_module_name;
  62
  63 class sc_bind_proxy
  64 {
  65   public:
  66     sc_bind_proxy(const sc_interface &interface);
  67     sc_bind_proxy(const sc_port_base &port);
  68 };
  69
  70 extern const sc_bind_proxy SC_BIND_PROXY_NIL;
  71
  72 class sc_module : public sc_object
  73 {
  74   public:
  75     virtual ~sc_module();
  76
  77     virtual const char *kind() const;
  78
  79     void operator () (const sc_bind_proxy &p001,
  80                       const sc_bind_proxy &p002 = SC_BIND_PROXY_NIL,
  81                       const sc_bind_proxy &p003 = SC_BIND_PROXY_NIL,
  82                       const sc_bind_proxy &p004 = SC_BIND_PROXY_NIL,
  83                       const sc_bind_proxy &p005 = SC_BIND_PROXY_NIL,
  84                       const sc_bind_proxy &p006 = SC_BIND_PROXY_NIL,
  85                       const sc_bind_proxy &p007 = SC_BIND_PROXY_NIL,
  86                       const sc_bind_proxy &p008 = SC_BIND_PROXY_NIL,
  87                       const sc_bind_proxy &p009 = SC_BIND_PROXY_NIL,
  88                       const sc_bind_proxy &p010 = SC_BIND_PROXY_NIL,
  89                       const sc_bind_proxy &p011 = SC_BIND_PROXY_NIL,
  90                       const sc_bind_proxy &p012 = SC_BIND_PROXY_NIL,
  91                       const sc_bind_proxy &p013 = SC_BIND_PROXY_NIL,
  92                       const sc_bind_proxy &p014 = SC_BIND_PROXY_NIL,
  93                       const sc_bind_proxy &p015 = SC_BIND_PROXY_NIL,
  94                       const sc_bind_proxy &p016 = SC_BIND_PROXY_NIL,
  95                       const sc_bind_proxy &p017 = SC_BIND_PROXY_NIL,
  96                       const sc_bind_proxy &p018 = SC_BIND_PROXY_NIL,
  97                       const sc_bind_proxy &p019 = SC_BIND_PROXY_NIL,
  98                       const sc_bind_proxy &p020 = SC_BIND_PROXY_NIL,
  99                       const sc_bind_proxy &p021 = SC_BIND_PROXY_NIL,
 100                       const sc_bind_proxy &p022 = SC_BIND_PROXY_NIL,
 101                       const sc_bind_proxy &p023 = SC_BIND_PROXY_NIL,
 102                       const sc_bind_proxy &p024 = SC_BIND_PROXY_NIL,
 103                       const sc_bind_proxy &p025 = SC_BIND_PROXY_NIL,
 104                       const sc_bind_proxy &p026 = SC_BIND_PROXY_NIL,
 105                       const sc_bind_proxy &p027 = SC_BIND_PROXY_NIL,
 106                       const sc_bind_proxy &p028 = SC_BIND_PROXY_NIL,
 107                       const sc_bind_proxy &p029 = SC_BIND_PROXY_NIL,
 108                       const sc_bind_proxy &p030 = SC_BIND_PROXY_NIL,
 109                       const sc_bind_proxy &p031 = SC_BIND_PROXY_NIL,
 110                       const sc_bind_proxy &p032 = SC_BIND_PROXY_NIL,
 111                       const sc_bind_proxy &p033 = SC_BIND_PROXY_NIL,
 112                       const sc_bind_proxy &p034 = SC_BIND_PROXY_NIL,
 113                       const sc_bind_proxy &p035 = SC_BIND_PROXY_NIL,
 114                       const sc_bind_proxy &p036 = SC_BIND_PROXY_NIL,
 115                       const sc_bind_proxy &p037 = SC_BIND_PROXY_NIL,
 116                       const sc_bind_proxy &p038 = SC_BIND_PROXY_NIL,
 117                       const sc_bind_proxy &p039 = SC_BIND_PROXY_NIL,
 118                       const sc_bind_proxy &p040 = SC_BIND_PROXY_NIL,
 119                       const sc_bind_proxy &p041 = SC_BIND_PROXY_NIL,
 120                       const sc_bind_proxy &p042 = SC_BIND_PROXY_NIL,
 121                       const sc_bind_proxy &p043 = SC_BIND_PROXY_NIL,
 122                       const sc_bind_proxy &p044 = SC_BIND_PROXY_NIL,
 123                       const sc_bind_proxy &p045 = SC_BIND_PROXY_NIL,
 124                       const sc_bind_proxy &p046 = SC_BIND_PROXY_NIL,
 125                       const sc_bind_proxy &p047 = SC_BIND_PROXY_NIL,
 126                       const sc_bind_proxy &p048 = SC_BIND_PROXY_NIL,
 127                       const sc_bind_proxy &p049 = SC_BIND_PROXY_NIL,
 128                       const sc_bind_proxy &p050 = SC_BIND_PROXY_NIL,
 129                       const sc_bind_proxy &p051 = SC_BIND_PROXY_NIL,
 130                       const sc_bind_proxy &p052 = SC_BIND_PROXY_NIL,
 131                       const sc_bind_proxy &p053 = SC_BIND_PROXY_NIL,
 132                       const sc_bind_proxy &p054 = SC_BIND_PROXY_NIL,
 133                       const sc_bind_proxy &p055 = SC_BIND_PROXY_NIL,
 134                       const sc_bind_proxy &p056 = SC_BIND_PROXY_NIL,
 135                       const sc_bind_proxy &p057 = SC_BIND_PROXY_NIL,
 136                       const sc_bind_proxy &p058 = SC_BIND_PROXY_NIL,
 137                       const sc_bind_proxy &p059 = SC_BIND_PROXY_NIL,
 138                       const sc_bind_proxy &p060 = SC_BIND_PROXY_NIL,
 139                       const sc_bind_proxy &p061 = SC_BIND_PROXY_NIL,
 140                       const sc_bind_proxy &p062 = SC_BIND_PROXY_NIL,
 141                       const sc_bind_proxy &p063 = SC_BIND_PROXY_NIL,
 142                       const sc_bind_proxy &p064 = SC_BIND_PROXY_NIL);
 143
 144     virtual const std::vector<sc_object *> &get_child_objects() const;
 145     virtual const std::vector<sc_event *> &get_child_events() const;
 146
 147   protected:
 148     sc_module(const sc_module_name &);
 149     sc_module();
 150
 151     /* Deprecated, but used in the regression tests. */
 152     void end_module() {}
 153
 154     void reset_signal_is(const sc_in<bool> &, bool);
 155     void reset_signal_is(const sc_inout<bool> &, bool);
 156     void reset_signal_is(const sc_out<bool> &, bool);
 157     void reset_signal_is(const sc_signal_in_if<bool> &, bool);
 158
 159     void async_reset_signal_is(const sc_in<bool> &, bool);
 160     void async_reset_signal_is(const sc_inout<bool> &, bool);
 161     void async_reset_signal_is(const sc_out<bool> &, bool);
 162     void async_reset_signal_is(const sc_signal_in_if<bool> &, bool);
 163
 164     sc_sensitive sensitive;
 165
 166     void dont_initialize();
 167     void set_stack_size(size_t);
 168
 169     void next_trigger();
 170     void next_trigger(const sc_event &);
 171     void next_trigger(const sc_event_or_list &);
 172     void next_trigger(const sc_event_and_list &);
 173     void next_trigger(const sc_time &);
 174     void next_trigger(double, sc_time_unit);
 175     void next_trigger(const sc_time &, const sc_event &);
 176     void next_trigger(double, sc_time_unit, const sc_event &);
 177     void next_trigger(const sc_time &, const sc_event_or_list &);
 178     void next_trigger(double, sc_time_unit, const sc_event_or_list &);
 179     void next_trigger(const sc_time &, const sc_event_and_list &);
 180     void next_trigger(double, sc_time_unit, const sc_event_and_list &);
 181
 182     void wait();
 183     void wait(int);
 184     void wait(const sc_event &);
 185     void wait(const sc_event_or_list &);
 186     void wait(const sc_event_and_list &);
 187     void wait(const sc_time &);
 188     void wait(double, sc_time_unit);
 189     void wait(const sc_time &, const sc_event &);
 190     void wait(double, sc_time_unit, const sc_event &);
 191     void wait(const sc_time &, const sc_event_or_list &);
 192     void wait(double, sc_time_unit, const sc_event_or_list &);
 193     void wait(const sc_time &, const sc_event_and_list &);
 194     void wait(double, sc_time_unit, const sc_event_and_list &);
 195
 196     // Nonstandard
 197     void halt();
 198     void at_posedge(const sc_signal_in_if<bool> &);
 199     void at_posedge(const sc_signal_in_if<sc_dt::sc_logic> &);
 200     void at_negedge(const sc_signal_in_if<bool> &);
 201     void at_negedge(const sc_signal_in_if<sc_dt::sc_logic> &);
 202
 203     virtual void before_end_of_elaboration() {}
 204     virtual void end_of_elaboration() {}
 205     virtual void start_of_simulation() {}
 206     virtual void end_of_simulation() {}
 207
 208   private:
 209     // Disabled
 210     sc_module(const sc_module &) : sc_object() {};
 211     sc_module &operator = (const sc_module &) { return *this; }
 212 };
 213
 214 void next_trigger();
 215 void next_trigger(const sc_event &);
 216 void next_trigger(const sc_event_or_list &);
 217 void next_trigger(const sc_event_and_list &);
 218 void next_trigger(const sc_time &);
 219 void next_trigger(double, sc_time_unit);
 220 void next_trigger(const sc_time &, const sc_event &);
 221 void next_trigger(double, sc_time_unit, const sc_event &);
 222 void next_trigger(const sc_time &, const sc_event_or_list &);
 223 void next_trigger(double, sc_time_unit, const sc_event_or_list &);
 224 void next_trigger(const sc_time &, const sc_event_and_list &);
 225 void next_trigger(double, sc_time_unit, const sc_event_and_list &);
 226
 227 void wait();
 228 void wait(int);
 229 void wait(const sc_event &);
 230 void wait(const sc_event_or_list &);
 231 void wait(const sc_event_and_list &);
 232 void wait(const sc_time &);
 233 void wait(double, sc_time_unit);
 234 void wait(const sc_time &, const sc_event &);
 235 void wait(double, sc_time_unit, const sc_event &);
 236 void wait(const sc_time &, const sc_event_or_list &);
 237 void wait(double, sc_time_unit, const sc_event_or_list &);
 238 void wait(const sc_time &, const sc_event_and_list &);
 239 void wait(double, sc_time_unit, const sc_event_and_list &);
 240
 241 #define SC_MODULE(name) struct name : ::sc_core::sc_module
 242
 243 #define SC_CTOR(name) \
 244     typedef name SC_CURRENT_USER_MODULE; \
 245     name(::sc_core::sc_module_name)
 246
 247 #define SC_HAS_PROCESS(name) typedef name SC_CURRENT_USER_MODULE
 248
 249 #define SC_METHOD(name) /* Implementation defined */
 250 #define SC_THREAD(name) /* Implementation defined */
 251 #define SC_CTHREAD(name, clk) /* Implementation defined */
 252
 253 // Nonstandard
 254 // Documentation for this is very scarce, but it looks like it's supposed to
 255 // stop the currently executing cthread, or if a cthread isn't running report
 256 // an error.
 257 void halt();
 258 void at_posedge(const sc_signal_in_if<bool> &);
 259 void at_posedge(const sc_signal_in_if<sc_dt::sc_logic> &);
 260 void at_negedge(const sc_signal_in_if<bool> &);
 261 void at_negedge(const sc_signal_in_if<sc_dt::sc_logic> &);
 262
 263 const char *sc_gen_unique_name(const char *);
 264
 265 typedef sc_module sc_behavior;
 266 typedef sc_module sc_channel;
 267
 268 bool sc_start_of_simulation_invoked();
 269 bool sc_end_of_simulation_invoked();
 270
 271 // Nonstandard
 272 // Allocates a module of type x and records a pointer to it so that it gets
 273 // destructed automatically at the end of the simulation.
 274 sc_module *sc_module_sc_new(sc_module *);
 275 #define SC_NEW(x) ::sc_core::sc_module_sc_new(new x);
 276
 277 // Nonstandard
 278 // In the Accellera implementation, this macro calls sc_set_location to record
 279 // the current file and line, calls wait, and then calls it again to clear the
 280 // file and line. We'll ignore the sc_set_location calls for now.
 281 #define SC_WAIT() ::sc_core::wait();
 282
 283 // Nonstandard
 284 // Same as above, but passes through an argument.
 285 #define SC_WAITN(n) ::sc_core::wait(n);
 286
 287 // Nonstandard
 288 #define SC_WAIT_UNTIL(expr) do { SC_WAIT(); } while (!(expr))
 289
 290 } // namespace sc_core
 291
 292 #endif  //__SYSTEMC_EXT_CORE_SC_MODULE_HH__