src/systemc/ext/core/sc_event.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_EXT_CORE_SC_EVENT_HH__
  31 #define __SYSTEMC_EXT_CORE_SC_EVENT_HH__
  32
  33 #include <cassert>
  34 #include <set>
  35 #include <vector>
  36
  37 #include "sc_port.hh"
  38 #include "sc_time.hh"
  39
  40 namespace sc_gem5
  41 {
  42
  43 class Event;
  44 class SensitivityEventAndList;
  45 class SensitivityEventOrList;
  46
  47 }
  48
  49 namespace sc_core
  50 {
  51
  52 class sc_event;
  53 class sc_event_and_expr;
  54 class sc_event_or_expr;
  55 class sc_interface;
  56 class sc_object;
  57 class sc_port_base;
  58
  59 class sc_event_finder
  60 {
  61   protected:
  62     virtual ~sc_event_finder() {}
  63
  64   public:
  65     // Should be "implementation defined" but used in the tests.
  66     virtual const sc_event &find_event(sc_interface *if_p=NULL) const = 0;
  67 };
  68
  69 template <class IF>
  70 class sc_event_finder_t : public sc_event_finder
  71 {
  72   public:
  73     sc_event_finder_t(const sc_port_base &p,
  74                       const sc_event & (IF::*_method)() const) :
  75         _method(_method)
  76     {
  77         _port = dynamic_cast<const sc_port_b<IF> *>(&p);
  78         assert(_port);
  79     }
  80
  81     virtual ~sc_event_finder_t() {}
  82
  83     const sc_event &
  84     find_event(sc_interface *if_p=NULL) const override
  85     {
  86         const IF *iface = if_p ? dynamic_cast<const IF *>(if_p) :
  87             dynamic_cast<const IF *>(_port->get_interface());
  88         return (const_cast<IF *>(iface)->*_method)();
  89     }
  90
  91   private:
  92     const sc_port_b<IF> *_port;
  93     const sc_event &(IF::*_method)() const;
  94 };
  95
  96 class sc_event_and_list
  97 {
  98   public:
  99     sc_event_and_list();
 100     sc_event_and_list(const sc_event_and_list &);
 101     sc_event_and_list(const sc_event &);
 102     sc_event_and_list &operator = (const sc_event_and_list &);
 103     ~sc_event_and_list();
 104
 105     int size() const;
 106     void swap(sc_event_and_list &);
 107
 108     sc_event_and_list &operator &= (const sc_event &);
 109     sc_event_and_list &operator &= (const sc_event_and_list &);
 110
 111     sc_event_and_expr operator & (const sc_event &) const;
 112     sc_event_and_expr operator & (const sc_event_and_list &);
 113
 114   private:
 115     friend class sc_event_and_expr;
 116     friend class sc_gem5::SensitivityEventAndList;
 117
 118     explicit sc_event_and_list(bool auto_delete);
 119
 120     void insert(sc_event const &e);
 121     void insert(sc_event_and_list const &eal);
 122
 123     std::set<const sc_event *> events;
 124     bool autoDelete;
 125     mutable unsigned busy;
 126 };
 127
 128 class sc_event_or_list
 129 {
 130   public:
 131     sc_event_or_list();
 132     sc_event_or_list(const sc_event_or_list &);
 133     sc_event_or_list(const sc_event &);
 134     sc_event_or_list& operator = (const sc_event_or_list &);
 135     ~sc_event_or_list();
 136
 137     int size() const;
 138     void swap(sc_event_or_list &);
 139
 140     sc_event_or_list &operator |= (const sc_event &);
 141     sc_event_or_list &operator |= (const sc_event_or_list &);
 142
 143     sc_event_or_expr operator | (const sc_event &) const;
 144     sc_event_or_expr operator | (const sc_event_or_list &) const;
 145
 146   private:
 147     friend class sc_event_or_expr;
 148     friend class sc_gem5::SensitivityEventOrList;
 149
 150     explicit sc_event_or_list(bool auto_delete);
 151
 152     void insert(sc_event const &e);
 153     void insert(sc_event_or_list const &eol);
 154
 155     std::set<const sc_event *> events;
 156     bool autoDelete;
 157     mutable unsigned busy;
 158 };
 159
 160 class sc_event_and_expr
 161 {
 162   public:
 163     sc_event_and_expr(sc_event_and_expr const &e);
 164     operator const sc_event_and_list &() const;
 165
 166     void insert(sc_event const &e) const;
 167     void insert(sc_event_and_list const &eal) const;
 168
 169     ~sc_event_and_expr();
 170
 171   private:
 172     friend class sc_event_and_list;
 173     friend class sc_event;
 174
 175     sc_event_and_expr();
 176     mutable sc_event_and_list *list;
 177 };
 178
 179 sc_event_and_expr operator & (sc_event_and_expr, sc_event const &);
 180 sc_event_and_expr operator & (sc_event_and_expr, sc_event_and_list const &);
 181
 182 class sc_event_or_expr
 183 {
 184   public:
 185     sc_event_or_expr(sc_event_or_expr const &e);
 186     operator const sc_event_or_list &() const;
 187
 188     void insert(sc_event const &e) const;
 189     void insert(sc_event_or_list const &eol) const;
 190
 191     ~sc_event_or_expr();
 192
 193   private:
 194     friend class sc_event_or_list;
 195     friend class sc_event;
 196
 197     sc_event_or_expr();
 198     mutable sc_event_or_list *list;
 199 };
 200
 201 sc_event_or_expr operator | (sc_event_or_expr, sc_event const &);
 202 sc_event_or_expr operator | (sc_event_or_expr, sc_event_or_list const &);
 203
 204 class sc_event
 205 {
 206   public:
 207     sc_event();
 208     explicit sc_event(const char *);
 209     ~sc_event();
 210
 211     const char *name() const;
 212     const char *basename() const;
 213     bool in_hierarchy() const;
 214     sc_object *get_parent_object() const;
 215
 216     void notify();
 217     void notify(const sc_time &);
 218     void notify(double, sc_time_unit);
 219     void cancel();
 220
 221     // Nonstandard
 222     // Returns whether this event is currently triggered.
 223     bool triggered() const;
 224
 225     // Deprecated
 226     void notify_delayed();
 227     void notify_delayed(const sc_time &);
 228
 229     sc_event_and_expr operator & (const sc_event &) const;
 230     sc_event_and_expr operator & (const sc_event_and_list &) const;
 231     sc_event_or_expr operator | (const sc_event &) const;
 232     sc_event_or_expr operator | (const sc_event_or_list &) const;
 233
 234   private:
 235     // Disabled
 236     sc_event(const sc_event &) {}
 237     sc_event &operator = (const sc_event &) { return *this; }
 238
 239     friend class ::sc_gem5::Event;
 240     ::sc_gem5::Event *_gem5_event;
 241 };
 242
 243 const std::vector<sc_event *> &sc_get_top_level_events();
 244 sc_event *sc_find_event(const char *);
 245
 246 } // namespace sc_core
 247
 248 #endif  //__SYSTEMC_EXT_CORE_SC_INTERFACE_HH__