src/systemc/ext/core/sc_process_handle.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_PROCESS_HANDLE_HH__
  31 #define __SYSTEMC_EXT_CORE_SC_PROCESS_HANDLE_HH__
  32
  33 #include <exception>
  34 #include <vector>
  35
  36 namespace sc_gem5
  37 {
  38
  39 class Process;
  40
  41 struct ProcessFuncWrapper
  42 {
  43     virtual void call() = 0;
  44     virtual ~ProcessFuncWrapper() {}
  45 };
  46
  47 template <typename T>
  48 struct ProcessMemberFuncWrapper : public ProcessFuncWrapper
  49 {
  50     typedef void (T::*TFunc)();
  51     T *t;
  52     TFunc func;
  53
  54     ProcessMemberFuncWrapper(T *t, TFunc func) : t(t), func(func) {}
  55
  56     void call() override { (t->*func)(); }
  57 };
  58
  59 struct ExceptionWrapperBase
  60 {
  61     virtual void throw_it() = 0;
  62 };
  63
  64 template <typename T>
  65 struct ExceptionWrapper : public ExceptionWrapperBase
  66 {
  67     const T &t;
  68     ExceptionWrapper(const T &t) : t(t) {}
  69
  70     void throw_it() { throw t; }
  71 };
  72
  73 void throw_it_wrapper(Process *p, ExceptionWrapperBase &exc, bool inc_kids);
  74
  75 } // namespace sc_gem5
  76
  77 namespace sc_core
  78 {
  79
  80 class sc_event;
  81 class sc_object;
  82
  83 enum sc_curr_proc_kind
  84 {
  85     SC_NO_PROC_,
  86     SC_METHOD_PROC_,
  87     SC_THREAD_PROC_,
  88     SC_CTHREAD_PROC_
  89 };
  90
  91 enum sc_descendent_inclusion_info
  92 {
  93     SC_NO_DESCENDANTS,
  94     SC_INCLUDE_DESCENDANTS
  95 };
  96
  97 class sc_unwind_exception : public std::exception
  98 {
  99   public:
 100     virtual const char *what() const throw();
 101     virtual bool is_reset() const;
 102
 103     // Nonstandard.
 104     // These should be protected, but I think this is to enable catch by
 105     // value.
 106   public:
 107     sc_unwind_exception(const sc_unwind_exception &);
 108     virtual ~sc_unwind_exception() throw();
 109
 110   protected:
 111     bool _isReset;
 112     sc_unwind_exception();
 113 };
 114
 115 // Deprecated
 116 // An incomplete version of sc_process_b to satisfy the tests.
 117 class sc_process_b
 118 {
 119   public:
 120     const char *file;
 121     int lineno;
 122     const char *name();
 123     const char *kind();
 124 };
 125
 126 // Deprecated
 127 sc_process_b *sc_get_curr_process_handle();
 128 static inline sc_process_b *
 129 sc_get_current_process_b()
 130 {
 131     return sc_get_curr_process_handle();
 132 }
 133
 134 // Deprecated/nonstandard
 135 struct sc_curr_proc_info
 136 {
 137     sc_process_b *process_handle;
 138     sc_curr_proc_kind kind;
 139     sc_curr_proc_info() : process_handle(NULL), kind(SC_NO_PROC_) {}
 140 };
 141 typedef const sc_curr_proc_info *sc_curr_proc_handle;
 142
 143 class sc_process_handle
 144 {
 145   private:
 146     ::sc_gem5::Process *_gem5_process;
 147
 148   public:
 149     sc_process_handle();
 150     sc_process_handle(const sc_process_handle &);
 151     explicit sc_process_handle(sc_object *);
 152     ~sc_process_handle();
 153
 154     // These non-standard operators provide access to the data structure which
 155     // actually tracks the process within gem5. By making them operators, we
 156     // can minimize the symbols added to the class namespace.
 157     operator ::sc_gem5::Process * () const { return _gem5_process; }
 158     sc_process_handle &
 159     operator = (::sc_gem5::Process *p)
 160     {
 161         _gem5_process = p;
 162         return *this;
 163     }
 164
 165     bool valid() const;
 166
 167     sc_process_handle &operator = (const sc_process_handle &);
 168     bool operator == (const sc_process_handle &) const;
 169     bool operator != (const sc_process_handle &) const;
 170     bool operator < (const sc_process_handle &) const;
 171     void swap(sc_process_handle &);
 172
 173     const char *name() const;
 174     sc_curr_proc_kind proc_kind() const;
 175     const std::vector<sc_object *> &get_child_objects() const;
 176     const std::vector<sc_event *> &get_child_events() const;
 177     sc_object *get_parent_object() const;
 178     sc_object *get_process_object() const;
 179     bool dynamic() const;
 180     bool terminated() const;
 181     const sc_event &terminated_event() const;
 182
 183     void suspend(sc_descendent_inclusion_info include_descendants=
 184                  SC_NO_DESCENDANTS);
 185     void resume(sc_descendent_inclusion_info include_descendants=
 186                 SC_NO_DESCENDANTS);
 187     void disable(sc_descendent_inclusion_info include_descendants=
 188                  SC_NO_DESCENDANTS);
 189     void enable(sc_descendent_inclusion_info include_descendants=
 190                 SC_NO_DESCENDANTS);
 191     void kill(sc_descendent_inclusion_info include_descendants=
 192               SC_NO_DESCENDANTS);
 193     void reset(sc_descendent_inclusion_info include_descendants=
 194                SC_NO_DESCENDANTS);
 195     bool is_unwinding();
 196     const sc_event &reset_event() const;
 197
 198     void sync_reset_on(sc_descendent_inclusion_info include_descendants=
 199                        SC_NO_DESCENDANTS);
 200     void sync_reset_off(sc_descendent_inclusion_info include_descendants=
 201                         SC_NO_DESCENDANTS);
 202
 203     template <typename T>
 204     void
 205     throw_it(const T &user_defined_exception,
 206              sc_descendent_inclusion_info include_descendants=
 207              SC_NO_DESCENDANTS)
 208     {
 209         ::sc_gem5::ExceptionWrapper<T> exc(user_defined_exception);
 210         ::sc_gem5::throw_it_wrapper(_gem5_process, exc,
 211                 include_descendants == SC_INCLUDE_DESCENDANTS);
 212     }
 213 };
 214
 215 sc_process_handle sc_get_current_process_handle();
 216 bool sc_is_unwinding();
 217
 218 // Nonstandard
 219 // See Accellera's kernel/sim_context.cpp for an explanation of what this is
 220 // supposed to do. It essentially selects what happens during certain
 221 // undefined situations.
 222 extern bool sc_allow_process_control_corners;
 223
 224 } // namespace sc_core
 225
 226 #endif  //__SYSTEMC_EXT_CORE_SC_PROCESS_HANDLE_HH__