libitm/method-serial.cc

   1 /* Copyright (C) 2008, 2009, 2011, 2012 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
  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 {
  43   virtual void init() { }
  44   virtual void fini() { }
  45 };
  46
  47 static serial_mg o_serial_mg;
  48
  49
  50 class serialirr_dispatch : public abi_dispatch
  51 {
  52  public:
  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:
  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.
  67   template <typename V> static V load(const V* addr, ls_modifier mod)
  68   {
  69     return *addr;
  70   }
  71   template <typename V> static void store(V* addr, const V value,
  72       ls_modifier mod)
  73   {
  74     *addr = value;
  75   }
  76
  77  public:
  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
  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, )
  93   CREATE_DISPATCH_METHODS_MEM()
  94
  95   virtual gtm_restart_reason begin_or_restart() { return NO_RESTART; }
  96   virtual bool trycommit(gtm_word& priv_time) { return true; }
  97   virtual void rollback(gtm_transaction_cp *cp) { abort(); }
  98
  99   virtual abi_dispatch* closed_nesting_alternative()
 100   {
 101     // For nested transactions with an instrumented code path, we can do
 102     // undo logging.
 103     return GTM::dispatch_serial();
 104   }
 105 };
 106
 107 class serial_dispatch : public abi_dispatch
 108 {
 109 protected:
 110   static void log(const void *addr, size_t len)
 111   {
 112     gtm_thread *tx = gtm_thr();
 113     tx->undolog.log(addr, len);
 114   }
 115
 116   template <typename V> static V load(const V* addr, ls_modifier mod)
 117   {
 118     return *addr;
 119   }
 120   template <typename V> static void store(V* addr, const V value,
 121       ls_modifier mod)
 122   {
 123     if (mod != WaW)
 124       log(addr, sizeof(V));
 125     *addr = value;
 126   }
 127
 128 public:
 129   static void memtransfer_static(void *dst, const void* src, size_t size,
 130       bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod)
 131   {
 132     if (dst_mod != WaW && dst_mod != NONTXNAL)
 133       log(dst, size);
 134     if (!may_overlap)
 135       ::memcpy(dst, src, size);
 136     else
 137       ::memmove(dst, src, size);
 138   }
 139
 140   static void memset_static(void *dst, int c, size_t size, ls_modifier mod)
 141   {
 142     if (mod != WaW)
 143       log(dst, size);
 144     ::memset(dst, c, size);
 145   }
 146
 147   virtual gtm_restart_reason begin_or_restart() { return NO_RESTART; }
 148   virtual bool trycommit(gtm_word& priv_time) { return true; }
 149   // Local undo will handle this.
 150   // trydropreference() need not be changed either.
 151   virtual void rollback(gtm_transaction_cp *cp) { }
 152
 153   CREATE_DISPATCH_METHODS(virtual, )
 154   CREATE_DISPATCH_METHODS_MEM()
 155
 156   serial_dispatch() : abi_dispatch(false, true, false, true,
 157       gtm_thread::STATE_SERIAL, &o_serial_mg)
 158   { }
 159 };
 160
 161
 162 // Like serialirr_dispatch but does not requests serial-irrevocable mode until
 163 // the first write in the transaction. Can be useful for read-mostly workloads
 164 // and testing, but is likely too simple to be of general purpose.
 165 class serialirr_onwrite_dispatch : public serialirr_dispatch
 166 {
 167  public:
 168   serialirr_onwrite_dispatch() :
 169     serialirr_dispatch(false, true, false, false, 0, &o_serial_mg) { }
 170
 171  protected:
 172   static void pre_write()
 173   {
 174     gtm_thread *tx = gtm_thr();
 175     if (!(tx->state & (gtm_thread::STATE_SERIAL
 176         | gtm_thread::STATE_IRREVOCABLE)))
 177       tx->serialirr_mode();
 178   }
 179
 180   // Transactional loads access memory directly.
 181   // Transactional stores switch to serial mode first.
 182   template <typename V> static void store(V* addr, const V value,
 183       ls_modifier mod)
 184   {
 185     pre_write();
 186     serialirr_dispatch::store(addr, value, mod);
 187   }
 188
 189  public:
 190   static void memtransfer_static(void *dst, const void* src, size_t size,
 191       bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod)
 192   {
 193     pre_write();
 194     serialirr_dispatch::memtransfer_static(dst, src, size, may_overlap,
 195         dst_mod, src_mod);
 196   }
 197
 198   static void memset_static(void *dst, int c, size_t size, ls_modifier mod)
 199   {
 200     pre_write();
 201     serialirr_dispatch::memset_static(dst, c, size, mod);
 202   }
 203
 204   CREATE_DISPATCH_METHODS(virtual, )
 205   CREATE_DISPATCH_METHODS_MEM()
 206
 207   virtual void rollback(gtm_transaction_cp *cp)
 208   {
 209     gtm_thread *tx = gtm_thr();
 210     if (tx->state & gtm_thread::STATE_IRREVOCABLE)
 211       abort();
 212   }
 213 };
 214
 215 } // anon namespace
 216
 217 static const serialirr_dispatch o_serialirr_dispatch;
 218 static const serial_dispatch o_serial_dispatch;
 219 static const serialirr_onwrite_dispatch o_serialirr_onwrite_dispatch;
 220
 221 abi_dispatch *
 222 GTM::dispatch_serialirr ()
 223 {
 224   return const_cast<serialirr_dispatch *>(&o_serialirr_dispatch);
 225 }
 226
 227 abi_dispatch *
 228 GTM::dispatch_serial ()
 229 {
 230   return const_cast<serial_dispatch *>(&o_serial_dispatch);
 231 }
 232
 233 abi_dispatch *
 234 GTM::dispatch_serialirr_onwrite ()
 235 {
 236   return
 237       const_cast<serialirr_onwrite_dispatch *>(&o_serialirr_onwrite_dispatch);
 238 }
 239
 240 // Put the transaction into serial-irrevocable mode.
 241
 242 void
 243 GTM::gtm_thread::serialirr_mode ()
 244 {
 245   struct abi_dispatch *disp = abi_disp ();
 246
 247   if (this->state & STATE_SERIAL)
 248     {
 249       if (this->state & STATE_IRREVOCABLE)
 250         return;
 251
 252       // Try to commit the dispatch-specific part of the transaction, as we
 253       // would do for an outermost commit.
 254       // We're already serial, so we don't need to ensure privatization safety
 255       // for other transactions here.
 256       gtm_word priv_time = 0;
 257       bool ok = disp->trycommit (priv_time);
 258       // Given that we're already serial, the trycommit better work.
 259       assert (ok);
 260     }
 261   else if (serial_lock.write_upgrade (this))
 262     {
 263       this->state |= STATE_SERIAL;
 264       // Try to commit the dispatch-specific part of the transaction, as we
 265       // would do for an outermost commit.
 266       // We have successfully upgraded to serial mode, so we don't need to
 267       // ensure privatization safety for other transactions here.
 268       // However, we are still a reader (wrt. privatization safety) until we
 269       // have either committed or restarted, so finish the upgrade after that.
 270       gtm_word priv_time = 0;
 271       if (!disp->trycommit (priv_time))
 272         restart (RESTART_SERIAL_IRR, true);
 273       gtm_thread::serial_lock.write_upgrade_finish(this);
 274     }
 275   else
 276     restart (RESTART_SERIAL_IRR, false);
 277
 278   this->state |= (STATE_SERIAL | STATE_IRREVOCABLE);
 279   set_abi_disp (dispatch_serialirr ());
 280 }
 281
 282 void ITM_REGPARM
 283 _ITM_changeTransactionMode (_ITM_transactionState state)
 284 {
 285   assert (state == modeSerialIrrevocable);
 286   gtm_thr()->serialirr_mode ();
 287 }