Academia.eduAcademia.edu

Outline

Title
Abstract
Basic Analysis Techniques
Array Data Ow Analysis
Conclusion
References
All Topics
Computer Science
Software Engineering

Compiling for massively parallel architectures: a perspective

Profile image of Paul FeautrierPaul Feautrier

1995, Microprocessing and Microprogramming

https://doi.org/10.1016/0165-6074(95)00025-J
visibility

…

description

20 pages

link

1 file

Abstract

The problem of automatically generating programs for massively parallel computers is a very complicated one, mainly because there are many architectures, each of them seeming to pose its own particular compilation problem. The purpose of this paper is to propose a framework in which to discuss the compilation process, and to show that the features which a ect it are few and generate a small number of combinations. The paper is oriented toward ne-grained parallelization of static control programs, with emphasis on data ow analysis, scheduling and placement. When going from there to more general programs and to coarser parallelism, one encounters new problems, some of which are discussed in the conclusion.

Related papers

Compiling parallel programs by optimizing performance
Young-il Choo

The Journal of Supercomputing, 1988

This paper describes how Crystal, a language based on familiar mathematical notation and lambda calculus, addresses the issues of programmability and performance for parallel supercomputers. Some scientifc programmers and theoreticians may ask, "What is new about Crystal?" or "How is it different from existing functional languages?" The answers lie in its model of parallel computation and a theory of parallel program optimization, and we examine this in the text to follow. We illustrate the power of our approach with benchmarks of compiled parallel code from Crystal source. The target machines are hypercube multiprocessors with distributed memory, on which it is considered difficult for functional programs to achieve high efficiency.

View PDFchevron_right
Parallel architecture and compilation techniques: selection of workshop papers, guests' editors introduction
Cosimo Prete, Roberto Giorgi

2001

In this issue, we present a selection of papers from several workshops held in September 2001 in Barcelona, Spain. The workshops were hosted within the PACT (Parallel Architecture and Compilation Techniques)

View PDFchevron_right
Parallel incremental compilation
Neal Gafter

1990

View PDFchevron_right
Compiling Global Name-Space Programs for Distributed Execution
Piyush Mehrotra

1990

Distributed memory machines do not provide hardware support for a global address space. Thus programmers are forced to partition the data across the memories of the architecture and use explicit message passing to communicate data between processors. In this paper we focus on the compiler support required to allow programmers to express their algorithms using a global name-space. We present a general method for analysis of a high level source program and its translation, to a set of independently executing tasks communicating via messages. If the compiler has enough information, this translation can be carried out at compile-time. Otherwise run-time code is generated to implement the required data movement. We describe the analysis required in both situations and present the performance of the generated code on the Intel iPSC/2.

View PDFchevron_right
Compiling Data-Parallel Programs to a Distributed Runtime Environment with Thread Isomigration
Christian Perez

Parallel Processing Letters, 2000

Traditionally, the compilation of data-parallel languages is targeted to low-level runtime environments: abstract processors are mapped onto static system processes, which directly address the low-level IPC library. Alternatively, we propose to map each HPF abstract processor onto a "lightweight process" (thread) which can be freely migrated between nodes together with the data it manages, under the supervision of some external scheduler. We discuss the pros and cons of such an approach and the facilities which must be provided by the multithreaded runtime. We describe a prototype HPF compiler built along these lines, based on the Adaptor HPF compiler and the PM2 multithreaded runtime environment.

View PDFchevron_right
A parallelizing compiler for multicore systems
Jose M Andion

Proceedings of the 17th International Workshop on Software and Compilers for Embedded Systems - SCOPES '14, 2014

This manuscript summarizes the main ideas introduced in [1]. We propose a compiler that automatically transforms a sequential application into a parallel counterpart for multicore processors. It is based on an intermediate representation, named KIR, which exposes multiple levels of parallelism and hides the complexity of the implementation details thanks to the domain-independent kernels (e.g., assignment, reduction). The effectiveness and performance of our approach, built on top of GCC, has been tested with a large variety of codes.

View PDFchevron_right
Special Issue: Current Trends in Compilers for Parallel Computers
Basilio B Fraguela

Concurrency and Computation: Practice and Experience, 2007

View PDFchevron_right
TAM - A Compiler Controlled Threaded Abstract Machine
Seth C Goldstein

Journal of Parallel and Distributed Computing, 1993

The Threaded Abstract Machine (TAM) refines dataflow execution models to address the critical constraints that modern parallel architectures place on the compilation of general-purpose parallel programming languages. TAM defines a self-scheduled machine language of parallel threads, which provides a path from dataflowgraph program representations to conventional control flow. The most important feature of TAM is the way it exposes the interaction between the handling of asynchronous message events, the scheduling of computation, and the utilization of the storage hierarchy.

View PDFchevron_right
Demonstration of automatic data partitioning techniques for parallelizing compilers on multicomputers
Manish Gupta

1992

Abstract An approach to the problem of automatic data partitioning is introduced. The notion of constraints on data distribution is presented, and it is shown how, based on performance considerations, a compiler identifies constraints to be imposed on the distribution of various data structures. These constraints are then combined by the compiler to obtain a complete and consistent picture of the data distribution scheme, one that offers good performance in terms of the overall execution time.

View PDFchevron_right
An Approach for Compiler Optimization to Exploit Instruction Level Parallelism
Rajendra Kumar

Instruction Level Parallelism (ILP) is not the new idea. Unfortunately ILP architecture not well suited to for all conventional high level language compilers and compiles optimization technique. Instruction Level Parallelism is the technique that allows a sequence of instructions derived from a sequential program (without rewriting) to be parallelized for its execution on multiple pipelining functional units. As a result, the performance is increased while working with current softwares. At implicit level it initiates by modifying the compiler and at explicit level it is done by exploiting the parallelism available with the hardware. To achieve high degree of instruction level parallelism, it is necessary to analyze and evaluate the technique of speculative execution control dependence analysis and to follow multiple flows of control. The researchers are continuously discovering the ways to increase parallelism by an order of magnitude beyond the current approaches. In this paper we present impact of control flow support on highly parallel architecture with 2- core and 4-core. We also investigated the scope of parallelism explicitly and implicitly. For our experiments we used trimaran simulator. The benchmarks are tested on abstract machine models created through trimaran simulator.

View PDFchevron_right

References (41)

  1. Saman P. Amarasinghe, Jennifer M. Anderson, Monica S. Lam, and Amy W. Lim. An overview of a compiler for scalable parallel machines. In Sixth Annual Workshop on Languages and Compilers for Parallel Computing, pages 253{272. Springer Verlag, LNCS 768, August 1993.
  2. Michel Auguin, Fernand Bo eri, and Jean-Paul Dalban. Synth ese et evaluation du projet OPSILA. TSI, 9:79{98, 1990.
  3. AI91] Corinne Ancourt and Fran cois Irigoin. Scanning polyhedra with DO loops. In Proc. third SIGPLAN Symp. on Principles and Practice of Parallel Program- ming, pages 39{50. ACM Press, April 1991.
  4. Jennifer M. Anderson and Monica S. Lam. Global optimization for parallelism and locality on scalable parallel machines. ACM Sigplan Notices, 28:112{125, June 1993.
  5. A. J. Bernstein. Analysis of programs for parallel processing. IEEE Trans. on El. Computers, EC-15, 1966.
  6. BKK + 94] David Bau, Indupras Kodukula, Vladimir Kotlyar, Keshav Pingali, and Paul Stodghill. Solving alignment using elementary linear algebra. In Seventh Annual Workshop on Languages and Compilers for Parallel Computing, pages 46{60. Springer-Verlag, LNCS 892, August 1994.
  7. Luc Boug e. Le mod ele de programmation a parall elisme de donn es : une per- spective s emantique. T.S.I., 12(5):541{562, 1993.
  8. Jean-Fran cois Collard, Denis Barthou, and Paul Feautrier. Fuzzy array data ow analysis. In ACM SIGPLAN Symp. on Principles and Practice of Parallel Pro- gramming. ACM, July 1995.
  9. Lucien M. Censier and Paul A. Feautrier. A new solution to coherence problems in multicache systems. IEEE Trans. on Computers, C-27:1112{1118, December 1978.
  10. Jean-Fran cois Collard, Paul Feautrier, and Tanguy Risset. Construction of do loops from systems of a ne constraints. Parallel Processing Letters, to appear, 1994.
  11. Nicholas Carriero and David Gelernter. How to write parallel programs: a guide to the perplexed. ACM Computing Surveys, 21(3), September 1989.
  12. Zbigniew Chamski. Environnement logiciel de programmation d'un acc el erateur de calcul parall ele. PhD thesis, IFSIC, Rennes I, February 1993.
  13. Jean-Fran cois Collard. Code generation in automatic parallelizers. In Claude Girault, editor, Proc. Int. Conf. on Application in Parallel and Distributed Com- puting, IFIP WG 10.3, pages 185{194. North Holland, April 1994.
  14. A. Darte. Techniques de parall elisation automatique de nids de boucles. PhD thesis, ENS Lyon, April 1993.
  15. Alain Darte and Yves Robert. Mapping uniform loop nests onto distributed memory architectures. Parallel Computing, 20:679{710, 1994.
  16. Alain Darte and Yves Robert. A ne-by-statement scheduling of uniform and a ne loop nests over parametric domains. J. Parallel and Distributed Comput- ing, 1995. to appear.
  17. Alain Darte and Fr ed eric Vivien. Automatic parallelization based on multidi- mensional scheduling. Technical Report RR 94-24, LIP, 1994.
  18. Paul Feautrier. Array expansion. In ACM Int. Conf. on Supercomputing, pages 429{441, 1988.
  19. Paul Feautrier. Parametric integer programming. RAIRO Recherche Op erationnelle, 22:243{268, September 1988.
  20. Paul Feautrier. Data ow analysis of scalar and array references. Int. J. of Parallel Programming, 20(1):23{53, February 1991.
  21. Paul Feautrier. Some e cient solutions to the a ne scheduling problem, I, one dimensional time. Int. J. of Parallel Programming, 21(5):313{348, October 1992.
  22. Paul Feautrier. Some e cient solutions to the a ne scheduling problem, II, mul- tidimensional time. Int. J. of Parallel Programming, 21(6):389{420, December 1992.
  23. Paul Feautrier. Toward automatic distribution. Parallel Processing Letters, 4(3):233{244, 1994.
  24. C. Heckler and L. Thiele. Computing linear data dependencies in nested loop programs. Parallel Processing Letters, 4(3):193{204, 1994.
  25. Iri87] Fran cois Irigoin. Partitionnement de boucles imbriqu ees, une technique d'optimisation pour les programmes scienti ques. PhD thesis, Universit e P. et M. Curie, Paris, June 1987.
  26. IT88] Fran cois Irigoin and R emi Triolet. Supernode partitioning. In Proc. 15th POPL, pages 319{328, San Diego, Cal., January 1988.
  27. Wayne Kelly and William Pugh. Generating schedules and code within a uni ed reordering transformation framework. Technical Report TR-92-126, Univ. of Maryland, November 1992.
  28. KP94] Wayne Kelly and William Pugh. Selecting a ne mappings based on performance estimations. Parallel Processing Letters, 4(3):205{220, September 1994.
  29. Jingke Li and Marina Chen. The data alignment phase in compiling programs for distributed memory machines. Journal of Parallel and Distributed Computing, 13:213{221, 1991.
  30. Dror E. Maydan, Saman P. Amarasinghe, and Monica S. Lam. Array data ow analysis and its use in array privatization. In Proc. of ACM Conf. on Principles of Programming Languages, pages 2{15, January 1993.
  31. Michel Minoux. Programmation Math ematique, th eorie et algorithmes. Dunod, Paris, 1983.
  32. William Pugh and David Wonnacott. An evaluation of exact methods for anal- ysis of value-based array data dependences. In Sixth Annual Workshop on Pro- gramming Languages and Compilers for Parallel Computing, pages 546{566. Springer-Verlag LNCS 768, August 1993.
  33. P. Quinton and V. Van Dongen. The mapping of linear recurrence equations on regular arrays. The Journal of VLSI Signal Processing, 1:95{113, 1989.
  34. Qui87] Patrice Quinton. The systematic design of systolic arrays. In F. Fogelman, Y. Robert, and M. Tschuente, editors, Automata networks in Computer Science, pages 229{260. Manchester University Press, December 1987.
  35. Tanguy Risset. Parall elisation Automatique: du mod ele systolique au a la com- pilation des nids de boucles. PhD thesis, ENS Lyon, February 1994.
  36. Mourad Raji-Werth and P. Feautrier. On parallel program generation for mas- sively parallel architectures. In M. Durand and F. El Dabaghi, editors, High Performance Computing II. North-Holland, October 1991.
  37. Mourad Raji-Werth and Paul Feautrier. On factors limiting the generation of ef- cient compiler-parallelized programs. In Marc Moonen and Francky Catthoor, editors, Algorithms and Parallel VLSI Architectures, III, pages 331{340, Ams- terdam, 1995. Elsevier.
  38. Herv e Le Verge, Doran K. Wilde, and Vincent Van Dongen. La synth ese de nids de boucles avec la biblioth eque poly edrique. In Luc Boug e, editor, RenPar'6. ENS Lyon, June 1994.
  39. M. Wolf and Monica S. Lam. A loop transformation theory and an algorithm to maximize parallelism. IEEE Trans. on Parallel and Distributed Systems, 2(4):452{471, October 1991.
  40. J. Xue. Automatic non-unimodular transformations of loop nests. Parallel Computing, 20(5):711{728, May 1994.
  41. H. P. Zima, H. J. Bast, and M. Gerndt. SUPERB : A tool for semi-automatic MIMD/SIMD parallelization. Parallel Computing, 6:1{18, 1988.

Related papers

Parallel architecture and compilation techniques
Cosimo Prete

ACM SIGARCH Computer Architecture News

In this issue, we present a selection of papers from several workshops held in September 2001 in Barcelona, Spain. The workshops were hosted within the PACT (Parallel Architecture and Compilation Techniques) Conference [1], [2]. The advances in technology arc improving the processing power and the computing speed of systems. As addressed by keynote speakers, the time has never been so propitious to explore the potentials of compilers on the architecture and vice versa, due to the strong demand for advances in the interaction of these two areas. The increasing interest is also shown by the record number of attendees this year. This is also due to the , high-quality workshops focused on hot topics in Compiler and Computer Architecture research areas. This year 2001, five different workshops covered hot research themes: the Compilers and Operating Systems for Low Power (COLP) workshop, the European Workshop on OpenMP (EWOMP), the MEmory DEcoupling Architecture workshop (MEDEA), the Ubiquitous Computing and Communication (UCC) workshop, and the Workshop on Binary Translation (WBT). For copyright reasons, we cannot include

View PDFchevron_right
A Simple Parallelising Compiler
Andrzej Goscinski

The process of writing parallel programs is not as simple or common as traditional sequential programming. A programmer must have an in-depth knowledge of the program at hand, as well as the resources available when the program is executed. By designing a compiler that can automatically parallelise sequentially written programs, is obviously of great benefit. The current efforts concentrate mainly on fine grained parallelism. With the move towards using clusters of workstations as platforms for parallel processing, coarse grained parallelism is becoming a very important research issue. This paper reports on the development of a simple parallelising compiler exploiting course grained parallelism in sequential programs. In particular, the use of three structured algorithms used to divide the parallelisation process into manageable phases is presented.

View PDFchevron_right
Intermediate Code Generation for Portable Scalable, Compilers. Architecture Independent Data Parallelism: The Preliminaries
Lenore Mullin

1993

This paper introduces the goals of the Portable, Scalable, Architecture Independent (PSI) Compiler Project for Data Parallel Languages at the University of Missouri-Rolla. A goal of this project is to produce a subcompiler for data parallel scientific programming languages such as HPF(High Performance Fortran) where the input grammar is translated to a three-address code intermediate language. Ultimately we plan to integrate our work into automated synthesis systems for scientific programming because we feel that it should not be necessary to learn complicated programming techniques to use multiprocessor computers or networks of computers effectively. This paper shows how to compile a data parallel language to an arbitrary multiprocessor topology or network of CPUs given the number of processors, length of vector registers, and total number of components in an array assuming a message passing, distributed memory paradigm of send and receive. We emphasize that this paradigm is not on...

View PDFchevron_right
Compile-time partitioning and scheduling of parallel programs
John Hennessy

Proceedings of the 1986 SIGPLAN symposium on Compiler construction, 1986

Partitioning and scheduling techniques are necessary to implement parallel languages on multiprocessors. Multiprocessor performance is maximized when parallelism between tasks is optimally traded off with communication and synchronization overhead. We present compile-time partitioning and scheduling techniques to achieve this trade-Off.

View PDFchevron_right
Compiler transformations to generate reentrant C programs to assist software parallelization
Adam Francis Smith

2009

As we move through the multi-core era into the many-core era it becomes obvious that thread-based programming is here to stay. This trend in the development of general purpose hardware is augmented by the fact that while writing sequential programs is considered a non-trivial task, writing parallel applications to take advantage of the advances in the number of cores in a processor severely complicates the process. Writing parallel applications requires programs and functions to be reentrant. Therefore, we cannot use globals and statics. However, globals and statics are useful in certain contexts. Globals allow an easy programming mechanism to share data between several functions. Statics provide the only mechanism of data hiding in C for variables that are global in scope. Writing parallel programs restricts users from using globals and statics in their programs, as doing so would make the program non-reentrant. Moreover, there is a large existing legacy code base of sequential programs that are non-reentrant, since they rely on statics and globals. Several of these sequential programs display significant amounts of data parallelism by operating on independent chunks of input data, and therefore can be easily converted into parallel versions to exploit multi-core processors. Indeed, several such programs have been manually converted into parallel versions. However, manually eliminating all globals and statics to make the program reentrant is tedious, time-consuming, and error-prone. In this paper we describe a system to provide a semi-automated mechanism for users to still be able to use statics and globals in their programs, and to let the compiler automatically convert them into their semantically-equivalent reentrant versions enabling their parallelization later.

View PDFchevron_right

Related topics

  • Automatic Parallelization
  • Parallelizing Compilers

    • Cited by

    Modeling Time(s)
    Frederic Mallet

    2007

    An understandable concrete syntax and a comprehensible abstract syntax are two central aspects of defining a modeling language. Both representations of a language significantly overlap in their structure and also information, but may also differ in parts of the information. To avoid discrepancies and problems while handling the language, concrete and abstract syntax need to be consistently defined. This will become an even bigger problem, when domain specific languages will become used to a larger extent. In this paper we present an extended grammar format that avoids redundancy between concrete and abstract syntax by allowing an integrated definition of both for textual modeling languages. For an amendment of the usability of the abstract syntax it furthermore integrates meta-modeling concepts like associations and inheritance into a well-understood grammar-based approach. This forms a sound foundation for an extensible grammar and therefore language definition.

    View PDFchevron_right
    Data and memory optimization techniques for embedded systems
    Erik Brockmeyer

    ACM Transactions on Design Automation of Electronic Systems, 2001

    We present a survey of the state-of-the-art techniques used in performing data and memory-related optimizations in embedded systems. The optimizations are targeted directly or indirectly at the memory subsystem, and impact one or more out of three important cost metrics: area, performance, and power dissipation of the resulting implementation. We first examine architecture-independent optimizations in the form of code transoformations. We next cover a broad spectrum of optimization techniques that address memory architectures at varying levels of granularity, ranging from register files to on-chip memory, data caches, and dynamic memory (DRAM). We end with memory addressing related issues.

    View PDFchevron_right
    580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved