Discovery and exploitation of general reductions: A constraint based approach

Ginsbach, Philip; O’Boyle, Michael

doi:10.1109/cgo.2017.7863746

Cited by 11 publications

(13 citation statements)

References 33 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Halide [26] is another parallelization tool based on SMT solver. Ginsbach et al presented techniques to discover reductions including simple scalar reductions and complex histogram reductions [14]. As shown in our evaluation, the state-of-the-art tool in this line of research, Parsynt from Farzan et al [11] cannot parallelize certain loops that our approach can work on.…”

Section: Related Workmentioning

confidence: 84%

Revealing parallel scans and reductions in recurrences through function reconstruction

Jiang

Chen

Agrawal

2018

Proceedings of the 27th International Conference on Parallel Architectures and Compilation Techniques

View full text Add to dashboard Cite

Many sequential loops are actually recurrences and can be parallelized across iterations as scans or reductions. Many efforts over the past 2+ decades have focused on parallelizing such loops by extracting and exploiting the hidden scan/reduction patterns. These approaches have largely been based on a heuristic search for closed-form composition of computations across loop iterations. While the search-based approaches are successful in parallelizing many recurrences, they have a large search overhead and need extensive program analysis. In this work, we propose a novel approach called sampling-and-reconstruction, which avoids the search for closed-form composition and has the potential to cover more recurrence loops. It is based on an observation that many recurrences can have a pointvalue representation. The loop iterations are divided across processors, and where the initial value(s) of the recurrence variable(s) are unknown, we execute with several chosen (sampling) initial values. Then, correct final result can be obtained by reconstructing the function from the outputs produced on the chosen initial values. Our approach is effective in parallelizing linear, rectified-linear, finite-state and multivariate recurrences, which cover all of the test cases in previous works. Our evaluation shows that our approach can parallelize a diverse set of sequential loops, including cases that cannot be parallelized by a state-of-the-art static parallelization tool, and achieves linear scalability across multiple cores.

show abstract

Section: Related Workmentioning

confidence: 84%

Revealing parallel scans and reductions in recurrences through function reconstruction

Jiang

Chen

Agrawal

2018

Proceedings of the 27th International Conference on Parallel Architectures and Compilation Techniques

View full text Add to dashboard Cite

show abstract

“…The C++ representation of the constraints and the user program LLVM IR code are then passed as inputs to a backtracking solver [16], which detects all cases where the idioms can be found in the LLVR IR.…”

Section: Compiler Flowmentioning

confidence: 99%

“…The compiler then emits C++ code which is passed to a generic solver based on [16] to search for idiom instances. This solver is based on standard backtracking.…”

Section: Compilation Process and Implementationmentioning

confidence: 99%

“…Work has focused on exploitation rather than discovery [18][19][20], examining trade-offs in implementation [52] or exploitation of novel hardware [42,51]. Recent work [16] shows that more complex reductions can be detected, but this is tied to an ad hoc non-portable code generation phase.…”

Section: Related and Future Workmentioning

confidence: 99%

“…In [16], constraints are used for detecting reductions, but this is tightly coupled to a specialized code generation phase for small-scale multi-core systems.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Automatic Matching of Legacy Code to Heterogeneous APIs

Ginsbach

Remmelg

Steuwer

et al. 2018

Proceedings of the Twenty-Third International Conference on Architectural Support for Programming Languages and Operating Syste

Self Cite

View full text Add to dashboard Cite

Heterogeneous accelerators often disappoint. They provide the prospect of great performance, but only deliver it when using vendor specific optimized libraries or domain specific languages. This requires considerable legacy code modifications, hindering the adoption of heterogeneous computing.This paper develops a novel approach to automatically detect opportunities for accelerator exploitation. We focus on calculations that are well supported by established APIs: sparse and dense linear algebra, stencil codes and generalized reductions and histograms. We call them idioms and use a custom constraint-based Idiom Description Language (IDL) to discover them within user code. Detected idioms are then mapped to BLAS libraries, cuSPARSE and clSPARSE and two DSLs: Halide and Lift.We implemented the approach in LLVM and evaluated it on the NAS and Parboil sequential C/C++ benchmarks, where we detect 60 idiom instances. In those cases where idioms are a significant part of the sequential execution time, we generate code that achieves 1.26× to over 20× speedup on integrated and external GPUs.CCS Concepts • Computer systems organization → Heterogeneous (hybrid) systems; • Software and its engineering → Domain specific languages; ACM Reference Format:

show abstract

Loop Parallelization using Dynamic Commutativity Analysis

Vasiladiotis

Lozano

Cole

et al. 2021

2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO)

View full text Add to dashboard Cite

Automatic parallelization has largely failed to keep its promise of extracting parallelism from sequential legacy code to maximize performance on multi-core systems outside the numerical domain. In this paper, we develop a novel dynamic commutativity analysis (DCA) for identifying parallelizable loops. Using commutativity instead of dependence tests, DCA avoids many of the overly strict data dependence constraints limiting existing parallelizing compilers. DCA extends the scope of automatic parallelization to uniformly include both regular arraybased and irregular pointer-based codes. We have prototyped our novel parallelism detection analysis and evaluated it extensively against five state-of-the-art dependence-based techniques in two experimental settings. First, when applied to the NAS benchmarks which contain almost 1400 loops, DCA is able to identify as many parallel loops (over 1200) as the profile-guided dependence techniques and almost twice as many as all the static techniques combined. We then apply DCA to complex pointer-based loops, where it can successfully detect parallelism, while existing techniques fail to identify any. When combined with existing parallel code generation techniques, this results in an average speedup of 3.6× (and up to 55×) across the NAS benchmarks on a 72-core host, and up to 36.9× for the pointer-based loops, demonstrating the effectiveness of DCA in identifying profitable parallelism across a wide range of loops.

show abstract

Discovery and exploitation of general reductions: A constraint based approach

Cited by 11 publications

References 33 publications

Revealing parallel scans and reductions in recurrences through function reconstruction

Revealing parallel scans and reductions in recurrences through function reconstruction

Automatic Matching of Legacy Code to Heterogeneous APIs

Loop Parallelization using Dynamic Commutativity Analysis

Contact Info

Product

Resources

About