Support for Thread-Level Speculation into OpenMP

Aldea, Sergio; Llanos, Diego R.; González-Escribano, Arturo

doi:10.1007/978-3-642-30961-8_25

Cited by 6 publications

(5 citation statements)

References 5 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…When BFCA+ detects such a situation, it is also able to label as speculative all variables whose definition or use may potentially lead to a dependency violation. Unlike shared and private clauses, the speculative clause is not part of the OpenMP standard, but a new clause first proposed by our group [4]. This proposal was later implemented in the ATLaS framework, the second solution BFCA+ is built upon.…”

Section: Bfca+ Architecture and Usagementioning

confidence: 98%

“…-BFCA [4,5] is an analysis framework that extracts profiling and dependency information of for loops in C code, in order to detect which for loops are the best candidates for parallelization. -ATLaS is a TLS compile [6] and runtime system [7] that extends OpenMP functionalities with a new speculative clause, to allow the parallelization of for loops that are not guaranteed at compile time to be dependency free.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

BFCA+: automatic synthesis of parallel code with TLS capabilities

2016

Self Cite

View full text Add to dashboard Cite

Parallelization of sequential applications requires extracting information about the loops and how their variables are accessed, and afterwards, augmenting the source code with extra code depending on such information. In this paper we propose a framework that avoids such an error-prone, time-consuming task. Our solution leverages the compile-time information extracted from the source code to classify all variables used inside each loop according to their accesses. Then, our system, called BFCA+, automatically instruments the source code with the necessary OpenMP directives and clauses to allow its parallel execution, using the standard shared and private clauses for variable classification. The framework is also capable of instrumenting loops for speculative parallelization, with the help of the ATLaS runtime system, that defines a new speculative clause to point out those variables that may lead to a dependency violation. As a result, the target loop is guaranteed to correctly run in parallel, ensuring that its execution follows sequential semantics even in the presence of dependency violations. Our experimental evaluation shows that the framework not only saves development time, but also leads to a faster code than the one manually parallelized.

show abstract

Section: Bfca+ Architecture and Usagementioning

confidence: 98%

Section: Introductionmentioning

confidence: 99%

BFCA+: automatic synthesis of parallel code with TLS capabilities

2016

Self Cite

View full text Add to dashboard Cite

show abstract

“…The second part of the ATLaS framework is a GCC plugin that extends OpenMP with a new speculative() clause [ 51 – 53 ]. This extension allows the programmer to indicate that a loop should be speculatively parallelized, and to declare the set of variables whose accesses may potentially lead to a dependence violation.…”

Section: Experimental Evaluationmentioning

confidence: 99%

On the choice of the best chunk size for the speculative execution of loops

et al. 2022

Self Cite

View full text Add to dashboard Cite

Loops are a rich source of parallelism. Unfortunately, many loops cannot be safely parallelized at compile time because the compiler is not able to guarantee that there will be no dependence violations. Thread-Level Speculation (TLS) techniques, either hardware or software-based, allow the parallel execution of non-analyzable loops, issuing the execution of blocks of consecutive iterations (called chunks) while a hardware or software monitor ensures that no dependence violations arise. If such a dependence violation occurs, the chunk that was fed with incorrect values is discarded and re-started, in order to consume the correct information. In the speculative execution of non-analyzable loops, it is very important to correctly choose the chunk size, because this choice dramatically affects the performance of the parallel execution. Bigger chunks imply less scheduling overheads, but smaller chunks allow fewer calculations to be discarded in the event of a dependence violation. To find a good chunk size is not a simple task, because loops may present dependencies that cannot be detected at compile time. In this paper, we present a comprehensive evaluation of different scheduling methods to estimate the optimal chunk size in the speculative execution of non-analyzable loops. This evaluation ranges from the simple, classical methods originally devised to achieve load balancing in loops with no dependencies, to methods that make some assumptions on the distribution pattern of dependencies, such as Meseta and Just-in-Time scheduling. We also propose and evaluate a general, more complex method called Moody Scheduling, that does not require a-priori assumptions to achieve the highest performance.

show abstract

“…[Aldea et al 2014; developed a GCC plugin so as to add loop-based TLS support to OpenMP. Their proposal include the development of a new OpenMP speculative clause to be used in for loops [Aldea et al 2012], which allowed programmers to declare all variables whose reads or writes may lead to dependence violations. The use of this clause guaranteed that all definitions and uses of speculative variables would follow sequential semantics.…”

Section: 22mentioning

confidence: 99%