Loop Selection for Thread-Level Speculation

Abstract

Abstract. Thread-level speculation (TLS) allows potentially dependent threads to speculatively execute in parallel, thus making it easier for the compiler to extract parallel threads. However, the high cost associated with unbalanced load, failed speculation, and inter-thread value communication makes it difficult to obtain the desired performance unless the speculative threads are carefully chosen.In this paper, we focus on extracting parallel threads from loops in generalpurpose applications because loops, with their regular structures and significant coverage on execution time, are ideal candidates for extracting parallel threads. General-purpose applications, however, usually contain a large number of nested loops with unpredictable parallel performance and dynamic behavior, thus making it difficult to decide which set of loops should be parallelized to improve overall program performance. Our proposed loop selection algorithm addresses all these difficulties. We have found that (i) with the aid of profiling information, compiler analyses can achieve a reasonably accurate estimation of the performance of parallel execution, and that (ii) different invocations of a loop may behave differently, and exploiting this dynamic behavior can further improve performance. With a judicious choice of loops, we can improve the overall program performance of SPEC2000 integer benchmarks by as much as 20%.

Supporting Speculative Multithreading on Simultaneous Multithreaded Processors

“…The compiler also generates synchronization instructions for frequently occurred cross-iteration data dependences. Our compiler framework and the loop selection methodology are described in detail in [14]. Table 2 shows the details of benchmarks (from SPEC2000) used to evaluate our scheme.…”

“…Due to this consideration, LSQ based architectures can support only small threads. But our research [14] shows that if we need to consider a more realistic overhead of forking a thread, it becomes more difficult to justify at small granularities. Hence, it is important to support larger threads.…”

Adaptive Fork-Heuristics for Software Thread-Level Speculation

“…Whaley and Kozyrakis [13] proposed three classes of heuristics for method-level speculation, and found that single-pass heuristics lead to best speedups while simple/complex multi-pass heuristics tend to over/under speculation. Wang et al [12] constructed a loop-graph and used it for global loop selection to maximize program performance. Liu et al [8] proposed an online-profiling approach to speculatively parallelize candidate loops.…”

Loop recreation for thread-level speculation

“…To the best of our knowledge, existing loop-oriented techniques [3,10,11,13,14,15] form threads only at loop boundaries by turning loop iterations into threads. In [10,14,15], frequently occurring dependences are synchronized.…”

“…If we turn loop iterations directly into speculative threads as in existing looporiented compiler techniques [3,10,11,13,14,15], some inter-iteration dependences in the loop, which become inter-thread dependences at run time, can be too costly to enforce. Furthermore, value prediction may not be effective for irregular loops accessing arrays with…”