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