The behaviour of concurrent and parallel programs can be specified in a functional style. functionalprogramming style has some inherent concurrent features. However, for a higher degree of expressing parallelism ther...
详细信息
The behaviour of concurrent and parallel programs can be specified in a functional style. functionalprogramming style has some inherent concurrent features. However, for a higher degree of expressing parallelism there is a need for new language constructs. In this paper, we introduce Concurrent Clean modules for evaluation strategies in order to control the evaluation degree, the dynamic behaviour, and the parallelism. The usage of the strategies will be illustrated by the parallel elementwise processing method. The implementation of the method in the lazy functionalprogramming language Concurrent Clean operates with a two arguments two values elementwise processable function. In order to obtain abstract type specification for the generalised manipulation of the linear data structures like lists, arrays, and strict arrays, a linear data structure class module is defined. The programming style is skeleton based. Skeletons in functional languages are higher-order functions. The skeleton given in this paper represents a generalisation of the map function. It is triply parameterized: by an elementwise processable function, by type specification, and by the strategy parameter that defines the dynamic behaviour of the program. (C) 2003 Elsevier Ltd. All rights reserved.
This paper presents Haskell#, a parallelfunctional language based on coordination. Haskell# supports lazy stream communication and facilities, at coordination level, to the specification of data parallel programs. Ha...
详细信息
ISBN:
(纸本)9781581134452
This paper presents Haskell#, a parallelfunctional language based on coordination. Haskell# supports lazy stream communication and facilities, at coordination level, to the specification of data parallel programs. Haskell# supports a clean and complete, semantic and syntactic, separation between coordination and computation levels of programming, with several benefits to parallel program engineering. The implementation of some well-known applications in Haskell# is presented, demonstrating its expressiveness, allowing for elegant, simple, and concise specification of any static pattern of parallel, concurrent or distributed computation.
The objective of this work is to present the implementation in the Java language of an abstract machine for distributed execution of functional programs. We show how the Java facilities were used to implement a parall...
详细信息
The objective of this work is to present the implementation in the Java language of an abstract machine for distributed execution of functional programs. We show how the Java facilities were used to implement a parallel functional programming language with a distributed runtime system. functional Languages are usually implemented using an abstract machine to execute programs. These abstract machines are usually graph reduction machines. To mn the functional programs on the Java Virtual Machine we have implemented the G-Machine graph reduction machine in Java. In this text, we first present the implementation of the G-Machine in J ava, and discuss its implementation. Then we show how this implementation was modified to allow distributed execution of functional programs. Finally some benchmarks, possible future works and conclusions are presented. ...
It has been attracting much attention to make use of list homomorphisms in parallelprogramming because they ideally suit the divide-and-conquer parallel paradigm, However, they have been usually treated rather inform...
详细信息
It has been attracting much attention to make use of list homomorphisms in parallelprogramming because they ideally suit the divide-and-conquer parallel paradigm, However, they have been usually treated rather informally and ad hoc in the development of efficient parallel programs. What is worse is that some interesting functions, e.g., the maximum segment sum problem, are basically not list homomorphisms. In this article, we propose a systematic and formal way for the construction of a list homomorphism for a given problem so that an efficient parallel program is derived. We show, with several well-known but nontrivial problems, how a straightforward, and ''obviously'' correct, but quite inefficient solution to the problem can be successfully turned into a semantically equivalent ''almost list homomorphism.'' The derivation is based on two transformations, namely tupling and fusion, which are defined according to the specific recursive structures of list homomorphisms.
暂无评论