sc_process_handle.hh revision 12994:afce27405f70
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 bool _isReset; 112 sc_unwind_exception(); 113}; 114 115// Deprecated 116// An incomplete version of sc_process_b to satisfy the tests. 117class 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 127sc_process_b *sc_get_curr_process_handle(); 128static inline sc_process_b * 129sc_get_current_process_b() 130{ 131 return sc_get_curr_process_handle(); 132} 133 134// Deprecated/nonstandard 135struct 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}; 141typedef const sc_curr_proc_info *sc_curr_proc_handle; 142 143class 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 215sc_process_handle sc_get_current_process_handle(); 216bool 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. 222extern bool sc_allow_process_control_corners; 223 224} // namespace sc_core 225 226#endif //__SYSTEMC_EXT_CORE_SC_PROCESS_HANDLE_HH__ 227