scispace - formally typeset
Proceedings ArticleDOI

May-happen-in-parallel analysis of X10 programs

Reads0
Chats0
TLDR
A new algorithm for May-Happen-in-Parallel (MHP) analysis of X10 programs is introduced, based on simple path traversals in the Program Structure Tree, and does not rely on pointer alias analysis of thread objects as in MHP analysis for Java programs.
Abstract
X10 is a modern object-oriented programming language designed for high performance, high productivity programming of parallel and multi-core computer systems. Compared to the lower-level thread-based concurrency model in the JavaTM language, X10 has higher-level concurrency constructs such as async, atomic and finish built into the language to simplify creation, analysis and optimization of parallel programs. In this paper, we introduce a new algorithm for May-Happen-in-Parallel (MHP) analysis of X10 programs. The analysis algorithm is based on simple path traversals in the Program Structure Tree, and does not rely on pointer alias analysis of thread objects as in MHP analysis for Java programs. We introduce a more precise definition of the MHP relation than in past work by adding condition vectors that identify execution instances for which the MHP relation holds, instead of just returning a single true/false value for all pairs of executing instances. Further, MHP analysis is refined in our approach by using the observation that two statement instances which occur in atomic sections that execute at the same X10 place must have MHP = false. We expect that our MHP analysis algorithm will be applicable to any language that adopts the core concepts of places, async, finish, and atomic sections from the X10 programming model. We also believe that this approach offers the best of two worlds to programmers and parallel programming tools ---higher-level abstractions of concurrency coupled with simple and efficient analysis algorithms.

read more

Content maybe subject to copyright    Report

Citations
More filters
Proceedings ArticleDOI

Habanero-Java: the new adventures of old X10

TL;DR: The Habanero-Java language developed at Rice University is presented as an extension to the original Java-based definition of the X10 language, which includes a powerful set of task-parallel programming constructs that can be added as simple extensions to standard Java programs to take advantage of today's multi-core and heterogeneous architectures.
Journal ArticleDOI

Analysis of recursively parallel programs

TL;DR: A general formal model of isolated hierarchical parallel computations is proposed, and several fragments are identified to match the concurrency constructs present in real-world programming languages such as Cilk and X10.
Proceedings ArticleDOI

Featherweight X10: a core calculus for async-finish parallelism

TL;DR: A type system that solves the open problem of context-sensitive may-happen-in-parallel analysis for languages with async-finish parallelism and proves the correctness of the type system.
Book ChapterDOI

Efficient data race detection for async-finish parallelism

TL;DR: An efficient dynamic race detector algorithm targeting the async-finish task-parallel parallel programming model, which generalize the spawn-sync constructs used in Cilk, while still ensuring that all computation graphs are deadlock-free.
Proceedings ArticleDOI

Tapir: Embedding Fork-Join Parallelism into LLVM's Intermediate Representation

TL;DR: 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) with only minor changes to its existing analyses and code transformations.
References
More filters
Journal ArticleDOI

The program dependence graph and its use in optimization

TL;DR: An intermediate program representation, called the program dependence graph (PDG), that makes explicit both the data and control dependences for each operation in a program, allowing transformations to be triggered by one another and applied only to affected dependences.
Proceedings ArticleDOI

X10: an object-oriented approach to non-uniform cluster computing

TL;DR: A modern object-oriented programming language, X10, is designed for high performance, high productivity programming of NUCC systems and an overview of the X10 programming model and language, experience with the reference implementation, and results from some initial productivity comparisons between the X 10 and Java™ languages are presented.
Proceedings ArticleDOI

Optimizing supercompilers for supercomputers

TL;DR: This work will focus a great deal on the importance of compilers in supercomputing, and compare and contrast the advantages and impacts of compiler solutions to the "Performance + Portability + Productivity" problem with language and runtime solutions.
Journal ArticleDOI

A fast algorithm for finding dominators in a flowgraph

TL;DR: A fast algorithm for finding dominators in a flowgraph is presented, which beat the straightforward algorithm and the bit vector algorithm on all but the smallest graphs tested.
Proceedings ArticleDOI

Detecting equality of variables in programs

TL;DR: An algorithm for detecting when two computations produce equivalent values by developing a static property called congruence, which is conservative in that any variables detected to be e:quivalent will in fact be equivalent, but not all equivalences are detected.
Related Papers (5)