1 /* Copyright (C) 2011-2018 Free Software Foundation, Inc. 2 Contributed by Torvald Riegel <triegel@redhat.com>. 3 4 This file is part of the GNU Transactional Memory Library (libitm). 5 6 Libitm is free software; you can redistribute it and/or modify it 7 under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 Libitm is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 13 FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 more details. 15 16 Under Section 7 of GPL version 3, you are granted additional 17 permissions described in the GCC Runtime Library Exception, version 18 3.1, as published by the Free Software Foundation. 19 20 You should have received a copy of the GNU General Public License and 21 a copy of the GCC Runtime Library Exception along with this program; 22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 <http://www.gnu.org/licenses/>. */ 24 25 #ifndef DISPATCH_H 26 #define DISPATCH_H 1 27 28 #include "libitm.h" 29 #include "common.h" 30 31 // Creates ABI load/store methods (can be made virtual or static using M, 32 // use M2 to create separate methods names for virtual and static) 33 // The _PV variants are for the pure-virtual methods in the base class. 34 #define ITM_READ_M(T, LSMOD, M, M2) \ 35 M _ITM_TYPE_##T ITM_REGPARM ITM_##LSMOD##T##M2 (const _ITM_TYPE_##T *ptr) \ 36 { \ 37 return load(ptr, abi_dispatch::LSMOD); \ 38 } 39 40 #define ITM_READ_M_PV(T, LSMOD, M, M2) \ 41 M _ITM_TYPE_##T ITM_REGPARM ITM_##LSMOD##T##M2 (const _ITM_TYPE_##T *ptr) \ 42 = 0; 43 44 #define ITM_WRITE_M(T, LSMOD, M, M2) \ 45 M void ITM_REGPARM ITM_##LSMOD##T##M2 (_ITM_TYPE_##T *ptr, \ 46 _ITM_TYPE_##T val) \ 47 { \ 48 store(ptr, val, abi_dispatch::LSMOD); \ 49 } 50 51 #define ITM_WRITE_M_PV(T, LSMOD, M, M2) \ 52 M void ITM_REGPARM ITM_##LSMOD##T##M2 (_ITM_TYPE_##T *ptr, \ 53 _ITM_TYPE_##T val) \ 54 = 0; 55 56 // Creates ABI load/store methods for all load/store modifiers for a particular 57 // type. 58 #define CREATE_DISPATCH_METHODS_T(T, M, M2) \ 59 ITM_READ_M(T, R, M, M2) \ 60 ITM_READ_M(T, RaR, M, M2) \ 61 ITM_READ_M(T, RaW, M, M2) \ 62 ITM_READ_M(T, RfW, M, M2) \ 63 ITM_WRITE_M(T, W, M, M2) \ 64 ITM_WRITE_M(T, WaR, M, M2) \ 65 ITM_WRITE_M(T, WaW, M, M2) 66 #define CREATE_DISPATCH_METHODS_T_PV(T, M, M2) \ 67 ITM_READ_M_PV(T, R, M, M2) \ 68 ITM_READ_M_PV(T, RaR, M, M2) \ 69 ITM_READ_M_PV(T, RaW, M, M2) \ 70 ITM_READ_M_PV(T, RfW, M, M2) \ 71 ITM_WRITE_M_PV(T, W, M, M2) \ 72 ITM_WRITE_M_PV(T, WaR, M, M2) \ 73 ITM_WRITE_M_PV(T, WaW, M, M2) 74 75 // Creates ABI load/store methods for all types. 76 // See CREATE_DISPATCH_FUNCTIONS for comments. 77 #define CREATE_DISPATCH_METHODS(M, M2) \ 78 CREATE_DISPATCH_METHODS_T (U1, M, M2) \ 79 CREATE_DISPATCH_METHODS_T (U2, M, M2) \ 80 CREATE_DISPATCH_METHODS_T (U4, M, M2) \ 81 CREATE_DISPATCH_METHODS_T (U8, M, M2) \ 82 CREATE_DISPATCH_METHODS_T (F, M, M2) \ 83 CREATE_DISPATCH_METHODS_T (D, M, M2) \ 84 CREATE_DISPATCH_METHODS_T (E, M, M2) \ 85 CREATE_DISPATCH_METHODS_T (CF, M, M2) \ 86 CREATE_DISPATCH_METHODS_T (CD, M, M2) \ 87 CREATE_DISPATCH_METHODS_T (CE, M, M2) 88 #define CREATE_DISPATCH_METHODS_PV(M, M2) \ 89 CREATE_DISPATCH_METHODS_T_PV (U1, M, M2) \ 90 CREATE_DISPATCH_METHODS_T_PV (U2, M, M2) \ 91 CREATE_DISPATCH_METHODS_T_PV (U4, M, M2) \ 92 CREATE_DISPATCH_METHODS_T_PV (U8, M, M2) \ 93 CREATE_DISPATCH_METHODS_T_PV (F, M, M2) \ 94 CREATE_DISPATCH_METHODS_T_PV (D, M, M2) \ 95 CREATE_DISPATCH_METHODS_T_PV (E, M, M2) \ 96 CREATE_DISPATCH_METHODS_T_PV (CF, M, M2) \ 97 CREATE_DISPATCH_METHODS_T_PV (CD, M, M2) \ 98 CREATE_DISPATCH_METHODS_T_PV (CE, M, M2) 99 100 // Creates memcpy/memmove/memset methods. 101 #define CREATE_DISPATCH_METHODS_MEM() \ 102 virtual void memtransfer(void *dst, const void* src, size_t size, \ 103 bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod) \ 104 { \ 105 if (size > 0) \ 106 memtransfer_static(dst, src, size, may_overlap, dst_mod, src_mod); \ 107 } \ 108 virtual void memset(void *dst, int c, size_t size, ls_modifier mod) \ 109 { \ 110 if (size > 0) \ 111 memset_static(dst, c, size, mod); \ 112 } 113 114 #define CREATE_DISPATCH_METHODS_MEM_PV() \ 115 virtual void memtransfer(void *dst, const void* src, size_t size, \ 116 bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod) = 0; \ 117 virtual void memset(void *dst, int c, size_t size, ls_modifier mod) = 0; 118 119 120 // Creates ABI load/store functions that can target either a class or an 121 // object. 122 #define ITM_READ(T, LSMOD, TARGET, M2) \ 123 _ITM_TYPE_##T ITM_REGPARM _ITM_##LSMOD##T (const _ITM_TYPE_##T *ptr) \ 124 { \ 125 return TARGET ITM_##LSMOD##T##M2(ptr); \ 126 } 127 128 #define ITM_WRITE(T, LSMOD, TARGET, M2) \ 129 void ITM_REGPARM _ITM_##LSMOD##T (_ITM_TYPE_##T *ptr, _ITM_TYPE_##T val) \ 130 { \ 131 TARGET ITM_##LSMOD##T##M2(ptr, val); \ 132 } 133 134 // Creates ABI load/store functions for all load/store modifiers for a 135 // particular type. 136 #define CREATE_DISPATCH_FUNCTIONS_T(T, TARGET, M2) \ 137 ITM_READ(T, R, TARGET, M2) \ 138 ITM_READ(T, RaR, TARGET, M2) \ 139 ITM_READ(T, RaW, TARGET, M2) \ 140 ITM_READ(T, RfW, TARGET, M2) \ 141 ITM_WRITE(T, W, TARGET, M2) \ 142 ITM_WRITE(T, WaR, TARGET, M2) \ 143 ITM_WRITE(T, WaW, TARGET, M2) 144 145 // Creates ABI memcpy/memmove/memset functions. 146 #define ITM_MEMTRANSFER_DEF(TARGET, M2, NAME, READ, WRITE) \ 147 void ITM_REGPARM _ITM_memcpy##NAME(void *dst, const void *src, size_t size) \ 148 { \ 149 TARGET memtransfer##M2 (dst, src, size, \ 150 false, GTM::abi_dispatch::WRITE, GTM::abi_dispatch::READ); \ 151 } \ 152 void ITM_REGPARM _ITM_memmove##NAME(void *dst, const void *src, size_t size) \ 153 { \ 154 TARGET memtransfer##M2 (dst, src, size, \ 155 GTM::abi_dispatch::memmove_overlap_check(dst, src, size, \ 156 GTM::abi_dispatch::WRITE, GTM::abi_dispatch::READ), \ 157 GTM::abi_dispatch::WRITE, GTM::abi_dispatch::READ); \ 158 } 159 160 #define ITM_MEMSET_DEF(TARGET, M2, WRITE) \ 161 void ITM_REGPARM _ITM_memset##WRITE(void *dst, int c, size_t size) \ 162 { \ 163 TARGET memset##M2 (dst, c, size, GTM::abi_dispatch::WRITE); \ 164 } \ 165 166 167 // ??? The number of virtual methods is large (7*4 for integers, 7*6 for FP, 168 // 7*3 for vectors). Is the cache footprint so costly that we should go for 169 // a small table instead (i.e., only have two virtual load/store methods for 170 // each supported type)? Note that this doesn't affect custom code paths at 171 // all because these use only direct calls. 172 // A large cache footprint could especially decrease HTM performance (due 173 // to HTM capacity). We could add the modifier (RaR etc.) as parameter, which 174 // would give us just 4*2+6*2+3*2 functions (so we'd just need one line for 175 // the integer loads/stores), but then the modifier can be checked only at 176 // runtime. 177 // For memcpy/memmove/memset, we just have two virtual methods (memtransfer 178 // and memset). 179 #define CREATE_DISPATCH_FUNCTIONS(TARGET, M2) \ 180 CREATE_DISPATCH_FUNCTIONS_T (U1, TARGET, M2) \ 181 CREATE_DISPATCH_FUNCTIONS_T (U2, TARGET, M2) \ 182 CREATE_DISPATCH_FUNCTIONS_T (U4, TARGET, M2) \ 183 CREATE_DISPATCH_FUNCTIONS_T (U8, TARGET, M2) \ 184 CREATE_DISPATCH_FUNCTIONS_T (F, TARGET, M2) \ 185 CREATE_DISPATCH_FUNCTIONS_T (D, TARGET, M2) \ 186 CREATE_DISPATCH_FUNCTIONS_T (E, TARGET, M2) \ 187 CREATE_DISPATCH_FUNCTIONS_T (CF, TARGET, M2) \ 188 CREATE_DISPATCH_FUNCTIONS_T (CD, TARGET, M2) \ 189 CREATE_DISPATCH_FUNCTIONS_T (CE, TARGET, M2) \ 190 ITM_MEMTRANSFER_DEF(TARGET, M2, RnWt, NONTXNAL, W) \ 191 ITM_MEMTRANSFER_DEF(TARGET, M2, RnWtaR, NONTXNAL, WaR) \ 192 ITM_MEMTRANSFER_DEF(TARGET, M2, RnWtaW, NONTXNAL, WaW) \ 193 ITM_MEMTRANSFER_DEF(TARGET, M2, RtWn, R, NONTXNAL) \ 194 ITM_MEMTRANSFER_DEF(TARGET, M2, RtWt, R, W) \ 195 ITM_MEMTRANSFER_DEF(TARGET, M2, RtWtaR, R, WaR) \ 196 ITM_MEMTRANSFER_DEF(TARGET, M2, RtWtaW, R, WaW) \ 197 ITM_MEMTRANSFER_DEF(TARGET, M2, RtaRWn, RaR, NONTXNAL) \ 198 ITM_MEMTRANSFER_DEF(TARGET, M2, RtaRWt, RaR, W) \ 199 ITM_MEMTRANSFER_DEF(TARGET, M2, RtaRWtaR, RaR, WaR) \ 200 ITM_MEMTRANSFER_DEF(TARGET, M2, RtaRWtaW, RaR, WaW) \ 201 ITM_MEMTRANSFER_DEF(TARGET, M2, RtaWWn, RaW, NONTXNAL) \ 202 ITM_MEMTRANSFER_DEF(TARGET, M2, RtaWWt, RaW, W) \ 203 ITM_MEMTRANSFER_DEF(TARGET, M2, RtaWWtaR, RaW, WaR) \ 204 ITM_MEMTRANSFER_DEF(TARGET, M2, RtaWWtaW, RaW, WaW) \ 205 ITM_MEMSET_DEF(TARGET, M2, W) \ 206 ITM_MEMSET_DEF(TARGET, M2, WaR) \ 207 ITM_MEMSET_DEF(TARGET, M2, WaW) 208 209 210 // Creates ABI load/store functions that delegate to a transactional memcpy. 211 #define ITM_READ_MEMCPY(T, LSMOD, TARGET, M2) \ 212 _ITM_TYPE_##T ITM_REGPARM _ITM_##LSMOD##T (const _ITM_TYPE_##T *ptr)\ 213 { \ 214 _ITM_TYPE_##T v; \ 215 TARGET memtransfer##M2(&v, ptr, sizeof(_ITM_TYPE_##T), false, \ 216 GTM::abi_dispatch::NONTXNAL, GTM::abi_dispatch::LSMOD); \ 217 return v; \ 218 } 219 220 #define ITM_WRITE_MEMCPY(T, LSMOD, TARGET, M2) \ 221 void ITM_REGPARM _ITM_##LSMOD##T (_ITM_TYPE_##T *ptr, _ITM_TYPE_##T val)\ 222 { \ 223 TARGET memtransfer##M2(ptr, &val, sizeof(_ITM_TYPE_##T), false, \ 224 GTM::abi_dispatch::LSMOD, GTM::abi_dispatch::NONTXNAL); \ 225 } 226 227 #define CREATE_DISPATCH_FUNCTIONS_T_MEMCPY(T, TARGET, M2) \ 228 ITM_READ_MEMCPY(T, R, TARGET, M2) \ 229 ITM_READ_MEMCPY(T, RaR, TARGET, M2) \ 230 ITM_READ_MEMCPY(T, RaW, TARGET, M2) \ 231 ITM_READ_MEMCPY(T, RfW, TARGET, M2) \ 232 ITM_WRITE_MEMCPY(T, W, TARGET, M2) \ 233 ITM_WRITE_MEMCPY(T, WaR, TARGET, M2) \ 234 ITM_WRITE_MEMCPY(T, WaW, TARGET, M2) 235 236 237 namespace GTM HIDDEN { 238 239 struct gtm_transaction_cp; 240 241 struct method_group 242 { 243 // Start using a TM method from this group. This constructs required meta 244 // data on demand when this method group is actually used. Will be called 245 // either on first use or after a previous call to fini(). 246 virtual void init() = 0; 247 // Stop using any method from this group for now. This can be used to 248 // destruct meta data as soon as this method group is not used anymore. 249 virtual void fini() = 0; 250 // This can be overriden to implement more light-weight re-initialization. reinitmethod_group251 virtual void reinit() 252 { 253 fini(); 254 init(); 255 } 256 }; 257 258 259 // This is the base interface that all TM methods have to implement. 260 struct abi_dispatch 261 { 262 public: 263 enum ls_modifier { NONTXNAL, R, RaR, RaW, RfW, W, WaR, WaW }; 264 265 private: 266 // Disallow copies 267 abi_dispatch(const abi_dispatch &) = delete; 268 abi_dispatch& operator=(const abi_dispatch &) = delete; 269 270 public: 271 // Starts or restarts a transaction. Is called right before executing the 272 // transactional application code (by either returning from 273 // gtm_thread::begin_transaction or doing the longjmp when restarting). 274 // Returns NO_RESTART if the transaction started successfully. Returns 275 // a real restart reason if it couldn't start and does need to abort. This 276 // allows TM methods to just give up and delegate ensuring progress to the 277 // restart mechanism. If it returns a restart reason, this call must be 278 // idempotent because it will trigger the restart mechanism, which could 279 // switch to a different TM method. 280 virtual gtm_restart_reason begin_or_restart() = 0; 281 // Tries to commit the transaction. Iff this returns true, the transaction 282 // got committed and all per-transaction data will have been reset. 283 // Currently, this is called only for the commit of the outermost 284 // transaction, or when switching to serial mode (which can happen in a 285 // nested transaction). 286 // If privatization safety must be ensured in a quiescence-based way, set 287 // priv_time to a value different to 0. Nontransactional code will not be 288 // executed after this commit until all registered threads' shared_state is 289 // larger than or equal to this value. 290 virtual bool trycommit(gtm_word& priv_time) = 0; 291 // Rolls back a transaction. Called on abort or after trycommit() returned 292 // false. 293 virtual void rollback(gtm_transaction_cp *cp = 0) = 0; 294 // Returns true iff the snapshot is most recent, which will be the case if 295 // this transaction cannot be the reason why other transactions cannot 296 // ensure privatization safety. 297 virtual bool snapshot_most_recent() = 0; 298 299 // Return an alternative method that is compatible with the current 300 // method but supports closed nesting. Return zero if there is none. 301 // Note that too be compatible, it must be possible to switch to this other 302 // method on begin of a nested transaction without committing or restarting 303 // the parent method. closed_nesting_alternativeabi_dispatch304 virtual abi_dispatch* closed_nesting_alternative() { return 0; } 305 // Returns true iff this method group supports the current situation. 306 // NUMBER_OF_THREADS is the current number of threads that might execute 307 // transactions. supportsabi_dispatch308 virtual bool supports(unsigned number_of_threads) { return true; } 309 read_onlyabi_dispatch310 bool read_only () const { return m_read_only; } write_throughabi_dispatch311 bool write_through() const { return m_write_through; } can_run_uninstrumented_codeabi_dispatch312 bool can_run_uninstrumented_code() const 313 { 314 return m_can_run_uninstrumented_code; 315 } 316 // Returns true iff this TM method supports closed nesting. closed_nestingabi_dispatch317 bool closed_nesting() const { return m_closed_nesting; } 318 // Returns STATE_SERIAL or STATE_SERIAL | STATE_IRREVOCABLE iff the TM 319 // method only works for serial-mode transactions. requires_serialabi_dispatch320 uint32_t requires_serial() const { return m_requires_serial; } get_method_groupabi_dispatch321 method_group* get_method_group() const { return m_method_group; } 322 newabi_dispatch323 static void *operator new(size_t s) { return xmalloc (s); } deleteabi_dispatch324 static void operator delete(void *p) { free (p); } 325 326 public: 327 static bool memmove_overlap_check(void *dst, const void *src, size_t size, 328 ls_modifier dst_mod, ls_modifier src_mod); 329 330 // Creates the ABI dispatch methods for loads and stores. 331 // ??? Should the dispatch table instead be embedded in the dispatch object 332 // to avoid the indirect lookup in the vtable? 333 CREATE_DISPATCH_METHODS_PV(virtual, ) 334 // Creates the ABI dispatch methods for memcpy/memmove/memset. 335 CREATE_DISPATCH_METHODS_MEM_PV() 336 337 protected: 338 const bool m_read_only; 339 const bool m_write_through; 340 const bool m_can_run_uninstrumented_code; 341 const bool m_closed_nesting; 342 const uint32_t m_requires_serial; 343 method_group* const m_method_group; abi_dispatchabi_dispatch344 abi_dispatch(bool ro, bool wt, bool uninstrumented, bool closed_nesting, 345 uint32_t requires_serial, method_group* mg) : 346 m_read_only(ro), m_write_through(wt), 347 m_can_run_uninstrumented_code(uninstrumented), 348 m_closed_nesting(closed_nesting), m_requires_serial(requires_serial), 349 m_method_group(mg) 350 { } 351 }; 352 353 } 354 355 #endif // DISPATCH_H 356