Smalltalk-80: the language and its implementation
Smalltalk-80: the language and its implementation
MULTILISP: a language for concurrent symbolic computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Distrbution and Abstract Types in Emerald
IEEE Transactions on Software Engineering - Special issue on distributed systems
Language Support for Loosely Coupled Distributed Programs
IEEE Transactions on Software Engineering - Special issue on distributed systems
ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Type architectures, shared memory, and the corollary of modest potential
Annual review of computer science vol. 1, 1986
Computer
Guided self-scheduling: A practical scheduling scheme for parallel supercomputers
IEEE Transactions on Computers
An overview of the SR language and implementation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Compiling Fortran 8x array features for the connection machine computer system
PPEALS '88 Proceedings of the ACM/SIGPLAN conference on Parallel programming: experience with applications, languages and systems
New ideas in parallel Lisp: language design, implementations, and programming tools
Proceedings of the US/Japan workshop on Parallel Lisp on Parallel Lisp: languages and systems
Proceedings of the US/Japan workshop on Parallel Lisp on Parallel Lisp: languages and systems
Architectural adaptability in parallel programming
Architectural adaptability in parallel programming
Parallel programming: a new approach
Parallel programming: a new approach
Fortran 90 explained
Performance debugging using parallel performance predicates
PADD '93 Proceedings of the 1993 ACM/ONR workshop on Parallel and distributed debugging
The advantages of multiple parallelizations in combinatorial search
Journal of Parallel and Distributed Computing - Special issue on data parallel algorithms and programming
Connection Machine Lisp: fine-grained parallel symbolic processing
LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
An Algorithm for Subgraph Isomorphism
Journal of the ACM (JACM)
ACM Transactions on Programming Languages and Systems (TOPLAS)
An APL Compiler for a Vector Processor
ACM Transactions on Programming Languages and Systems (TOPLAS)
Time, clocks, and the ordering of events in a distributed system
Communications of the ACM
Communications of the ACM
POPL '86 Proceedings of the 13th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
The Paralation Model: Architecture-Independent Parallel Programming
The Paralation Model: Architecture-Independent Parallel Programming
Abstraction Mechanisms and Language Design
Abstraction Mechanisms and Language Design
IEEE Software
Program Structuring for Effective Parallel Portability
IEEE Transactions on Parallel and Distributed Systems
Par: an approach to architecture-independent parallel programming
Par: an approach to architecture-independent parallel programming
Abstractions for effectively portable shared memory parallel programs
Abstractions for effectively portable shared memory parallel programs
Algorithm + strategy = parallelism
Journal of Functional Programming
Hi-index | 0.03 |
Parallel programming involves finding the potential parallelism in an application and mapping it to the architecture at hand. Since a typical application has more potential parallelism than any single architecture can exploit effectively, programmers usually limit their focus to the parallelism that the available control constructs express easily and that the given architecture exploits efficiently. This approach produces programs that exhibit much less parallelism that exists in the application, and whose performance depends critically on the underlying hardware and software.We argue for an alternative approach based on control abstraction. Control abstraction is the process by which programmers define new control constructs, specifying constraints on statement ordering separately from an implementation of that ordering. With control abstraction programmers can define and use a rich variety of control constructs to represent an algorithm's potential parallelism.Since control abstraction separates the definition of a construct from its implementation, a construct may have several different implementations, each exploiting a different subset of the parallelism admitted by the construct. By selecting an implementation for each control construct using annotations, a programmer can vary the parallelism in a program to best exploit the underlying hardware without otherwise changing the source code. This approach produces programs that exhibit most of the potential parallelism in an algorithm, and whose performance can be tuned simply by choosing among the various implementations for the control constructs in use.