1/* Copyright (C) 2008-2017 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 <stdlib.h>
26#include <string.h>
27#include <ctype.h>
28#include "libitm_i.h"
29
30// The default TM method used when starting a new transaction. Initialized
31// in number_of_threads_changed() below.
32// Access to this variable is always synchronized with help of the serial
33// lock, except one read access that happens in decide_begin_dispatch() before
34// a transaction has become active (by acquiring the serial lock in read or
35// write mode). The default_dispatch is only changed and initialized in
36// serial mode. Transactions stay active when they restart (see beginend.cc),
37// thus decide_retry_strategy() can expect default_dispatch to be unmodified.
38// See decide_begin_dispatch() for further comments.
39static std::atomic<GTM::abi_dispatch*> default_dispatch;
40// The default TM method as requested by the user, if any.
41static GTM::abi_dispatch* default_dispatch_user = 0;
42
43void
44GTM::gtm_thread::decide_retry_strategy (gtm_restart_reason r)
45{
46 struct abi_dispatch *disp = abi_disp ();
47
48 this->restart_reason[r]++;
49 this->restart_total++;
50
51 if (r == RESTART_INIT_METHOD_GROUP)
52 {
53 // A re-initializations of the method group has been requested. Switch
54 // to serial mode, initialize, and resume normal operation.
55 if ((state & STATE_SERIAL) == 0)
56 {
57 // We have to eventually re-init the method group. Therefore,
58 // we cannot just upgrade to a write lock here because this could
59 // fail forever when other transactions execute in serial mode.
60 // However, giving up the read lock then means that a change of the
61 // method group could happen in-between, so check that we're not
62 // re-initializing without a need.
63 // ??? Note that we can still re-initialize too often, but avoiding
64 // that would increase code complexity, which seems unnecessary
65 // given that re-inits should be very infrequent.
66 serial_lock.read_unlock(this);
67 serial_lock.write_lock();
68 if (disp->get_method_group()
69 == default_dispatch.load(memory_order_relaxed)
70 ->get_method_group())
71 // Still the same method group.
72 disp->get_method_group()->reinit();
73 serial_lock.write_unlock();
74 // Also, we're making the transaction inactive, so when we become
75 // active again, some other thread might have changed the default
76 // dispatch, so we run the same code as for the first execution
77 // attempt.
78 disp = decide_begin_dispatch(prop);
79 set_abi_disp(disp);
80 }
81 else
82 // We are a serial transaction already, which makes things simple.
83 disp->get_method_group()->reinit();
84
85 return;
86 }
87
88 bool retry_irr = (r == RESTART_SERIAL_IRR);
89 bool retry_serial = (retry_irr || this->restart_total > 100);
90
91 // We assume closed nesting to be infrequently required, so just use
92 // dispatch_serial (with undo logging) if required.
93 if (r == RESTART_CLOSED_NESTING)
94 retry_serial = true;
95
96 if (retry_serial)
97 {
98 // In serialirr_mode we can succeed with the upgrade to
99 // write-lock but fail the trycommit. In any case, if the
100 // write lock is not yet held, grab it. Don't do this with
101 // an upgrade, since we've no need to preserve the state we
102 // acquired with the read.
103 // Note that we will be restarting with either dispatch_serial or
104 // dispatch_serialirr, which are compatible with all TM methods; if
105 // we would retry with a different method, we would have to first check
106 // whether the default dispatch or the method group have changed. Also,
107 // the caller must have rolled back the previous transaction, so we
108 // don't have to worry about things such as privatization.
109 if ((this->state & STATE_SERIAL) == 0)
110 {
111 this->state |= STATE_SERIAL;
112 serial_lock.read_unlock (this);
113 serial_lock.write_lock ();
114 }
115
116 // We can retry with dispatch_serialirr if the transaction
117 // doesn't contain an abort and if we don't need closed nesting.
118 if ((this->prop & pr_hasNoAbort) && (r != RESTART_CLOSED_NESTING))
119 retry_irr = true;
120 }
121
122 // Note that we can just use serial mode here without having to switch
123 // TM method sets because serial mode is compatible with all of them.
124 if (retry_irr)
125 {
126 this->state = (STATE_SERIAL | STATE_IRREVOCABLE);
127 disp = dispatch_serialirr ();
128 set_abi_disp (disp);
129 }
130 else if (retry_serial)
131 {
132 disp = dispatch_serial();
133 set_abi_disp (disp);
134 }
135}
136
137
138// Decides which TM method should be used on the first attempt to run this
139// transaction. Acquires the serial lock and sets transaction state
140// according to the chosen TM method.
141GTM::abi_dispatch*
142GTM::gtm_thread::decide_begin_dispatch (uint32_t prop)
143{
144 abi_dispatch* dd;
145 // TODO Pay more attention to prop flags (eg, *omitted) when selecting
146 // dispatch.
147 // ??? We go irrevocable eagerly here, which is not always good for
148 // performance. Don't do this?
149 if ((prop & pr_doesGoIrrevocable) || !(prop & pr_instrumentedCode))
150 dd = dispatch_serialirr();
151
152 else
153 {
154 // Load the default dispatch. We're not an active transaction and so it
155 // can change concurrently but will still be some valid dispatch.
156 // Relaxed memory order is okay because we expect each dispatch to be
157 // constructed properly already (at least that its closed_nesting() and
158 // closed_nesting_alternatives() will return sensible values). It is
159 // harmless if we incorrectly chose the serial or serialirr methods, and
160 // for all other methods we will acquire the serial lock in read mode
161 // and load the default dispatch again.
162 abi_dispatch* dd_orig = default_dispatch.load(memory_order_relaxed);
163 dd = dd_orig;
164
165 // If we might need closed nesting and the default dispatch has an
166 // alternative that supports closed nesting, use it.
167 // ??? We could choose another TM method that we know supports closed
168 // nesting but isn't the default (e.g., dispatch_serial()). However, we
169 // assume that aborts that need closed nesting are infrequent, so don't
170 // choose a non-default method until we have to actually restart the
171 // transaction.
172 if (!(prop & pr_hasNoAbort) && !dd->closed_nesting()
173 && dd->closed_nesting_alternative())
174 dd = dd->closed_nesting_alternative();
175
176 if (!(dd->requires_serial() & STATE_SERIAL))
177 {
178 // The current dispatch is supposedly a non-serial one. Become an
179 // active transaction and verify this. Relaxed memory order is fine
180 // because the serial lock itself will have established
181 // happens-before for any change to the selected dispatch.
182 serial_lock.read_lock (this);
183 if (default_dispatch.load(memory_order_relaxed) == dd_orig)
184 return dd;
185
186 // If we raced with a concurrent modification of default_dispatch,
187 // just fall back to serialirr. The dispatch choice might not be
188 // up-to-date anymore, but this is harmless.
189 serial_lock.read_unlock (this);
190 dd = dispatch_serialirr();
191 }
192 }
193
194 // We are some kind of serial transaction.
195 serial_lock.write_lock();
196 state = dd->requires_serial();
197 return dd;
198}
199
200
201void
202GTM::gtm_thread::set_default_dispatch(GTM::abi_dispatch* disp)
203{
204 abi_dispatch* dd = default_dispatch.load(memory_order_relaxed);
205 if (dd == disp)
206 return;
207 if (dd)
208 {
209 // If we are switching method groups, initialize and shut down properly.
210 if (dd->get_method_group() != disp->get_method_group())
211 {
212 dd->get_method_group()->fini();
213 disp->get_method_group()->init();
214 }
215 }
216 else
217 disp->get_method_group()->init();
218 default_dispatch.store(disp, memory_order_relaxed);
219}
220
221
222static GTM::abi_dispatch*
223parse_default_method()
224{
225 const char *env = getenv("ITM_DEFAULT_METHOD");
226 GTM::abi_dispatch* disp = 0;
227 if (env == NULL)
228 return 0;
229
230 while (isspace((unsigned char) *env))
231 ++env;
232 if (strncmp(env, "serialirr_onwrite", 17) == 0)
233 {
234 disp = GTM::dispatch_serialirr_onwrite();
235 env += 17;
236 }
237 else if (strncmp(env, "serialirr", 9) == 0)
238 {
239 disp = GTM::dispatch_serialirr();
240 env += 9;
241 }
242 else if (strncmp(env, "serial", 6) == 0)
243 {
244 disp = GTM::dispatch_serial();
245 env += 6;
246 }
247 else if (strncmp(env, "gl_wt", 5) == 0)
248 {
249 disp = GTM::dispatch_gl_wt();
250 env += 5;
251 }
252 else if (strncmp(env, "ml_wt", 5) == 0)
253 {
254 disp = GTM::dispatch_ml_wt();
255 env += 5;
256 }
257 else if (strncmp(env, "htm", 3) == 0)
258 {
259 disp = GTM::dispatch_htm();
260 env += 3;
261 }
262 else
263 goto unknown;
264
265 while (isspace((unsigned char) *env))
266 ++env;
267 if (*env == '\0')
268 return disp;
269
270 unknown:
271 GTM::GTM_error("Unknown TM method in environment variable "
272 "ITM_DEFAULT_METHOD\n");
273 return 0;
274}
275
276// Gets notifications when the number of registered threads changes. This is
277// used to initialize the method set choice and trigger straightforward choice
278// adaption.
279// This must be called only by serial threads.
280void
281GTM::gtm_thread::number_of_threads_changed(unsigned previous, unsigned now)
282{
283 if (previous == 0)
284 {
285 // No registered threads before, so initialize.
286 static bool initialized = false;
287 if (!initialized)
288 {
289 initialized = true;
290 // Check for user preferences here.
291 default_dispatch = 0;
292 default_dispatch_user = parse_default_method();
293 }
294 }
295 else if (now == 0)
296 {
297 // No registered threads anymore. The dispatch based on serial mode do
298 // not have any global state, so this effectively shuts down properly.
299 set_default_dispatch(dispatch_serialirr());
300 }
301
302 if (now == 1)
303 {
304 // Only one thread, so use a serializing method.
305 // ??? If we don't have a fast serial mode implementation, it might be
306 // better to use the global lock method set here.
307 if (default_dispatch_user && default_dispatch_user->supports(now))
308 set_default_dispatch(default_dispatch_user);
309 else
310 set_default_dispatch(dispatch_serialirr());
311 }
312 else if (now > 1 && previous <= 1)
313 {
314 // More than one thread, use the default method.
315 if (default_dispatch_user && default_dispatch_user->supports(now))
316 set_default_dispatch(default_dispatch_user);
317 else
318 {
319 // If HTM is available, use it by default with serial mode as
320 // fallback. Otherwise, use ml_wt because it probably scales best.
321 abi_dispatch* a;
322#ifdef USE_HTM_FASTPATH
323 if (htm_available())
324 a = dispatch_htm();
325 else
326#endif
327 a = dispatch_ml_wt();
328 if (a->supports(now))
329 set_default_dispatch(a);
330 else
331 // Serial-irrevocable mode always works.
332 set_default_dispatch(dispatch_serialirr());
333 }
334 }
335}
336