1 /* Copyright (C) 2011-2023 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.
251 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.
304 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.
308 virtual bool supports(unsigned number_of_threads) { return true; }
309
310 bool read_only () const { return m_read_only; }
311 bool write_through() const { return m_write_through; }
312 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.
317 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.
320 uint32_t requires_serial() const { return m_requires_serial; }
321 method_group* get_method_group() const { return m_method_group; }
322
323 static void *operator new(size_t s) { return xmalloc (s); }
324 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;
344 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