Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Bird-Meertens Background
Conclusions
References
All Topics
Computer Science
Distributed Systems

A cost calculus for parallel functional programming

Profile image of Wentong CaiWentong Cai

1995, Journal of Parallel and Distributed Computing

Abstract

Building a cost calculus for a parallel program development environment is di cult because of the many degrees of freedom available in parallel implementations, and because of di culties with compositionality. We present a strategy for building cost calculi for skeleton-based programming languages which can be used for derivational software development and which deals in a pragmatic way with the di culties of composition. The approach is illustrated for the Bird-Meertens theory of lists, a parallel functional language with an associated equational transformation system.

Related papers

Parallel functional programming: An introduction
Kevin Hammond

1994

Parallel functional programming has a relatively long history. Burge was one of the first to suggest the basic technique of evaluating function arguments in parallel, with the possibility of functions absorbing unevaluated arguments and perhaps also exploiting speculative evaluation 22]. Berkling also considered the application of functional languages to parallel processing 17].

View PDFchevron_right
Comparing parallel functional languages: Programming and performance
Kevin Hammond

2003

This paper presents a practical evaluation and comparison of three state-of-the-art parallel functional languages. The evaluation is based on implementations of three typical symbolic computation programs, with performance measured on a Beowulf-class parallel architecture.

View PDFchevron_right
On deriving data parallel code from a functional program
Patrice Quinton

Proceedings of 9th International Parallel Processing Symposium, 1995

We discuss a translation methodology for transforming a high level algorithmic speci cation written in Alpha to an imperative data parallel language. We informally introduce the Alpha language with the aid of an example and explain how it is adapted for doing static analysis and transformation. An Alpha program can be naively compiled 11] using applicative caching. Our compilation method makes incremental transformations on the abstract syntax tree of an Alpha program in order to make e ciency and performance improvements over the naive code and optimize it for a given architecture. The compilation steps described include scheduling, alignment, partitioning, allocation, loop nest generation, and code generation and they are illustrated with an example.

View PDFchevron_right
A metacircular data-parallel functional language
John Mullins

We describe and verify a data-parallel semantics for the simply-typed -calculus and obtain a semantic function expressible in its object language. The explicitly distributed semantics oers the possibility of formally optimising the interpreter's data partitioning and communication features.

View PDFchevron_right
Parallel Programming with Skeletons
Joel Falcou

Computing in Science and Engineering, 2009

Parallel programming is bound to become the main concern of software developers in the coming decades. Various models aim to solve this tension, trading efficiency for abstraction or vice versa, but how about getting both?

View PDFchevron_right
Concrete data structures and functional parallel programming
John Mullins

Theoretical Computer Science, 2001

A framework is presented for designing parallel programming languages whose semantics is functional and where communications are explicit. To this end, Brookes and Geva's generalized concrete data structures are specialized with a notion of explicit data layout to yield a CCC of distributed structures called arrays. Arrays' symmetric replicated structures, suggested by the data-parallel SPMD paradigm, are found to be incompatible with sum types. We then outline a functional language with explicitly distributed (monomorphic) concrete types, including higher-order, sum and recursive ones. In this language, programs can be as large as the network and can observe communication events in other programs. Such exibility is missing from current data-parallel languages and amounts to a fusion with their so-called annotations, directives or meta-languages.

View PDFchevron_right
Engineering large parallel functional programs
Hans-Wolfgang Loidl

Lecture Notes in Computer Science, 1998

The design and implementation of useful programming languages, whether sequential or parallel, should be driven by large, realistic applications. In constructing several medium-and large-scale programs in Glasgow Parallel Haskell, GpH, a parallel extension of Haskell, the group at Glasgow has investigated several important engineering issues:

View PDFchevron_right
FACILE: A symmetric integration of concurrent and functional programming
Alessandro Giacalone

Lecture Notes in Computer Science, 1989

FACILE is a language which symmetrically integrates concurrent and functional programming. It is a typed and statically scoped language. The language supports both function and process abstractions.

View PDFchevron_right
Ocamlp3l a functional parallel programming system
Susanna Pelagatti

1998

Writing parallel programs is not easy, and debugging them is usually a nightmare. To cope with these difficulties, a structured approach to parallel programsusing skeletons and template based compiler techniques has been developed overthe past years by several researchers, including the P3L group in Pisa. This approach is based on the use of a set of primitives that are just functionalsimplemented via templates exploiting the underlying parallelism, so it is naturalto ask whether marrying a real functional language like Ocaml ...

View PDFchevron_right
Paradigm-oriented' Design Of ParallelIterative Programs Using FunctionalLanguages
Fethi Rabhi

WIT Transactions on Information and Communication Technologies, 1970

Functional languages offer a high degree of abstraction to the programmer while containing a great deal of implicit parallelism. This parallelism could be efficiently exploited if parallel algorithmic structures were used in the design of algorithms. A structure captures the behaviour of a parallel programming paradigm and acts as a template in the design of an algorithm. This paper addresses the issue of defining a structure for static iterative transformation (SIT) algorithms which are coarse-grained data parallel algorithms with an iterative control structure. The parameters required by the structure are supplied by the programmer using a functional language, forming the problem specification. This specification can then be successively turned into a sequential functional program, then into a parallel program for a graph reduction machine, and finally into a program that maps on a specific parallel architecture.

View PDFchevron_right

References (35)

  1. D.F. Bacon, S.L. Graham, and O.J. Sharp. Compiler transformations for high- performance computing. ACM Computing Surveys, to appear.
  2. F. Bellegarde. Rewriting systems on FP expressions to reduce the number of sequences yielded. Science of Computer Programming, 6:11{34, 1986.
  3. R.S. Bird. A calculus of functions for program derivation. Oxford University Program- ming Research Group Monograph PRG-64, 1987.
  4. R.S. Bird. An introduction to the theory of lists. In M. Broy, editor, Logic of Program- ming and Calculi of Discrete Design, pages 3{42. Springer-Verlag, 1987.
  5. R.S. Bird. Lectures on constructive functional programming. Oxford University Pro- gramming Research Group Monograph PRG-69, 1988.
  6. R.S. Bird. Algebraic identities for program calculation. The Computer Journal, 32(2):122{126, February 1989.
  7. R.S. Bird, J. Gibbons, and G. Jones. Formal derivation of a pattern matching algorithm. Science of Computer Programming, 12:93{104, 1989.
  8. G. Blelloch. Scans as primitive parallel operations. In Proceedings of the International Conference on Parallel Processing, pages 355{362, August 1987.
  9. G.E. Blelloch. Vector Models for Data-Parallel Computing. MIT Press, 1990.
  10. L. Boug e. The data-parallel programming model: A semantic perspective. Technical Report 92{45, Laboratoire de l'Informatique du Parall elisme, Ecole Normale Sup erieure de Lyon, 1992.
  11. W. Cai and D.B. Skillicorn. Calculating recurrences using the Bird-Meertens Formalism. Parallel Processing Letters, submitted February 1994.
  12. S. Chatterjee, G.E. Blelloch, and A.L. Fisher. Size and access interference for data- parallel programs. In ACM SIGPLAN '91 Conference on Programming Language Design and Implementation, pages 130{144, June 1991.
  13. M. Cole. Algorithmic Skeletons: Structured Management of Parallel Computation. Research Monographs in Parallel and Distributed Computing. Pitman, 1989.
  14. M. Danelutto, R. di Meglio, S. Orlando, S. Pelagatti, and M. Vanneschi. A methodology for the development and the support of massively parallel programs. Future Genera- tion Computer Systems, 1992. Also appears as \The P 3 L language: an introduction", Hewlett-Packard Report HPL-PSC-91-29, December 1991.
  15. M. Danelutto, R. di Meglio, S. Pelagatti, and M. Vanneschi. High level language con- structs for massively parallel computing. Technical report, Hewlett Packard Pisa Science Center, HPL-PSC-90-19, 1990.
  16. J. Darlington, A.J. Field, P.G. Harrison, P.H.J. Kelly, Q. Wu, and R.L. While. Par- allel programming using skeleton functions. In PARLE93, Parallel Architectures and Languages Europe, June 1993.
  17. V. Dornic, P. Jouvelot, and D.K. Gi ord. Polymorphic time systems for estimating program complexity. ACM Letters on Programming Languages and Systems, pages 33{45, March 1992.
  18. S. Flynn Hummel and R. Kelly. A rationale for parallel programming with sets. Journal of Programming Languages, 1:187{207, 1993.
  19. D. le M etayer. Mechanical analysis of program complexity. Proceedings of the SIGPLAN '85 Symposium, pages 69{73, July 1985.
  20. C. Lengauer. Loop parallelization in the polytope model. In CONCUR '93, Springer Lecture Notes in Computer Science, 1993.
  21. G. Malcolm. Algebraic Data Types and Program Transformation. PhD thesis, Rijk- suniversiteit Groningen, September 1990.
  22. W.F. McColl. General purpose parallel computing. In A.M. Gibbons and P. Spirakis, editors, Lectures on Parallel Computation, Cambridge International Series on Parallel Computation, pages 337{391. Cambridge University Press, Cambridge, 1993.
  23. K. Mehlhorn and U. Vishkin. Randomized and deterministic simulation of PRAMs by parallel machines with restricted granularity of parallel memories. Acta Informatica, 21:339{374, 1984.
  24. C. Morgan. Programming from Speci cations. Prentice-Hall International, 1990.
  25. A.G. Ranade. Fluent Parallel Computation. PhD thesis, Yale University, 1989.
  26. P. Roe. Parallel Programming Using Functional Languages. PhD thesis, Department of Computer Science, University of Glasgow, February 1991.
  27. P. Roe. Derivation of e cient data parallel programs. Technical report, Queensland University of Technology, December 1993.
  28. D. Sands. Complexity analysis for a higher-order language. Technical report, Depart- ment of Computing, Imperial College, Technical Report 88/14, London, December 1988.
  29. D. Sands. Calculi for Time Analysis of Functional Programs. PhD thesis, Imperial College, London, September 1990.
  30. D.B. Skillicorn. Architecture-independent parallel computation. IEEE Computer, 23(12):38{51, December 1990.
  31. D.B. Skillicorn. Models for practical parallel computation. International Journal of Parallel Programming, 20(2):133{158, April 1991. Actually appeared in 1992.
  32. L. Snyder. Type architectures, shared memory and the corollary of modest potential. Annual Review of Computer Science 1986, 1:289{317, 1987.
  33. L.G. Valiant. Optimally universal parallel computers. Phil. Trans. Royal Society Lond. Series A, 326:373{376, 1988.
  34. L.G. Valiant. A bridging model for parallel computation. Communications of the ACM, 33(8):103{111, August 1990.
  35. L.G. Valiant. General purpose parallel architectures. In J. van Leeuwen, editor, Hand- book of Theoretical Computer Science, Vol. A. Elsevier Science Publishers and MIT Press, 1990.

Related papers

Transformational Derivation of (Parallel) Programs Using Skeletons
Eerke Boiten

1993

View PDFchevron_right
A case study in the parallel implementation of functional languages using skeletons
Fethi Rabhi

Lecture Notes in Computer Science, 1994

The use of algorithmic skeletons in parallel functional programming seems to overcome many of the problems functional languages have in their applicability for applications. This paper presents a parallel implementation method for the SIT skeleton which takes into account all the available information about its behaviour in order to produce an e cient implementation on a parallel computer. Graph Reduction Unit Comm Unit Thread Pool Mailbox Send Receive Fig.1. Abstract machine structure

View PDFchevron_right
Functional Languages: Compiler Technology and Parallelism (Dagstuhl Seminar 9213)
Werner Damm

1992

The seminar emphasized four issues: o sta.tic program analysis o extensions for progra.mmer control of pa.ra.llelism o functional+logic languages and constraints o implementa.tion of functiona.l la.ngua.ges There were two formal discussion sessions, which a.ddressed the problems of input/output in functional la.nguages, and the utility of static program analysis. It is gratifying that the first Dagstuhl seminar in this area. (Functional Languages: Optimization for Parallelism) had stimulated many developments which were reported a.t this one. A particular feature of this seminar was the la.rge number of prototypes which were demonstrated a.nd which vividly illustrated the issues raised in discussions and presentations. Static Program Analysis Static program analysis has been thoroughly investigated for optimising sequential implementations, but parallel ones offer new problems. Discovering properties of synchronisation, for example, requires richer domains than those used in the sequential setting, lea.ding to a combinatorial explosion in cost. Current sequential analyses operate at or beyond the limits of today s algorithm technology. The most expensive aspect is computing xpoints, which requires a convergence test am] therefore a decision procedure for equality of abstract values. New work reported here helps reduce the need for convergence tests. and, using the algebraic properties of the operators in the resulting straightline code, partial evaluation ca.n be used to generate very efficient parallel code with a high degree of processor utilization. This is exempli ed by the well-known problem of parallel evaluation of expressions (and, more generally, straight-line code) over a semi-ring. In this context, partial evaluation is evaluation over the induced polynomial semi-ring that can be executed in parallel by tree contraction.

View PDFchevron_right
Skeleton based parallel programming: functional and parallel semantic in a single shot
Marco Aldinucci

Computer Languages, Systems and Structures, vol. 33, iss. 3-4, pp. 179-192, 2007. doi:10.1016/j.cl.2006.07.004 , 2007

Semantics of skeleton-based parallel programming languages comes usually as two distinct items: a functional semantics, modeling the function computed by the skeleton program, and a parallel semantics describing the ways used to exploit parallelism during the execution of the skeleton program. The former is usually expressed using some kind of semantic formalism, while the latter is almost always given in an informal way. Such a separation of functional and parallel semantics seriously impairs the possibility of programmers to use the semantic tools to prove properties of programs. In this work, we show how a formal semantic framework can be set up that handles both functional and parallel aspects of skeleton-based parallel programs. The framework is based on a labeled transition system. We show how different properties related to skeleton programs can be proved using such a system. We use Lithium, a skeleton-based full Java parallel programming environment, as the case study.

View PDFchevron_right
Parallel Functional Programming with Skeletons: the {OCAMLP3L} experiment
Roberto Di Cosmo

1998

Writing parallel programs is not easy, and debugging them is usually a nightmare. To cope with these di culties, a structured approach to parallel programs using skeletons and template based compiler techniques has been developed over the past years by several researchers, including the P3L group in Pisa.

View PDFchevron_right

Related topics

  • Distributed Computing
  • Parallel & Distributed Computing
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved