1 /* Copyright (C) 2008-2018 Free Software Foundation, Inc.
2    Contributed by Richard Henderson <rth@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 #include "libitm_i.h"
26 
27 // Avoid a dependency on libstdc++ for the pure virtuals in abi_dispatch.
28 extern "C" void HIDDEN
__cxa_pure_virtual()29 __cxa_pure_virtual ()
30 {
31   abort ();
32 }
33 
34 using namespace GTM;
35 
36 namespace {
37 
38 // This group consists of the serial, serialirr, and serialirr_onwrite
39 // methods, which all need no global state (except what is already provided
40 // by the serial mode implementation).
41 struct serial_mg : public method_group
42 {
init__anon9365b1570111::serial_mg43   virtual void init() { }
fini__anon9365b1570111::serial_mg44   virtual void fini() { }
45 };
46 
47 static serial_mg o_serial_mg;
48 
49 
50 class serialirr_dispatch : public abi_dispatch
51 {
52  public:
serialirr_dispatch()53   serialirr_dispatch() : abi_dispatch(false, true, true, false,
54       gtm_thread::STATE_SERIAL | gtm_thread::STATE_IRREVOCABLE, &o_serial_mg)
55   { }
56 
57  protected:
serialirr_dispatch(bool ro,bool wt,bool uninstrumented,bool closed_nesting,uint32_t requires_serial,method_group * mg)58   serialirr_dispatch(bool ro, bool wt, bool uninstrumented,
59       bool closed_nesting, uint32_t requires_serial, method_group* mg) :
60     abi_dispatch(ro, wt, uninstrumented, closed_nesting, requires_serial, mg)
61   { }
62 
63   // Transactional loads and stores simply access memory directly.
64   // These methods are static to avoid indirect calls, and will be used by the
65   // virtual ABI dispatch methods or by static direct-access methods created
66   // below.
load(const V * addr,ls_modifier mod)67   template <typename V> static V load(const V* addr, ls_modifier mod)
68   {
69     return *addr;
70   }
store(V * addr,const V value,ls_modifier mod)71   template <typename V> static void store(V* addr, const V value,
72       ls_modifier mod)
73   {
74     *addr = value;
75   }
76 
77  public:
memtransfer_static(void * dst,const void * src,size_t size,bool may_overlap,ls_modifier dst_mod,ls_modifier src_mod)78   static void memtransfer_static(void *dst, const void* src, size_t size,
79       bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod)
80   {
81     if (!may_overlap)
82       ::memcpy(dst, src, size);
83     else
84       ::memmove(dst, src, size);
85   }
86 
memset_static(void * dst,int c,size_t size,ls_modifier mod)87   static void memset_static(void *dst, int c, size_t size, ls_modifier mod)
88   {
89     ::memset(dst, c, size);
90   }
91 
92   CREATE_DISPATCH_METHODS(virtual, )
CREATE_DISPATCH_METHODS_MEM()93   CREATE_DISPATCH_METHODS_MEM()
94 
95   virtual gtm_restart_reason begin_or_restart() { return NO_RESTART; }
trycommit(gtm_word & priv_time)96   virtual bool trycommit(gtm_word& priv_time) { return true; }
rollback(gtm_transaction_cp * cp)97   virtual void rollback(gtm_transaction_cp *cp) { abort(); }
snapshot_most_recent()98   virtual bool snapshot_most_recent() { return true; }
99 
closed_nesting_alternative()100   virtual abi_dispatch* closed_nesting_alternative()
101   {
102     // For nested transactions with an instrumented code path, we can do
103     // undo logging.
104     return GTM::dispatch_serial();
105   }
106 };
107 
108 class serial_dispatch : public abi_dispatch
109 {
110 protected:
log(const void * addr,size_t len)111   static void log(const void *addr, size_t len)
112   {
113     gtm_thread *tx = gtm_thr();
114     tx->undolog.log(addr, len);
115   }
116 
load(const V * addr,ls_modifier mod)117   template <typename V> static V load(const V* addr, ls_modifier mod)
118   {
119     return *addr;
120   }
store(V * addr,const V value,ls_modifier mod)121   template <typename V> static void store(V* addr, const V value,
122       ls_modifier mod)
123   {
124     if (mod != WaW)
125       log(addr, sizeof(V));
126     *addr = value;
127   }
128 
129 public:
memtransfer_static(void * dst,const void * src,size_t size,bool may_overlap,ls_modifier dst_mod,ls_modifier src_mod)130   static void memtransfer_static(void *dst, const void* src, size_t size,
131       bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod)
132   {
133     if (dst_mod != WaW && dst_mod != NONTXNAL)
134       log(dst, size);
135     if (!may_overlap)
136       ::memcpy(dst, src, size);
137     else
138       ::memmove(dst, src, size);
139   }
140 
memset_static(void * dst,int c,size_t size,ls_modifier mod)141   static void memset_static(void *dst, int c, size_t size, ls_modifier mod)
142   {
143     if (mod != WaW)
144       log(dst, size);
145     ::memset(dst, c, size);
146   }
147 
begin_or_restart()148   virtual gtm_restart_reason begin_or_restart() { return NO_RESTART; }
trycommit(gtm_word & priv_time)149   virtual bool trycommit(gtm_word& priv_time) { return true; }
150   // Local undo will handle this.
151   // trydropreference() need not be changed either.
rollback(gtm_transaction_cp * cp)152   virtual void rollback(gtm_transaction_cp *cp) { }
snapshot_most_recent()153   virtual bool snapshot_most_recent() { return true; }
154 
155   CREATE_DISPATCH_METHODS(virtual, )
CREATE_DISPATCH_METHODS_MEM()156   CREATE_DISPATCH_METHODS_MEM()
157 
158   serial_dispatch() : abi_dispatch(false, true, false, true,
159       gtm_thread::STATE_SERIAL, &o_serial_mg)
160   { }
161 };
162 
163 
164 // Like serialirr_dispatch but does not requests serial-irrevocable mode until
165 // the first write in the transaction. Can be useful for read-mostly workloads
166 // and testing, but is likely too simple to be of general purpose.
167 class serialirr_onwrite_dispatch : public serialirr_dispatch
168 {
169  public:
serialirr_onwrite_dispatch()170   serialirr_onwrite_dispatch() :
171     serialirr_dispatch(false, true, false, false, 0, &o_serial_mg) { }
172 
173  protected:
pre_write()174   static void pre_write()
175   {
176     gtm_thread *tx = gtm_thr();
177     if (!(tx->state & (gtm_thread::STATE_SERIAL
178 	| gtm_thread::STATE_IRREVOCABLE)))
179       tx->serialirr_mode();
180   }
181 
182   // Transactional loads access memory directly.
183   // Transactional stores switch to serial mode first.
store(V * addr,const V value,ls_modifier mod)184   template <typename V> static void store(V* addr, const V value,
185       ls_modifier mod)
186   {
187     pre_write();
188     serialirr_dispatch::store(addr, value, mod);
189   }
190 
191  public:
memtransfer_static(void * dst,const void * src,size_t size,bool may_overlap,ls_modifier dst_mod,ls_modifier src_mod)192   static void memtransfer_static(void *dst, const void* src, size_t size,
193       bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod)
194   {
195     pre_write();
196     serialirr_dispatch::memtransfer_static(dst, src, size, may_overlap,
197 	dst_mod, src_mod);
198   }
199 
memset_static(void * dst,int c,size_t size,ls_modifier mod)200   static void memset_static(void *dst, int c, size_t size, ls_modifier mod)
201   {
202     pre_write();
203     serialirr_dispatch::memset_static(dst, c, size, mod);
204   }
205 
206   CREATE_DISPATCH_METHODS(virtual, )
CREATE_DISPATCH_METHODS_MEM()207   CREATE_DISPATCH_METHODS_MEM()
208 
209   virtual void rollback(gtm_transaction_cp *cp)
210   {
211     gtm_thread *tx = gtm_thr();
212     if (tx->state & gtm_thread::STATE_IRREVOCABLE)
213       abort();
214   }
215 
snapshot_most_recent()216   virtual bool snapshot_most_recent() { return true; }
217 };
218 
219 // This group is pure HTM with serial mode as a fallback.  There is no
220 // difference to serial_mg except that we need to enable or disable the HTM
221 // fastpath.  See gtm_thread::begin_transaction.
222 struct htm_mg : public method_group
223 {
init__anon9365b1570111::htm_mg224   virtual void init()
225   {
226     // Enable the HTM fastpath if the HW is available.  The fastpath is
227     // initially disabled.
228 #ifdef USE_HTM_FASTPATH
229     gtm_thread::serial_lock.set_htm_fastpath(htm_init());
230 #endif
231   }
fini__anon9365b1570111::htm_mg232   virtual void fini()
233   {
234     // Disable the HTM fastpath.
235     gtm_thread::serial_lock.set_htm_fastpath(0);
236   }
237 };
238 
239 static htm_mg o_htm_mg;
240 
241 // We just need the subclass to associate it with the HTM method group that
242 // sets up the HTM fast path.  This will use serial_dispatch as fallback for
243 // transactions that might get canceled; it has a different method group, but
244 // this is harmless for serial dispatchs because they never abort.
245 class htm_dispatch : public serialirr_dispatch
246 {
247  public:
htm_dispatch()248   htm_dispatch() : serialirr_dispatch(false, true, false, false,
249       gtm_thread::STATE_SERIAL | gtm_thread::STATE_IRREVOCABLE, &o_htm_mg)
250   { }
251 };
252 
253 } // anon namespace
254 
255 static const serialirr_dispatch o_serialirr_dispatch;
256 static const serial_dispatch o_serial_dispatch;
257 static const serialirr_onwrite_dispatch o_serialirr_onwrite_dispatch;
258 static const htm_dispatch o_htm_dispatch;
259 
260 abi_dispatch *
dispatch_serialirr()261 GTM::dispatch_serialirr ()
262 {
263   return const_cast<serialirr_dispatch *>(&o_serialirr_dispatch);
264 }
265 
266 abi_dispatch *
dispatch_serial()267 GTM::dispatch_serial ()
268 {
269   return const_cast<serial_dispatch *>(&o_serial_dispatch);
270 }
271 
272 abi_dispatch *
dispatch_serialirr_onwrite()273 GTM::dispatch_serialirr_onwrite ()
274 {
275   return
276       const_cast<serialirr_onwrite_dispatch *>(&o_serialirr_onwrite_dispatch);
277 }
278 
279 abi_dispatch *
dispatch_htm()280 GTM::dispatch_htm ()
281 {
282   return const_cast<htm_dispatch *>(&o_htm_dispatch);
283 }
284 
285 // Put the transaction into serial-irrevocable mode.
286 
287 void
serialirr_mode()288 GTM::gtm_thread::serialirr_mode ()
289 {
290   struct abi_dispatch *disp = abi_disp ();
291 
292 #if defined(USE_HTM_FASTPATH)
293   // HTM fastpath.  If we are executing a HW transaction, don't go serial but
294   // continue.  See gtm_thread::begin_transaction.
295   if (likely(!gtm_thread::serial_lock.htm_fastpath_disabled()))
296     return;
297 #endif
298 
299   if (this->state & STATE_SERIAL)
300     {
301       if (this->state & STATE_IRREVOCABLE)
302 	return;
303 
304       // Try to commit the dispatch-specific part of the transaction, as we
305       // would do for an outermost commit.
306       // We're already serial, so we don't need to ensure privatization safety
307       // for other transactions here.
308       gtm_word priv_time = 0;
309       bool ok = disp->trycommit (priv_time);
310       // Given that we're already serial, the trycommit better work.
311       assert (ok);
312     }
313   else if (serial_lock.write_upgrade (this))
314     {
315       this->state |= STATE_SERIAL;
316       // Try to commit the dispatch-specific part of the transaction, as we
317       // would do for an outermost commit.
318       // We have successfully upgraded to serial mode, so we don't need to
319       // ensure privatization safety for other transactions here.
320       // However, we are still a reader (wrt. privatization safety) until we
321       // have either committed or restarted, so finish the upgrade after that.
322       gtm_word priv_time = 0;
323       if (!disp->trycommit (priv_time))
324         restart (RESTART_SERIAL_IRR, true);
325       gtm_thread::serial_lock.write_upgrade_finish(this);
326     }
327   else
328     restart (RESTART_SERIAL_IRR, false);
329 
330   this->state |= (STATE_SERIAL | STATE_IRREVOCABLE);
331   set_abi_disp (dispatch_serialirr ());
332 }
333 
334 void ITM_REGPARM
_ITM_changeTransactionMode(_ITM_transactionState state)335 _ITM_changeTransactionMode (_ITM_transactionState state)
336 {
337   assert (state == modeSerialIrrevocable);
338   gtm_thr()->serialirr_mode ();
339 }
340