Intermediate language extensions for parallelism

Zhao, Jisheng; Sarkar, Vivek

doi:10.1145/2095050.2095103

Cited by 17 publications

(4 citation statements)

References 34 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Figure 31 presents the overall structure of the HJC compiler. The Polyglot [Nystrom et al 2003]-based front-end for HJ was modified to emit a new Parallel Intermediate Representation (PIR) extension [Zhao and Sarkar 2011] to the Jimple intermediate representation used in the SOOT bytecode analysis and transformation framework [Vallée-Rai et al 1999]. In addition to standard Java operators, the PIR includes explicit constructs for parallel operations, such as async, finish, and isolated.…”

Section: Methodsmentioning

confidence: 99%

A Transformation Framework for Optimizing Task-Parallel Programs

Nandivada

Shirako

Zhao

et al. 2013

ACM Trans. Program. Lang. Syst.

Self Cite

View full text Add to dashboard Cite

Task parallelism has increasingly become a trend with programming models such as OpenMP 3.0, Cilk, Java Concurrency, X10, Chapel and Habanero-Java (HJ) to address the requirements of multicore programmers. While task parallelism increases productivity by allowing the programmer to express multiple levels of parallelism, it can also lead to performance degradation due to increased overheads. In this article, we introduce a transformation framework for optimizing task-parallel programs with a focus on task creation and task termination operations. These operations can appear explicitly in constructs such as async, finish in X10 and HJ, task, taskwait in OpenMP 3.0, and spawn, sync in Cilk, or implicitly in composite code statements such as foreach and ateach loops in X10, forall and foreach loops in HJ, and parallel loop in OpenMP.Our framework includes a definition of data dependence in task-parallel programs, a happens-before analysis algorithm, and a range of program transformations for optimizing task parallelism. Broadly, our transformations cover three different but interrelated optimizations: (1) finish-elimination, (2) forall-coarsening, and (3) loop-chunking. Finish-elimination removes redundant task termination operations, forall-coarsening replaces expensive task creation and termination operations with more efficient synchronization operations, and loop-chunking extracts useful parallelism from ideal parallelism. All three optimizations are specified in an iterative transformation framework that applies a sequence of relevant transformations until a fixed point is reached. Further, we discuss the impact of exception semantics on the specified transformations, and extend them to handle task-parallel programs with precise exception semantics. Experimental results were obtained for a collection of task-parallel benchmarks on three multicore platforms: a dual-socket 128-thread (16-core) Niagara T2 system, a quad-socket 16-core Intel Xeon SMP, and a quad-socket 32-core Power7 SMP. We have observed that the proposed optimizations interact with each other in a synergistic way, and result in an overall geometric average performance improvement between 6.28× and 10.30×, measured across all three platforms for the benchmarks studied.This article is an extended and reorganized version of the following two previous articles from conference proceedings [Shirako et al. 2009;

show abstract

Section: Methodsmentioning

confidence: 99%

A Transformation Framework for Optimizing Task-Parallel Programs

Nandivada

Shirako

Zhao

et al. 2013

ACM Trans. Program. Lang. Syst.

Self Cite

View full text Add to dashboard Cite

show abstract

“…Second, the compiler can use intrinsic functions to demark parallel tasks. (For examples, see [37,55,72].) Often, either existing serial analyses and optimizations must be shut down when code contains these intrinsics, or the intrinsics offer minimal opportunities for compiler optimization.…”

Section: Previous Approachesmentioning

confidence: 99%

“…Third, the compiler can use a separate IR to encode logical parallelism in the program. The HPIR [7,72], SPIRE [29], and INSPIRE [27] representations, for instance, model parallel constructs using an alternative IR, such as one based on the program's abstract syntax tree [2,Sec. 2.5.1].…”

Section: Previous Approachesmentioning

confidence: 99%

Tapir

Schardl

Moses

Leiserson

2017

Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

View full text Add to dashboard Cite

This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as syntactic sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code-including loop-invariant-code motion, commonsubexpression elimination, and tail-recursion eliminationto work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.

show abstract

“…Other authors have described parallel intermediate representations (IRs), which typically are sequential IRs with parallel extensions [39]. STC's IR semantics are, in contrast, fully based on a data-driven task parallel execution model with asynchronous execution and monotonic data structures built-in.…”

Section: Related Work On Compiler Optimizationmentioning

confidence: 99%

Compiler Techniques for Massively Scalable Implicit Task Parallelism

Armstrong

Wozniak

Wilde

et al. 2014

SC14: International Conference for High Performance Computing, Networking, Storage and Analysis

View full text Add to dashboard Cite

Swift/T is a high-level language for writing concise, deterministic scripts that compose serial or parallel codes implemented in lower-level programming models into large-scale parallel applications. It executes using a data-driven task parallel execution model that is capable of orchestrating millions of concurrently executing asynchronous tasks on homogeneous or heterogeneous resources. Producing code that executes efficiently at this scale requires sophisticated compiler transformations: poorly optimized code inhibits scaling with excessive synchronization and communication. We present a comprehensive set of compiler techniques for data-driven task parallelism, including novel compiler optimizations and intermediate representations.We report application benchmark studies, including unbalanced tree search and simulated annealing, and demonstrate that our techniques greatly reduce communication overhead and enable extreme scalability, distributing up to 612 million dynamically load balanced tasks per second at scales of up to 262,144 cores without explicit parallelism, synchronization, or load balancing in application code.

show abstract

Intermediate language extensions for parallelism

Cited by 17 publications

References 34 publications

A Transformation Framework for Optimizing Task-Parallel Programs

A Transformation Framework for Optimizing Task-Parallel Programs

Tapir

Compiler Techniques for Massively Scalable Implicit Task Parallelism

Contact Info

Product

Resources

About