Abstractions Logicielles pour Architectures Parallèles (original) (raw)
Related papers
New abstractions for data parallel programming
2009
Developing applications is becoming increasingly difficult due to recent growth in machine complexity along many dimensions, especially that of parallelism. We are studying data types that can be used to represent data parallel operations. Developing parallel programs with these data types have numerous advantages and such a strategy should facilitate parallel programming and enable portability across machine classes and machine generations without significant performance degradation.
Lcpc, 1995
It is our pleasure to present the papers from the 20th International Workshop on Languages and Compilers for Parallel Computing! For the past 19 years, this workshop has been one of the primary venues for presenting and learning about a wide range of current research in parallel computing. We believe that tradition has continued in this, the 20th year of the workshop.
Abstractions for portable, scalable parallel programming
IEEE Transactions on Parallel and Distributed Systems, 1998
In parallel programming, the need to manage communication costs, load imbalance, and irregularities in the computation puts substantial demands on the programmer. Key properties of the architecture, such as the number of processors and the costs of communication, must be exploited to achieve good performance. Coding these properties directly into a program compromises the portability and exibility of the code because signicant changes are usually needed to port or enhance the program. We describe a parallel programming model that supports the concise, independent description of key aspects of a parallel program|such as data distribution, communication, and boundary conditions|without reference to machine idiosyncrasies. The independence of such components improves portability by allowing the components of a program to be tuned independently, and encourages reuse by supporting the composition of existing components. The architecture-sensitive aspects of a computation are isolated from the rest of the program, reducing the need to make extensive changes to port a program. This model is eective in exploiting both data parallelism and functional parallelism. This paper provides programming examples, compares this work to related languages, and presents performance results.
Views on template-based parallel programming
1996
For almost a decade we h a v e been working at developing and using template-based models for coarse-grained parallel computing. Our initial system, FrameWorks, was positively received but had a number of shortcomings. The Enterprise parallel programming environment evolved out of this work, and now, after several years of experience with the system, its shortcomings are becoming evident. This paper outlines our experiences in developing and using the two parallel programming systems. Many of our observations are relevant to other parallel programming systems, even though they may be based on dierent assumptions. Although template-base models have the potential for simplifying the complexities of parallel programming, they have y et to realize these expectations for high-performance applications.
Booster: a high-level language for portable parallel algorithms
Applied Numerical Mathematics, 1991
The development of programming languages suitable to express parallel algorithms in is crucial to the pace of acceptance of parallel processors for production applications. As in sequential programming, portability of parallel software is a strongly desirable feature. Portability in this respect means that given an algorithm description in a parallel programming language, it must be possible, with relatively little effort, to generate efficient code for several classes of (parallel) architectures.
2014
— With the start of the parallel computing era, due to power and thermal considerations, there is a growing need to bridge the gap between parallel hardware and software. The unintuitive nature of parallel programming and the high learning curve often prove a bottleneck in the development of quality parallel software. We propose HAMP – A Highly Abstracted and Modular Programming paradigm for expressing parallel programs. We provide the developer with high level modular constructs that can use to generate hardware specific optimized code. HAMP abstracts programs into important kernels and provides scheduling support to manage parallelism. By abstracting the scheduling and hardware features from the developer, we cannot only, considerably reduce the learning curve, but also increase software lifetime Keywords- Bottleneck code, highly abstracted, modular programming, parallel constructs, customized code I.
An adaptive compilation framework for generic data-parallel array programming
2010
Abstract. Generic array programming abstracts from structural properties of arrays, such as rank (number of axes/dimensions) and shape (number of element along each axis/dimension). This allows for abstract program specifications and, as such, is desirable from a software engineering perspective. However, generic programming in this sense does have an adverse effect on runtime performance when executed naively.
Task Parallelism and Data Distribution: An Overview of Explicit Parallel Programming Languages
Lecture Notes in Computer Science, 2013
Programming parallel machines as effectively as sequential ones would ideally require a language that provides high-level programming constructs to avoid the programming errors frequent when expressing parallelism. Since task parallelism is considered more error-prone than data parallelism, we survey six popular and efficient parallel language designs that tackle this difficult issue: Cilk, Chapel, X10, Habanero-Java, OpenMP and OpenCL. Using as single running example a parallel implementation of the computation of the Mandelbrot set, this paper describes how the fundamentals of task parallel programming, i.e., collective and point-to-point synchronization and mutual exclusion, are dealt with in these languages. We discuss how these languages allocate and distribute data over memory. Our study suggests that, even though there are many keywords and notions introduced by these languages, they all boil down, as far as control issues are concerned, to three key task concepts: creation, synchronization and atomicity. Regarding memory models, these languages adopt one of three approaches: shared memory, message passing and PGAS (Partitioned Global Address Space). The paper is designed to give users and language and compiler designers an upto-date comparative overview of current parallel languages. Recent programming models explore the best trade-offs between expressiveness and performance when addressing parallelism. Traditionally, there are two general ways to break an application into concurrent parts in order to take advantage of a parallel computer and execute them simultaneously on different CPUs: data and task parallelisms.
2000
Java.- High Performance Numerical Computing in Java: Language and Compiler Issues.- Instruction Scheduling in the Presence of Java's Runtime Exceptions.- Dependence Analysis for Java.- Low-Level Transformations A.- Comprehensive Redundant Load Elimination for the IA-64 Architecture.- Minimum Register Instruction Scheduling: A New Approach for Dynamic Instruction Issue Processors.- Unroll-Based Copy Elimination for Enhanced Pipeline Scheduling.- Data Distribution.- A Linear Algebra Formulation for Optimising Replication in Data Parallel Programs.- Accurate Data and Context Management in Message-Passing Programs.- An Automatic Iteration/Data Distribution Method Based on Access Descriptors for DSMM.- High-Level Transformations.- Inter-array Data Regrouping.- Iteration Space Slicing for Locality.- A Compiler Framework for Tiling Imperfectly-Nested Loops.- Models.- Parallel Programming with Interacting Processes.- Application of the Polytope Model to Functional Programs.- Multilingua...
Languages and Compilers for Parallel Computing
Lecture Notes in Computer Science, 2000
The topics covered include languages and language extensions for parallel computing - a status report on CONSUL, a future-based parallel language for a general-purpose high-parallel computer; COOL, blackboard programming in shared Prolog, refined C, the XYZ ...