Results 1 
6 of
6
A Practical Comparison of NBody Algorithms
 In Parallel Algorithms, Series in Discrete Mathematics and Theoretical Computer Science
, 1997
"... This work compares three algorithms for the three dimensional Nbody problem, the BarnesHut algorithm, Greengard's Fast Multipole Method(FMM), and the Parallel Multipole Tree Algorithm (PMTA) to determine which of the algorithms performs best in practice. Although FMM has a better asymptotic r ..."
Abstract

Cited by 33 (2 self)
 Add to MetaCart
This work compares three algorithms for the three dimensional Nbody problem, the BarnesHut algorithm, Greengard's Fast Multipole Method(FMM), and the Parallel Multipole Tree Algorithm (PMTA) to determine which of the algorithms performs best in practice. Although FMM has a better asymptotic running time (O(N ) instead of O(N log N ) for uniform distributions), the algorithm is more complicated and it is not immediately clear above what values of N it performs better in practice. We studied the dependence of accuracy on the variable parameters `, p and ff, and then compared the floating point operation counts of the three algorithms at similar levels of accuracy, for both charged and uncharged random distributions. At a high level of accuracy (RMSerror ß 10 \Gamma5 ), the FMM did the least number of operations for N ? 10 4 , assuming both charged and uncharged distributions of points. At a lower level of accuracy, (RMSerror ß 10 \Gamma3 ) for uncharged distributions, the FMM d...
Implicit and Explicit Parallel Programming in Haskell
, 1993
"... Abstract It has often been suggested that functional languages provide an excellent basis for programming parallel computer systems. This is largely a result of the lack of side effects which makes it possible to evaluate the subexpressions of a given term without any risk of interference. On the ot ..."
Abstract

Cited by 31 (1 self)
 Add to MetaCart
(Show Context)
Abstract It has often been suggested that functional languages provide an excellent basis for programming parallel computer systems. This is largely a result of the lack of side effects which makes it possible to evaluate the subexpressions of a given term without any risk of interference. On the other hand, the lack of sideeffects has also been seen as a weakness of functional languages since it rules out many features of traditional imperative languages such as state, I/O and exceptions. These ideas can be simulated in a functional language but the resulting programs are sometimes unnatural and inefficient. On the bright side, recent work has shown how many of these features can be naturally incorporated into a functional language without compromising efficiency by expressing computations in terms of monads or continuations. Unfortunately, the &quot;singlethreading &quot; implied by these techniques often destroys many opportunities for parallelism. In this paper, we describe a simple extension to the Haskell I/O monad that allows a form of explicit highlevel concurrency. It is a simple matter to incorporate these features in a sequential implementation, and genuine parallelism can be obtained on a parallel machine. In addition, the inclusion of constructs for explicit concurrency enhances the use of Haskell as an executable specification language, since some programs are most naturally described as a composition of parallel processes. \Lambda This research was supported by ARPA via a subcontract to Intermetrics, Inc. 1
A DataParallel Implementation of the Adaptive Fast Multipole Algorithm
, 1993
"... Given an ensemble of n bodies in space whose interaction is governed by a potential function, the Nbody problem is to calculate the force on each body in the ensemble that results from its interaction with all other bodies. An efficient algorithm for this problem is critical in the simulation of mo ..."
Abstract

Cited by 13 (1 self)
 Add to MetaCart
Given an ensemble of n bodies in space whose interaction is governed by a potential function, the Nbody problem is to calculate the force on each body in the ensemble that results from its interaction with all other bodies. An efficient algorithm for this problem is critical in the simulation of molecular dynamics, turbulent fluid flow, intergalactic matter and other problems. The fast multipole algorithm (FMA) developed by Greengard approximates the solution with bounded error in time O(n ). For nonuniform distributions of bodies, an adaptive variation of the algorithm is required to maintain this time complexity. The parallel execution of the FMA poses complex implementation issues in the decomposition of the problem over processors to reduce communication. As a result the 3D Adaptive FMA has, to our knowledge, never been implemented on a scalable parallel computer. This paper describes several variations on the parallel adaptive 3D FMA algorithm that are expressed using the datapa...
Prototyping Parallel Algorithms
 Proceedings of 1992 DAGS/PC Symposium (Dartmount
, 1992
"... A prototyping approach to the implementation of complex parallel algorithms on actual parallel machines is proposed as a way to bridge the gap between theoretical descriptions of parallel algorithms and the implementationlevel details required in current lowlevel parallel programming languages. Pro ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
A prototyping approach to the implementation of complex parallel algorithms on actual parallel machines is proposed as a way to bridge the gap between theoretical descriptions of parallel algorithms and the implementationlevel details required in current lowlevel parallel programming languages. Prototypes are constructed using the widespectrum parallel programming language Proteus and can be executed using a Proteus interpreter. The widespectrum nature of the Proteus language permits key aspects of the implementation to be carefully investigated while other, ancillary, aspects can remain at a convenient level of abstraction. Manual and automatic techniques are under investigation to transform prototypes to lowlevel programming languages for specific machines. In this paper several different Nbody force calculation techniques are used to introduce Proteus, including a preliminary implementation study of the 3dimensional fast multipole algorithm of Greengard, an algorithm of current...
RateControl as a Language Construct for Parallel and Distributed Programming
 IEEE WORKSHOP ON PARALLEL AND DISTRIBUTED REALTIME SYSTEMS (IPPS'93
, 1993
"... This paper introduces a new parallel programming language construct, the rate construct, and examines its utility for a variety of problems. The rate construct specifies constraints on the relative rates of progress of tasks executing in parallel, where progress is the amount of computational work a ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
This paper introduces a new parallel programming language construct, the rate construct, and examines its utility for a variety of problems. The rate construct specifies constraints on the relative rates of progress of tasks executing in parallel, where progress is the amount of computational work as measured by elapsed "ticks" on a local logical clock. By prescribing expected work, the rate construct constrains the allocation of processortime to tasks needed to achieve that work; in a parallel setting this constrains the distribution of tasks to processors and multiprocessing ratios, effected for example by load balancing. We present definitions of rate and underlying realtime primitives as orthogonal extensions to the architectureindependent parallel programming language Proteus. The utility of the rate construct is evidenced for a variety of problems, including weighted parallel search for a goal, adaptive manybody simulation in which rates abstract the requirements for loadbal...
approaches to the classical NBody Problem: the BarnesHut
"... feasible implementation of these algorithms. The execution codes have been written in NESL, a parallel programming language developed at Carnegie Mellon University, and extensive experiments have been run on them. The goal of this project is to compare these three algorithms in terms of both the com ..."
Abstract
 Add to MetaCart
(Show Context)
feasible implementation of these algorithms. The execution codes have been written in NESL, a parallel programming language developed at Carnegie Mellon University, and extensive experiments have been run on them. The goal of this project is to compare these three algorithms in terms of both the computational cost and the accuracy.