| /* Copyright (C) 2008-2020 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 <stdlib.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include "libitm_i.h" |
| |
| // The default TM method used when starting a new transaction. Initialized |
| // in number_of_threads_changed() below. |
| // Access to this variable is always synchronized with help of the serial |
| // lock, except one read access that happens in decide_begin_dispatch() before |
| // a transaction has become active (by acquiring the serial lock in read or |
| // write mode). The default_dispatch is only changed and initialized in |
| // serial mode. Transactions stay active when they restart (see beginend.cc), |
| // thus decide_retry_strategy() can expect default_dispatch to be unmodified. |
| // See decide_begin_dispatch() for further comments. |
| static std::atomic<GTM::abi_dispatch*> default_dispatch; |
| // The default TM method as requested by the user, if any. |
| static GTM::abi_dispatch* default_dispatch_user = 0; |
| |
| void |
| GTM::gtm_thread::decide_retry_strategy (gtm_restart_reason r) |
| { |
| struct abi_dispatch *disp = abi_disp (); |
| |
| this->restart_reason[r]++; |
| this->restart_total++; |
| |
| if (r == RESTART_INIT_METHOD_GROUP) |
| { |
| // A re-initializations of the method group has been requested. Switch |
| // to serial mode, initialize, and resume normal operation. |
| if ((state & STATE_SERIAL) == 0) |
| { |
| // We have to eventually re-init the method group. Therefore, |
| // we cannot just upgrade to a write lock here because this could |
| // fail forever when other transactions execute in serial mode. |
| // However, giving up the read lock then means that a change of the |
| // method group could happen in-between, so check that we're not |
| // re-initializing without a need. |
| // ??? Note that we can still re-initialize too often, but avoiding |
| // that would increase code complexity, which seems unnecessary |
| // given that re-inits should be very infrequent. |
| serial_lock.read_unlock(this); |
| serial_lock.write_lock(); |
| if (disp->get_method_group() |
| == default_dispatch.load(memory_order_relaxed) |
| ->get_method_group()) |
| // Still the same method group. |
| disp->get_method_group()->reinit(); |
| serial_lock.write_unlock(); |
| // Also, we're making the transaction inactive, so when we become |
| // active again, some other thread might have changed the default |
| // dispatch, so we run the same code as for the first execution |
| // attempt. |
| disp = decide_begin_dispatch(prop); |
| set_abi_disp(disp); |
| } |
| else |
| // We are a serial transaction already, which makes things simple. |
| disp->get_method_group()->reinit(); |
| |
| return; |
| } |
| |
| bool retry_irr = (r == RESTART_SERIAL_IRR); |
| bool retry_serial = (retry_irr || this->restart_total > 100); |
| |
| // We assume closed nesting to be infrequently required, so just use |
| // dispatch_serial (with undo logging) if required. |
| if (r == RESTART_CLOSED_NESTING) |
| retry_serial = true; |
| |
| if (retry_serial) |
| { |
| // In serialirr_mode we can succeed with the upgrade to |
| // write-lock but fail the trycommit. In any case, if the |
| // write lock is not yet held, grab it. Don't do this with |
| // an upgrade, since we've no need to preserve the state we |
| // acquired with the read. |
| // Note that we will be restarting with either dispatch_serial or |
| // dispatch_serialirr, which are compatible with all TM methods; if |
| // we would retry with a different method, we would have to first check |
| // whether the default dispatch or the method group have changed. Also, |
| // the caller must have rolled back the previous transaction, so we |
| // don't have to worry about things such as privatization. |
| if ((this->state & STATE_SERIAL) == 0) |
| { |
| this->state |= STATE_SERIAL; |
| serial_lock.read_unlock (this); |
| serial_lock.write_lock (); |
| } |
| |
| // We can retry with dispatch_serialirr if the transaction |
| // doesn't contain an abort and if we don't need closed nesting. |
| if ((this->prop & pr_hasNoAbort) && (r != RESTART_CLOSED_NESTING)) |
| retry_irr = true; |
| } |
| |
| // Note that we can just use serial mode here without having to switch |
| // TM method sets because serial mode is compatible with all of them. |
| if (retry_irr) |
| { |
| this->state = (STATE_SERIAL | STATE_IRREVOCABLE); |
| disp = dispatch_serialirr (); |
| set_abi_disp (disp); |
| } |
| else if (retry_serial) |
| { |
| disp = dispatch_serial(); |
| set_abi_disp (disp); |
| } |
| } |
| |
| |
| // Decides which TM method should be used on the first attempt to run this |
| // transaction. Acquires the serial lock and sets transaction state |
| // according to the chosen TM method. |
| GTM::abi_dispatch* |
| GTM::gtm_thread::decide_begin_dispatch (uint32_t prop) |
| { |
| abi_dispatch* dd; |
| // TODO Pay more attention to prop flags (eg, *omitted) when selecting |
| // dispatch. |
| // ??? We go irrevocable eagerly here, which is not always good for |
| // performance. Don't do this? |
| if ((prop & pr_doesGoIrrevocable) || !(prop & pr_instrumentedCode)) |
| dd = dispatch_serialirr(); |
| |
| else |
| { |
| // Load the default dispatch. We're not an active transaction and so it |
| // can change concurrently but will still be some valid dispatch. |
| // Relaxed memory order is okay because we expect each dispatch to be |
| // constructed properly already (at least that its closed_nesting() and |
| // closed_nesting_alternatives() will return sensible values). It is |
| // harmless if we incorrectly chose the serial or serialirr methods, and |
| // for all other methods we will acquire the serial lock in read mode |
| // and load the default dispatch again. |
| abi_dispatch* dd_orig = default_dispatch.load(memory_order_relaxed); |
| dd = dd_orig; |
| |
| // If we might need closed nesting and the default dispatch has an |
| // alternative that supports closed nesting, use it. |
| // ??? We could choose another TM method that we know supports closed |
| // nesting but isn't the default (e.g., dispatch_serial()). However, we |
| // assume that aborts that need closed nesting are infrequent, so don't |
| // choose a non-default method until we have to actually restart the |
| // transaction. |
| if (!(prop & pr_hasNoAbort) && !dd->closed_nesting() |
| && dd->closed_nesting_alternative()) |
| dd = dd->closed_nesting_alternative(); |
| |
| if (!(dd->requires_serial() & STATE_SERIAL)) |
| { |
| // The current dispatch is supposedly a non-serial one. Become an |
| // active transaction and verify this. Relaxed memory order is fine |
| // because the serial lock itself will have established |
| // happens-before for any change to the selected dispatch. |
| serial_lock.read_lock (this); |
| if (default_dispatch.load(memory_order_relaxed) == dd_orig) |
| return dd; |
| |
| // If we raced with a concurrent modification of default_dispatch, |
| // just fall back to serialirr. The dispatch choice might not be |
| // up-to-date anymore, but this is harmless. |
| serial_lock.read_unlock (this); |
| dd = dispatch_serialirr(); |
| } |
| } |
| |
| // We are some kind of serial transaction. |
| serial_lock.write_lock(); |
| state = dd->requires_serial(); |
| return dd; |
| } |
| |
| |
| void |
| GTM::gtm_thread::set_default_dispatch(GTM::abi_dispatch* disp) |
| { |
| abi_dispatch* dd = default_dispatch.load(memory_order_relaxed); |
| if (dd == disp) |
| return; |
| if (dd) |
| { |
| // If we are switching method groups, initialize and shut down properly. |
| if (dd->get_method_group() != disp->get_method_group()) |
| { |
| dd->get_method_group()->fini(); |
| disp->get_method_group()->init(); |
| } |
| } |
| else |
| disp->get_method_group()->init(); |
| default_dispatch.store(disp, memory_order_relaxed); |
| } |
| |
| |
| static GTM::abi_dispatch* |
| parse_default_method() |
| { |
| const char *env = getenv("ITM_DEFAULT_METHOD"); |
| GTM::abi_dispatch* disp = 0; |
| if (env == NULL) |
| return 0; |
| |
| while (isspace((unsigned char) *env)) |
| ++env; |
| if (strncmp(env, "serialirr_onwrite", 17) == 0) |
| { |
| disp = GTM::dispatch_serialirr_onwrite(); |
| env += 17; |
| } |
| else if (strncmp(env, "serialirr", 9) == 0) |
| { |
| disp = GTM::dispatch_serialirr(); |
| env += 9; |
| } |
| else if (strncmp(env, "serial", 6) == 0) |
| { |
| disp = GTM::dispatch_serial(); |
| env += 6; |
| } |
| else if (strncmp(env, "gl_wt", 5) == 0) |
| { |
| disp = GTM::dispatch_gl_wt(); |
| env += 5; |
| } |
| else if (strncmp(env, "ml_wt", 5) == 0) |
| { |
| disp = GTM::dispatch_ml_wt(); |
| env += 5; |
| } |
| else if (strncmp(env, "htm", 3) == 0) |
| { |
| disp = GTM::dispatch_htm(); |
| env += 3; |
| } |
| else |
| goto unknown; |
| |
| while (isspace((unsigned char) *env)) |
| ++env; |
| if (*env == '\0') |
| return disp; |
| |
| unknown: |
| GTM::GTM_error("Unknown TM method in environment variable " |
| "ITM_DEFAULT_METHOD\n"); |
| return 0; |
| } |
| |
| // Gets notifications when the number of registered threads changes. This is |
| // used to initialize the method set choice and trigger straightforward choice |
| // adaption. |
| // This must be called only by serial threads. |
| void |
| GTM::gtm_thread::number_of_threads_changed(unsigned previous, unsigned now) |
| { |
| if (previous == 0) |
| { |
| // No registered threads before, so initialize. |
| static bool initialized = false; |
| if (!initialized) |
| { |
| initialized = true; |
| // Check for user preferences here. |
| default_dispatch = 0; |
| default_dispatch_user = parse_default_method(); |
| } |
| } |
| else if (now == 0) |
| { |
| // No registered threads anymore. The dispatch based on serial mode do |
| // not have any global state, so this effectively shuts down properly. |
| set_default_dispatch(dispatch_serialirr()); |
| } |
| |
| if (now == 1) |
| { |
| // Only one thread, so use a serializing method. |
| // ??? If we don't have a fast serial mode implementation, it might be |
| // better to use the global lock method set here. |
| if (default_dispatch_user && default_dispatch_user->supports(now)) |
| set_default_dispatch(default_dispatch_user); |
| else |
| set_default_dispatch(dispatch_serialirr()); |
| } |
| else if (now > 1 && previous <= 1) |
| { |
| // More than one thread, use the default method. |
| if (default_dispatch_user && default_dispatch_user->supports(now)) |
| set_default_dispatch(default_dispatch_user); |
| else |
| { |
| // If HTM is available, use it by default with serial mode as |
| // fallback. Otherwise, use ml_wt because it probably scales best. |
| abi_dispatch* a; |
| #ifdef USE_HTM_FASTPATH |
| if (htm_available()) |
| a = dispatch_htm(); |
| else |
| #endif |
| a = dispatch_ml_wt(); |
| if (a->supports(now)) |
| set_default_dispatch(a); |
| else |
| // Serial-irrevocable mode always works. |
| set_default_dispatch(dispatch_serialirr()); |
| } |
| } |
| } |