Abstract. We present a complete automatic coarse-grained parallelization tool allowing the execution of sequential programs on distributed memory parallel computers. It is based on the PlusPyr parameterized task graph builder and a new dynamic scheduling algorithm whose computational complexity

This paper presents Jade, a language which allows a programmer to easily express dynamic coarse-grain parallelism. Starting with a sequential program, a programmer augments those sections of code to be parallelized with abstract data usage information. The compiler and run-time system use

We present a coarse grained parallel algorithm for planarity testing and planar embedding. The algorithm

Abstract: A coarse-grained parallel (distributed) computing application using the ISIS toolkit is described. The method should be applicable to any serial program suitable for coarse-grain parallelization. Criteria for parallelizing existing programs, factors which affect the speed of parallel

As the demand for multimedia applications increases, the performance of algorithms such as MPEG-2 video compression on general-purpose microprocessors is becoming more important. In this paper, we propose a number of coarse-grained parallel implementations of MPEG-2 decoding and encoding. We

We consider the problem of optimizing select-project-join relational queries for minimum response time on parallel machines. The design of the optimizer is based on three ideas: (1) the concept and quantification of degree of coarse grain parallelism for an execution tree, (2) the design of a

This paper improves on op. cit. in several ways: (1) It studies the more general next element search problem which also solves, e.g., planar point location. (2) The algorithms require only O((n#p) log n) local computation instead of O(log p*(n#p) log n). (3) The algorithms require only O((n#p) log p) local memory instead of O((n#p) log n)

Abstract. Simulating spatial dynamics in physics by Cellular Automata (CA) requires very large computation power, and, hence, CA simulation algorithms are to be implemented on multiprocessors. The preconceived opinion, that no much effort is required to obtain highly efficient coarse grained

Abstract—We propose the use of a novel architecture, called the Multi-Level Computing Architecture (MLCA) to efficiently exploit coarse-grain parallelism on FPGAs. The central com-ponent of the MLCA is its Control Processor (CP), which is analogous to an out-of-order scheduling unit of a

We observe that for n=p p, which is usually the case in practice, there exists a very simple, deterministic, optimal coarse grained parallel integer sorting p -relations and 18 p-relations), O(n=p) memory per processor and O(n=p) local computation. Experimental data indicates that the algorithm