Combining thread level speculation helper threads and runahead execution

Abstract

With the current trend toward multicore architectures, improved execution performance can no longer be obtained via traditional single-thread instruction level parallelism (ILP), but, instead, via multithreaded execution. Generating thread-parallel programs is hard and thread-level speculation (TLS) has been suggested as an execution model that can speculatively exploit thread-level parallelism (TLP) even when thread independence cannot be guaranteed by the programmer/compiler. Alternatively, the helper threads (HT) execution model has been proposed where subordinate threads are executed in parallel with a main thread in order to improve the execution efficiency (i.e., ILP) of the latter. Yet another execution model, runahead execution (RA), has also been proposed where subordinate versions of the main thread are dynamically created especially to cope with long-latency operations, again with the aim of improving the execution efficiency of the main thread.Each one of these multithreaded execution models works best for different applications and application phases. In this paper we combine these three models into a single execution model and single hardware infrastructure such that the system can dynamically adapt to find the most appropriate multithreaded execution model. More specifically, TLS is favored whenever successful parallel execution of instructions in multiple threads (i.e., TLP) is possible and the system can seamlessly transition at run-time to the other models otherwise. In order to understand the tradeoffs involved, we also develop a performance model that allows one to quantitatively attribute overall performance gains to either TLP or ILP in such combined multithreaded execution model.Experimental results show that our unified execution model achieves speedups of up to 41.2%, with an average of 10.2%, over an existing state-of-the-art TLS system and speedups of up to 35.2%, with an average of 18.3%, over a flavor of runahead execution for a subset of the SPEC2000 Int benchmark suite.

Profitability-based power allocation for speculative multithreaded systems

“…Although this optimistic view of the existence of dependences usually results in a better performance, it does so at the cost of an increase in power when speculation fails. It is interesting to note that even when speculation fails, we may still be able to gain benefits, due to prefetching effects as it was previously reported in [19] and [28].…”

“…Albeit simple, this approach can be very detrimental in terms of performance. As was pointed out in [28] even threads that do squash may be useful for prefetching reasons. By stalling threads that squash, we remove much of this desirable side-effect of TLS execution.…”

Automatic parallelization of fine-grained meta-functions on a chip multiprocessor

“…Many works have improved singlethread performance by using helper threads [16,28,35,37,38]. In [16,28], to tolerate memory bottlenecks, the helper threads perform pre-execution with idle hardware resources.…”

“…In [16,28], to tolerate memory bottlenecks, the helper threads perform pre-execution with idle hardware resources. Xekalakis et al [38] combined helper threads with Thread-Level Speculation and Runahead execution. Tiwari et al [35] used a helper thread to accelerate memory management.…”

Renumbering Methods to Unleash Multi-Threaded Approaches for a General Navier-Stokes Implementation

“…For large general applications, like Code_Saturne developed by EDF for decades, generating threads is very complex without recoding or introducing data structures. Among the standard thread models (OpenMP and Posix threads) and the innovative models (Thread Level Speculation (TLS), Transactional Memory, Helper Thread, Runahead thread [1]) we focus here on the modelling programming based on compiler directives with the constraint to minimize the recoding impact.…”