2,000 research outputs found
Using a functional language and graph reduction to program multiprocessor machines or functional control of imperative programs
Journal ArticleThis paper describes an effective means for programming shared memory multiprocessors whereby a set of sequential activities are linked together for execution in parallel. The glue for this linkage is provided by a functional language implemented via graph reduction and demand evaluation. The full power of functional programming is used to obtain succinct, high level specifications of parallel computations. The imperative procedures that constitute the sequential activities facilitate efficient utilization of individual processing elements, while the mechanisms inherent in graph reduction synchronize and schedule these activities. The main contributions of this paper are: 1) an evaluation of the performance implications of parallel graph reduction; 2) a demonstration that the mechanisms of graph reduction can obtain multiprocessor performance uniformly surpassing the best uni-processor implementation of sequential algorithms running on a single node of the same machine, and 3) an illustration of our method used to program a real world fluid flow simulation problem
A standard for a graph representation for functional programs
The data structures used in the authors' functional language graph reduction implementations are described, together with a standard notation for representing the graphs in a textual format. The graphs employed are compatible with FLIC and with the functional languages in use at Birmingham and Warwick. The textual format is designed to be transmittable easily across networks
An abstract machine for parallel graph reduction
technical reportAn abstract machine suitable for parallel graph reduction on a shared memory multiprocessor is described. Parallel programming is plagued with subtle race conditions resulting in deadlock or fatal system errors. Due to the nondeterministic nature of program execution the utilization of resources may vary from one run to another. The abstract machine has been designed for the efficient execution of normal order functional languages. The instructions proposed related to parallel activity are sensitive to load conditions and the current utilization of resources on the machine. The novel aspect of the architecture is the very simple set of instructions needed to control the complexities of parallel execution. This is an important step towards building a compiler for multiprocessor machines and to further language research in this area. Sample test programs hand coded in this instruction set show good performance on our 18 node BBN Butterfly as compared to a VAX 8600
An abstract machine for parallel graph reduction
technical reportAn abstract machine for parallel graph reduction on a shared memory multiprocessor is described. This is intended primarily for normal order (lazy) evaluation of functional programs. It is absolutely essential in such a design to adapt an efficient sequential model since during execution under limited resources available, performance will be reduced in the limit to that of the sequential engine. Parallel evaluation of normal order functional languages performed naively can result in poor overall performance despite the availability of sufficient processing elements and parallelism in the application. Needless context switching, task migration and continuation building may occur when a sequential thread of control would have sufficed. Furthermore, the compiler using static information cannot be fully aware of the availability of resources and their optimal utilization at any moment in run time. Indeed this may vary between runs which further aggravates the job of the compiler writer in generating optimal and compact code for programs. The benefits derived from this model are: 1) it is based on the G-machine so that execution under limited resources will default to a performance close to that of the G-machine; 2) the additional instructions needed to control the complexities of parallel evaluation are extremely simple, almost trivializing the job of the compiler writer; 3) attempts are made where possible to avoid context switching and task migration by retaining a sequential thread of control (made more clear in the paper), and 4) the method has demonstrated good overall performance on a shared memory multiprocessor
Independent AND-parallel implementation of narrowing
We present a parallel graph narrowing machine, which is
used to implement a functional logic language on a shared memory multiprocessor. It is an extensión of an abstract machine for a purely functional language. The result is a programmed graph reduction machine which integrates the mechanisms of unification, backtracking, and independent
and-parallelism. In the machine, the subexpressions of an expression can run in parallel. In the case of backtracking, the structure of an expression is used to avoid the reevaluation of subexpressions as far as possible. Deterministic computations are detected. Their results are maintained and need not be reevaluated after backtracking
Isospectral Graph Reductions and Improved Estimates of Matrices' Spectra
Via the process of isospectral graph reduction the adjacency matrix of a
graph can be reduced to a smaller matrix while its spectrum is preserved up to
some known set. It is then possible to estimate the spectrum of the original
matrix by considering Gershgorin-type estimates associated with the reduced
matrix. The main result of this paper is that eigenvalue estimates associated
with Gershgorin, Brauer, Brualdi, and Varga improve as the matrix size is
reduced. Moreover, given that such estimates improve with each successive
reduction, it is also possible to estimate the eigenvalues of a matrix with
increasing accuracy by repeated use of this process.Comment: 32 page
Dynamics of heuristic optimization algorithms on random graphs
In this paper, the dynamics of heuristic algorithms for constructing small
vertex covers (or independent sets) of finite-connectivity random graphs is
analysed. In every algorithmic step, a vertex is chosen with respect to its
vertex degree. This vertex, and some environment of it, is covered and removed
from the graph. This graph reduction process can be described as a Markovian
dynamics in the space of random graphs of arbitrary degree distribution. We
discuss some solvable cases, including algorithms already analysed using
different techniques, and develop approximation schemes for more complicated
cases. The approximations are corroborated by numerical simulations.Comment: 19 pages, 3 figures, version to app. in EPJ
- …