OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libitm/] [dispatch.h] - Blame information for rev 737

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 737 jeremybenn
/* Copyright (C) 2011 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
  memtransfer_static(dst, src, size, may_overlap, dst_mod, src_mod); \
106
}                                                                     \
107
virtual void memset(void *dst, int c, size_t size, ls_modifier mod)  \
108
{                                                                     \
109
  memset_static(dst, c, size, mod);                                  \
110
}
111
 
112
#define CREATE_DISPATCH_METHODS_MEM_PV()  \
113
virtual void memtransfer(void *dst, const void* src, size_t size,       \
114
    bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod) = 0;     \
115
virtual void memset(void *dst, int c, size_t size, ls_modifier mod) = 0;
116
 
117
 
118
// Creates ABI load/store functions that can target either a class or an
119
// object.
120
#define ITM_READ(T, LSMOD, TARGET, M2)                                 \
121
  _ITM_TYPE_##T ITM_REGPARM _ITM_##LSMOD##T (const _ITM_TYPE_##T *ptr) \
122
  {                                                                    \
123
    return TARGET ITM_##LSMOD##T##M2(ptr);                            \
124
  }
125
 
126
#define ITM_WRITE(T, LSMOD, TARGET, M2)                                    \
127
  void ITM_REGPARM _ITM_##LSMOD##T (_ITM_TYPE_##T *ptr, _ITM_TYPE_##T val) \
128
  {                                                                        \
129
    TARGET ITM_##LSMOD##T##M2(ptr, val);                                  \
130
  }
131
 
132
// Creates ABI load/store functions for all load/store modifiers for a
133
// particular type.
134
#define CREATE_DISPATCH_FUNCTIONS_T(T, TARGET, M2) \
135
  ITM_READ(T, R, TARGET, M2)                \
136
  ITM_READ(T, RaR, TARGET, M2)              \
137
  ITM_READ(T, RaW, TARGET, M2)              \
138
  ITM_READ(T, RfW, TARGET, M2)              \
139
  ITM_WRITE(T, W, TARGET, M2)               \
140
  ITM_WRITE(T, WaR, TARGET, M2)             \
141
  ITM_WRITE(T, WaW, TARGET, M2)
142
 
143
// Creates ABI memcpy/memmove/memset functions.
144
#define ITM_MEMTRANSFER_DEF(TARGET, M2, NAME, READ, WRITE) \
145
void ITM_REGPARM _ITM_memcpy##NAME(void *dst, const void *src, size_t size)  \
146
{                                                                            \
147
  TARGET memtransfer##M2 (dst, src, size,                                   \
148
             false, GTM::abi_dispatch::WRITE, GTM::abi_dispatch::READ);      \
149
}                                                                            \
150
void ITM_REGPARM _ITM_memmove##NAME(void *dst, const void *src, size_t size) \
151
{                                                                            \
152
  TARGET memtransfer##M2 (dst, src, size,                                   \
153
      GTM::abi_dispatch::memmove_overlap_check(dst, src, size,               \
154
          GTM::abi_dispatch::WRITE, GTM::abi_dispatch::READ),                \
155
      GTM::abi_dispatch::WRITE, GTM::abi_dispatch::READ);                    \
156
}
157
 
158
#define ITM_MEMSET_DEF(TARGET, M2, WRITE) \
159
void ITM_REGPARM _ITM_memset##WRITE(void *dst, int c, size_t size) \
160
{                                                                  \
161
  TARGET memset##M2 (dst, c, size, GTM::abi_dispatch::WRITE);     \
162
}                                                                  \
163
 
164
 
165
// ??? The number of virtual methods is large (7*4 for integers, 7*6 for FP,
166
// 7*3 for vectors). Is the cache footprint so costly that we should go for
167
// a small table instead (i.e., only have two virtual load/store methods for
168
// each supported type)? Note that this doesn't affect custom code paths at
169
// all because these use only direct calls.
170
// A large cache footprint could especially decrease HTM performance (due
171
// to HTM capacity). We could add the modifier (RaR etc.) as parameter, which
172
// would give us just 4*2+6*2+3*2 functions (so we'd just need one line for
173
// the integer loads/stores), but then the modifier can be checked only at
174
// runtime.
175
// For memcpy/memmove/memset, we just have two virtual methods (memtransfer
176
// and memset).
177
#define CREATE_DISPATCH_FUNCTIONS(TARGET, M2)  \
178
  CREATE_DISPATCH_FUNCTIONS_T (U1, TARGET, M2) \
179
  CREATE_DISPATCH_FUNCTIONS_T (U2, TARGET, M2) \
180
  CREATE_DISPATCH_FUNCTIONS_T (U4, TARGET, M2) \
181
  CREATE_DISPATCH_FUNCTIONS_T (U8, TARGET, M2) \
182
  CREATE_DISPATCH_FUNCTIONS_T (F, TARGET, M2)  \
183
  CREATE_DISPATCH_FUNCTIONS_T (D, TARGET, M2)  \
184
  CREATE_DISPATCH_FUNCTIONS_T (E, TARGET, M2)  \
185
  CREATE_DISPATCH_FUNCTIONS_T (CF, TARGET, M2) \
186
  CREATE_DISPATCH_FUNCTIONS_T (CD, TARGET, M2) \
187
  CREATE_DISPATCH_FUNCTIONS_T (CE, TARGET, M2) \
188
  ITM_MEMTRANSFER_DEF(TARGET, M2, RnWt,     NONTXNAL, W)      \
189
  ITM_MEMTRANSFER_DEF(TARGET, M2, RnWtaR,   NONTXNAL, WaR)    \
190
  ITM_MEMTRANSFER_DEF(TARGET, M2, RnWtaW,   NONTXNAL, WaW)    \
191
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtWn,     R,      NONTXNAL) \
192
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtWt,     R,      W)        \
193
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtWtaR,   R,      WaR)      \
194
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtWtaW,   R,      WaW)      \
195
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtaRWn,   RaR,    NONTXNAL) \
196
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtaRWt,   RaR,    W)        \
197
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtaRWtaR, RaR,    WaR)      \
198
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtaRWtaW, RaR,    WaW)      \
199
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtaWWn,   RaW,    NONTXNAL) \
200
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtaWWt,   RaW,    W)        \
201
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtaWWtaR, RaW,    WaR)      \
202
  ITM_MEMTRANSFER_DEF(TARGET, M2, RtaWWtaW, RaW,    WaW)      \
203
  ITM_MEMSET_DEF(TARGET, M2, W)   \
204
  ITM_MEMSET_DEF(TARGET, M2, WaR) \
205
  ITM_MEMSET_DEF(TARGET, M2, WaW)
206
 
207
 
208
// Creates ABI load/store functions that delegate to a transactional memcpy.
209
#define ITM_READ_MEMCPY(T, LSMOD, TARGET, M2)                         \
210
  _ITM_TYPE_##T ITM_REGPARM _ITM_##LSMOD##T (const _ITM_TYPE_##T *ptr)\
211
  {                                                                   \
212
    _ITM_TYPE_##T v;                                                  \
213
    TARGET memtransfer##M2(&v, ptr, sizeof(_ITM_TYPE_##T), false,    \
214
        GTM::abi_dispatch::NONTXNAL, GTM::abi_dispatch::LSMOD);       \
215
    return v;                                                         \
216
  }
217
 
218
#define ITM_WRITE_MEMCPY(T, LSMOD, TARGET, M2)                            \
219
  void ITM_REGPARM _ITM_##LSMOD##T (_ITM_TYPE_##T *ptr, _ITM_TYPE_##T val)\
220
  {                                                                       \
221
    TARGET memtransfer##M2(ptr, &val, sizeof(_ITM_TYPE_##T), false,      \
222
        GTM::abi_dispatch::LSMOD, GTM::abi_dispatch::NONTXNAL);           \
223
  }
224
 
225
#define CREATE_DISPATCH_FUNCTIONS_T_MEMCPY(T, TARGET, M2) \
226
  ITM_READ_MEMCPY(T, R, TARGET, M2)                \
227
  ITM_READ_MEMCPY(T, RaR, TARGET, M2)              \
228
  ITM_READ_MEMCPY(T, RaW, TARGET, M2)              \
229
  ITM_READ_MEMCPY(T, RfW, TARGET, M2)              \
230
  ITM_WRITE_MEMCPY(T, W, TARGET, M2)               \
231
  ITM_WRITE_MEMCPY(T, WaR, TARGET, M2)             \
232
  ITM_WRITE_MEMCPY(T, WaW, TARGET, M2)
233
 
234
 
235
namespace GTM HIDDEN {
236
 
237
struct gtm_transaction_cp;
238
 
239
struct method_group
240
{
241
  // Start using a TM method from this group. This constructs required meta
242
  // data on demand when this method group is actually used. Will be called
243
  // either on first use or after a previous call to fini().
244
  virtual void init() = 0;
245
  // Stop using any method from this group for now. This can be used to
246
  // destruct meta data as soon as this method group is not used anymore.
247
  virtual void fini() = 0;
248
  // This can be overriden to implement more light-weight re-initialization.
249
  virtual void reinit()
250
  {
251
    fini();
252
    init();
253
  }
254
};
255
 
256
 
257
// This is the base interface that all TM methods have to implement.
258
struct abi_dispatch
259
{
260
public:
261
  enum ls_modifier { NONTXNAL, R, RaR, RaW, RfW, W, WaR, WaW };
262
 
263
private:
264
  // Disallow copies
265
  abi_dispatch(const abi_dispatch &) = delete;
266
  abi_dispatch& operator=(const abi_dispatch &) = delete;
267
 
268
public:
269
  // Starts or restarts a transaction. Is called right before executing the
270
  // transactional application code (by either returning from
271
  // gtm_thread::begin_transaction or doing the longjmp when restarting).
272
  // Returns NO_RESTART if the transaction started successfully. Returns
273
  // a real restart reason if it couldn't start and does need to abort. This
274
  // allows TM methods to just give up and delegate ensuring progress to the
275
  // restart mechanism. If it returns a restart reason, this call must be
276
  // idempotent because it will trigger the restart mechanism, which could
277
  // switch to a different TM method.
278
  virtual gtm_restart_reason begin_or_restart() = 0;
279
  // Tries to commit the transaction. Iff this returns true, the transaction
280
  // got committed and all per-transaction data will have been reset.
281
  // Currently, this is called only for the commit of the outermost
282
  // transaction, or when switching to serial mode (which can happen in a
283
  // nested transaction).
284
  // If privatization safety must be ensured in a quiescence-based way, set
285
  // priv_time to a value different to 0. Nontransactional code will not be
286
  // executed after this commit until all registered threads' shared_state is
287
  // larger than or equal to this value.
288
  virtual bool trycommit(gtm_word& priv_time) = 0;
289
  // Rolls back a transaction. Called on abort or after trycommit() returned
290
  // false.
291
  virtual void rollback(gtm_transaction_cp *cp = 0) = 0;
292
 
293
  // Return an alternative method that is compatible with the current
294
  // method but supports closed nesting. Return zero if there is none.
295
  // Note that too be compatible, it must be possible to switch to this other
296
  // method on begin of a nested transaction without committing or restarting
297
  // the parent method.
298
  virtual abi_dispatch* closed_nesting_alternative() { return 0; }
299
  // Returns true iff this method group supports the current situation.
300
  // NUMBER_OF_THREADS is the current number of threads that might execute
301
  // transactions.
302
  virtual bool supports(unsigned number_of_threads) { return true; }
303
 
304
  bool read_only () const { return m_read_only; }
305
  bool write_through() const { return m_write_through; }
306
  bool can_run_uninstrumented_code() const
307
  {
308
    return m_can_run_uninstrumented_code;
309
  }
310
  // Returns true iff this TM method supports closed nesting.
311
  bool closed_nesting() const { return m_closed_nesting; }
312
  method_group* get_method_group() const { return m_method_group; }
313
 
314
  static void *operator new(size_t s) { return xmalloc (s); }
315
  static void operator delete(void *p) { free (p); }
316
 
317
public:
318
  static bool memmove_overlap_check(void *dst, const void *src, size_t size,
319
      ls_modifier dst_mod, ls_modifier src_mod);
320
 
321
  // Creates the ABI dispatch methods for loads and stores.
322
  // ??? Should the dispatch table instead be embedded in the dispatch object
323
  // to avoid the indirect lookup in the vtable?
324
  CREATE_DISPATCH_METHODS_PV(virtual, )
325
  // Creates the ABI dispatch methods for memcpy/memmove/memset.
326
  CREATE_DISPATCH_METHODS_MEM_PV()
327
 
328
protected:
329
  const bool m_read_only;
330
  const bool m_write_through;
331
  const bool m_can_run_uninstrumented_code;
332
  const bool m_closed_nesting;
333
  method_group* const m_method_group;
334
  abi_dispatch(bool ro, bool wt, bool uninstrumented, bool closed_nesting,
335
      method_group* mg) :
336
    m_read_only(ro), m_write_through(wt),
337
    m_can_run_uninstrumented_code(uninstrumented),
338
    m_closed_nesting(closed_nesting), m_method_group(mg)
339
  { }
340
};
341
 
342
}
343
 
344
#endif // DISPATCH_H

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.