URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libitm/] [method-serial.cc] - Rev 745
Go to most recent revision | Compare with Previous | Blame | View Log
/* Copyright (C) 2008, 2009, 2011, 2012 Free Software Foundation, Inc. Contributed by Richard Henderson <rth@redhat.com>. This file is part of the GNU Transactional Memory Library (libitm). Libitm is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. Libitm is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. */ #include "libitm_i.h" // Avoid a dependency on libstdc++ for the pure virtuals in abi_dispatch. extern "C" void HIDDEN __cxa_pure_virtual () { abort (); } using namespace GTM; namespace { // This group consists of the serial, serialirr, and serialirr_onwrite // methods, which all need no global state (except what is already provided // by the serial mode implementation). struct serial_mg : public method_group { virtual void init() { } virtual void fini() { } }; static serial_mg o_serial_mg; class serialirr_dispatch : public abi_dispatch { public: serialirr_dispatch() : abi_dispatch(false, true, true, false, &o_serial_mg) { } protected: serialirr_dispatch(bool ro, bool wt, bool uninstrumented, bool closed_nesting, method_group* mg) : abi_dispatch(ro, wt, uninstrumented, closed_nesting, mg) { } // Transactional loads and stores simply access memory directly. // These methods are static to avoid indirect calls, and will be used by the // virtual ABI dispatch methods or by static direct-access methods created // below. template <typename V> static V load(const V* addr, ls_modifier mod) { return *addr; } template <typename V> static void store(V* addr, const V value, ls_modifier mod) { *addr = value; } public: static void memtransfer_static(void *dst, const void* src, size_t size, bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod) { if (!may_overlap) ::memcpy(dst, src, size); else ::memmove(dst, src, size); } static void memset_static(void *dst, int c, size_t size, ls_modifier mod) { ::memset(dst, c, size); } CREATE_DISPATCH_METHODS(virtual, ) CREATE_DISPATCH_METHODS_MEM() virtual gtm_restart_reason begin_or_restart() { return NO_RESTART; } virtual bool trycommit(gtm_word& priv_time) { return true; } virtual void rollback(gtm_transaction_cp *cp) { abort(); } virtual abi_dispatch* closed_nesting_alternative() { // For nested transactions with an instrumented code path, we can do // undo logging. return GTM::dispatch_serial(); } }; class serial_dispatch : public abi_dispatch { protected: static void log(const void *addr, size_t len) { gtm_thread *tx = gtm_thr(); tx->undolog.log(addr, len); } template <typename V> static V load(const V* addr, ls_modifier mod) { return *addr; } template <typename V> static void store(V* addr, const V value, ls_modifier mod) { if (mod != WaW) log(addr, sizeof(V)); *addr = value; } public: static void memtransfer_static(void *dst, const void* src, size_t size, bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod) { if (dst_mod != WaW && dst_mod != NONTXNAL) log(dst, size); if (!may_overlap) ::memcpy(dst, src, size); else ::memmove(dst, src, size); } static void memset_static(void *dst, int c, size_t size, ls_modifier mod) { if (mod != WaW) log(dst, size); ::memset(dst, c, size); } virtual gtm_restart_reason begin_or_restart() { return NO_RESTART; } virtual bool trycommit(gtm_word& priv_time) { return true; } // Local undo will handle this. // trydropreference() need not be changed either. virtual void rollback(gtm_transaction_cp *cp) { } CREATE_DISPATCH_METHODS(virtual, ) CREATE_DISPATCH_METHODS_MEM() serial_dispatch() : abi_dispatch(false, true, false, true, &o_serial_mg) { } }; // Like serialirr_dispatch but does not requests serial-irrevocable mode until // the first write in the transaction. Can be useful for read-mostly workloads // and testing, but is likely too simple to be of general purpose. class serialirr_onwrite_dispatch : public serialirr_dispatch { public: serialirr_onwrite_dispatch() : serialirr_dispatch(false, true, false, false, &o_serial_mg) { } protected: static void pre_write() { gtm_thread *tx = gtm_thr(); if (!(tx->state & (gtm_thread::STATE_SERIAL | gtm_thread::STATE_IRREVOCABLE))) tx->serialirr_mode(); } // Transactional loads access memory directly. // Transactional stores switch to serial mode first. template <typename V> static void store(V* addr, const V value, ls_modifier mod) { pre_write(); serialirr_dispatch::store(addr, value, mod); } public: static void memtransfer_static(void *dst, const void* src, size_t size, bool may_overlap, ls_modifier dst_mod, ls_modifier src_mod) { pre_write(); serialirr_dispatch::memtransfer_static(dst, src, size, may_overlap, dst_mod, src_mod); } static void memset_static(void *dst, int c, size_t size, ls_modifier mod) { pre_write(); serialirr_dispatch::memset_static(dst, c, size, mod); } CREATE_DISPATCH_METHODS(virtual, ) CREATE_DISPATCH_METHODS_MEM() virtual void rollback(gtm_transaction_cp *cp) { gtm_thread *tx = gtm_thr(); if (tx->state & gtm_thread::STATE_IRREVOCABLE) abort(); } }; } // anon namespace static const serialirr_dispatch o_serialirr_dispatch; static const serial_dispatch o_serial_dispatch; static const serialirr_onwrite_dispatch o_serialirr_onwrite_dispatch; abi_dispatch * GTM::dispatch_serialirr () { return const_cast<serialirr_dispatch *>(&o_serialirr_dispatch); } abi_dispatch * GTM::dispatch_serial () { return const_cast<serial_dispatch *>(&o_serial_dispatch); } abi_dispatch * GTM::dispatch_serialirr_onwrite () { return const_cast<serialirr_onwrite_dispatch *>(&o_serialirr_onwrite_dispatch); } // Put the transaction into serial-irrevocable mode. void GTM::gtm_thread::serialirr_mode () { struct abi_dispatch *disp = abi_disp (); if (this->state & STATE_SERIAL) { if (this->state & STATE_IRREVOCABLE) return; // Try to commit the dispatch-specific part of the transaction, as we // would do for an outermost commit. // We're already serial, so we don't need to ensure privatization safety // for other transactions here. gtm_word priv_time = 0; bool ok = disp->trycommit (priv_time); // Given that we're already serial, the trycommit better work. assert (ok); } else if (serial_lock.write_upgrade (this)) { this->state |= STATE_SERIAL; // Try to commit the dispatch-specific part of the transaction, as we // would do for an outermost commit. // We have successfully upgraded to serial mode, so we don't need to // ensure privatization safety for other transactions here. // However, we are still a reader (wrt. privatization safety) until we // have either committed or restarted, so finish the upgrade after that. gtm_word priv_time = 0; if (!disp->trycommit (priv_time)) restart (RESTART_SERIAL_IRR, true); gtm_thread::serial_lock.write_upgrade_finish(this); } else restart (RESTART_SERIAL_IRR, false); this->state |= (STATE_SERIAL | STATE_IRREVOCABLE); set_abi_disp (dispatch_serialirr ()); } void ITM_REGPARM _ITM_changeTransactionMode (_ITM_transactionState state) { assert (state == modeSerialIrrevocable); gtm_thr()->serialirr_mode (); }
Go to most recent revision | Compare with Previous | Blame | View Log