Connection Machine CM-2 Research Articles

Recent developments in the evolution of morphologies and controllers for physically simulated creatures.

Karl Sims' work on evolving body shapes and controllers for three-dimensional, physically simulated creatures generated wide interest on its publication in 1994. The purpose of this article is threefold: (a) to highlight a spate of recent work by a number of researchers in replicating, and in some cases extending, Sims' results using standard PCs (Sims' original work was done on a Connection Machine CM-5 parallel computer). In particular, a re-implementation of Sims' work by the authors will be described and discussed; (b) to illustrate how off-the-shelf physics engines can be used in this sort of work, and also to highlight some deficiencies of these engines and pitfalls when using them; and (c) to indicate how these recent studies stand in respect to Sims' original work.

Experiences with parallel N-body simulation

This paper describes our experiences developing high-performance code for astrophysical N-body simulations. Recent N-body methods are based on an adaptive tree structure. The tree must be built and maintained across physically distributed memory; moreover, the communication requirements are irregular and adaptive. Together with the need to balance the computational work-load among processors, these issues pose interesting challenges and tradeoffs for high-performance implementation. Our implementation was guided by the need to keep solutions simple and general. We use a technique for implicitly representing a dynamic global tree across multiple processors which substantially reduces the programming complexity as well as the performance overheads of distributed memory architectures. The contributions include methods to vectorize the computation and minimize communication time which are theoretically and experimentally justified. The code has been tested by varying the number and distribution of bodies on different configurations of the Connection Machine CM-5. The overall performance on instances with 10 million bodies is typically over 48 percent of the peak machine rate, which compares favorably with other approaches.

An Interleaving Transformation for Parallelizing Reductions for Distributed-Memory Parallel Machines

Reduction operations frequently appear in algorithms. Due to their mathematical invariance properties (assuming that round-off errorscan be tolerated), it is reasonable to ignore ordering constraints on the computation of reductions in order to take advantage of the computing power of parallel machines. One obvious and widely-used compilation approach for reductions is syntactic pattern recognition. Either the source language includes explicit reduction operators, or certain specific loops are recognized as equivalent to known reductions. Once such patterns are recognized, hand optimized code for the reductions are incorporated in the target program. The advantage of this approach is simplicity. However, it imposes restrictions on the reduction loops—no data dependence other than that caused by the reduction operation itself is allowed in the reduction loops. In this paper, we present a parallelizing technique, interleaving transformation, for distributed-memory parallel machines. This optimization exploits parallelism embodied in reduction loops through combination of data dependence analysis and region analysis. Data dependence analysis identifies the loop structures and the conditions that can trigger this optimization. Region analysis divides the iteration domain into a sequential region and an order-insensitive region. Parallelism is achieved by distributing the iterations in the order-insensitive region among multiple processors. We use a triangular solver as an example to illustrate the optimization. Experimental results on various distributed-memory parallel machines, including the Connection Machines CM-5, the nCUBE, the IBM SP-2, and a network of Sun Workstations are reported.

A Coarse-Grained Parallel Homotopy for Mechanism Design

Polynomial systems of equations arise frequently in many scientific and engineering applications such as solid modeling, kinematics, and robotics and chemical process de-sign. Locally convergent iterative solution methods may diverge or fail to find all possible solutions to a system of polynomial equations. Recently, homotopy algorithms have been proposed for solving polynomial equations. These methods are globally convergent from any arbitrary starting point, can reliably compute all possible solutions, and are inherently parallel in nature. For problems arising in mechanism design, it is shown in this paper that through a use of m-homogenization and by defining auxiliary equations in addition to the design equations, the number of homotopy paths to be tracked (and the associated computational effort) to obtain all possible solutions can be reduced significantly. Further computation time gains are realized by using the data-parallel nature of these methods, which involved implementing them on Connection Machines CM-2/5. Numerical examples dealing with the synthesis of a slider-crank mechanism for six and eight finitely and multiply separated precision positions are presented.

CRAFT: a framework for F90/HPF compiler optimizations

In this paper, we give an overview of the results of the CRAFT optimising compiler project (Fortran 90/HPF subset compilers). We start by describing the theoretical framework within which we designed program transformations for the optimization of inter- and intra-procedural data motion, as well as the optimizations for parallel loops; we then describe the implementation of the CRAFT compilers for Thinking Machines' CM-2 and CM-5. We report results from experiments on the Connection Machine CM-5, the IBM SP-2 and a network of UltraSparc workstations. The results demonstrate that these optimizations can achieve significant object code performance improvement. Copyright © 1999 John Wiley & Sons, Ltd.

Explicitly restarted Lanczos algorithms in an MPP environment

The Lanczos algorithm is one of the principal methods for the computation of a small part of the eigenspectrum of large, sparse, real symmetric matrices. A single-vector, explicitly restarted variant of the Lanczos method is proposed in this paper. The algorithm finds only one eigenpair at a time using a deflation technique in which the Lanczos factorization for the current eigenpair is generated in the null space of all previously computed eigenvectors. This approach yields a fixed k-step restarting scheme which permits short Lanczos factorizations and almost completely eliminates the reorthogonalization among the Lanczos vectors. The orthogonalization strategy developed falls naturally into the class of selective orthogonalization strategies as classified by Simon. `Reverse communication' software for the implementation of the proposed variant on a Connection Machine CM-200 with 8K processors and on a Cray T3D with 32 processors is discussed. Test results on the CM-200 using examples from the Harwell–Boeing collection of sparse matrices show the method to be very effective when compared with Sorensen's state-of-the-art routine taken from the ARPACK library. The method has fixed, small storage requirements, copes easily with genuinely multiple eigenvalues and is guaranteed to converge to the desired eigenvalues.

Stability of rotating spherical stellar systems

We study the stability of rotating collisionless self-gravitating spherical systems by using high resolution N-body experiments on a Connection Machine CM-5. We added rotation to Ossipkov-Merritt (hereafter OM) anisotropic spherical systems by using two methods. The first method conserves the anisotropy of the distribution function defined in the OM algorithm. The second method distorts the systems in velocity space. We then show that the stability of systems depends both on their anisotropy and on the value of the ratio between the total kinetic energy and the rotational kinetic energy. We also test the relevance of the stability parameters introduced by Perez et al. (1996) for the case of rotating systems.

Unsupervised parallel image classification using Markovian models

This paper deals with the problem of unsupervised classification of images modeled by Markov random fields (MRF). If the model parameters are known then we have various methods to solve the segmentation problem (simulated annealing (SA), iterated conditional modes (ICM), etc). However, when the parameters are unknown, the problem becomes more difficult. One has to estimate the hidden label field parameters only from the observed image. Herein, we are interested in parameter estimation methods related to monogrid and hierarchical MRF models. The basic idea is similar to the expectation–maximization (EM) algorithm: we recursively look at the maximum a posteriori (MAP) estimate of the label field given the estimated parameters, then we look at the maximum likelihood (ML) estimate of the parameters given a tentative labeling obtained at the previous step. The only parameter supposed to be known is the number of classes, all the other parameters are estimated. The proposed algorithms have been implemented on a Connection Machine CM200. Comparative experiments have been performed on both noisy synthetic data and real images.

Data-parallel tomographic reconstruction: A comparison of filtered backprojection and direct Fourier reconstruction

We consider the parallelization of two standard 2D reconstruction algorithms, filtered backprojection and direct Fourier reconstruction, using the data-parallel programming style. The algorithms are implemented on a Connection Machine CM-5 with 16 processors and a peak performance of 2 Gflop/s.

Cybermap—Visually Navigating the Web

The general problem we address in this paper is the automatic generation of structural overview maps of large collections of unstructured data to aid in the navigation of collections such as the Web and data retrieved from search engines. We present the theoretical foundations of such a generator, CyberMap, as well as the algorithms used for its implementation. We will detail a series of actual prototype implementations of CyberMap in HyperCard on the Macintosh, in C*on the massively parallel Connection Machine CM-2, as well as in C and Java for the World Wide Web.

Operator-Splitting Methods for Monotone Affine Variational Inequalities, with a Parallel Application to Optimal Control

This article applies splitting techniques developed for set-valued maximal monotone operators to monotone affine variational inequalities, including, as a special case, the classical linear complementarity problem. We give a unified presentation of several splitting algorithms for monotone operators, and then apply these results to obtain two classes of algorithms for affine variational inequalities. The second class resembles classical matrix splitting, but has a novel “under-relaxation” step, and converges under more general conditions. In particular, the convergence proofs do not require the affine operator to be symmetric. We specialize our matrix-splitting-like method to discrete-time optimal control problems formulated as extended linear-quadratic programs in the manner advocated by Rockafellar and Wets. The result is a highly parallel algorithm, which we implement and test on the Connection Machine CM-5 computer family.

Advanced manufacturing of large-scale composite structures: process modeling, manufacturing simulations and massively parallel computing platforms

Newly emerging composite manufacturing processes, where there exist only limited industrial experience, demonstrate a definite need for process simulations to reduce the time and cost associated with the product and process developments. The physical and geometric complexity of the net-shape composite structural parts produced by resin transfer molding (RTM) lead to larger computational problem sizes and computational complexity demanding more memory and computational time which can be provided by high-performance and massively parallel computing platforms. The associated computational costs and times for large-scale simulations is a major factor for the effective use of massively parallel computing platforms. However, the limited availability of these massively parallel computing platforms and the demand for their computing resources make it imperative to have improved computational methodologies and algorithms for physical problems for effective use of the massively parallel computing platforms. An effective pure finite element methodology for the process simulation analysis of mold filling in RTM is employed for large-scale process simulation of composite structures and the computational effectiveness of the methodology is demonstrated for large-scale process simulations. The Connection Machine CM-5 is the massively parallel computing platform employed in this study. Issues regarding the implementation and software development of these manufacturing process simulations, behavior of the linear system solution methodologies during large-scale composite manufacturing process simulations, computation and communication loads, performance and scalability are specifically addressed. Demonstrative process simulation applications involving practical large-scale composite structures such as the Comanche helicopter keel beam and an aircraft composite wing box section are also presented.

A parallel programming environment for adaptive p-version finite element analysis

This paper presents a parallel programming environment for solving large-scale problems using adaptive p-version finite element approach. A scalable parallel feedback algorithm based on domain decomposition technique has been developed to incorporate the parallelism in adaptive finite element analysis of large-scale structures. This algorithm is implementable on MIMD type parallel processors, and uses p-extension of the finite element method. Modeling with p-version finite elements needs special considerations of load-balancing, and this has been incorporated in present domain decomposition technique using semi-empirical approach. The Connection Machine's CM-5 system has been used to implement the present system. Most of the previous attempts to parallelize adaptive finite element analysis were confirmed to parallel algorithms for direct or iterative equation solvers, and did not produce satisfactory performance because of small granularity of parallel tasks. Also these efforts were based on h-version of the finite element method, and hence could not exploit some of the special advantages available in p-vision of finite element approach. As the feedback algorithm is based on an iterative scheme, utilizing the domain decomposition technique, it produced good performance, particularly for large-scale structures. It has been tested for a number of regular and irregular two-dimensional problems showing good convergence characteristics.

Intrinsically parallel solution of systems of linear partial differential equations

We give here an intrinsically parallel algorithm, which solves systems of linear partial differential equations. The mathematical foundations of the algorithm rely upon a particular representation of polynomials on a structure called “hypercube”, introduced by Beauzamy-Frot-Millour, and use Bombieri's scalar product. This scalar product also permits a detailed study of the stability of the algorithm. Boundary conditions and compatibility conditions are handled by the algorithm in an intrinsically parallel manner. This algorithm has been implemented on a Connection Machine CM5, at the “Etablissement Technique Central de l'Armement” (Arcueil, France). We give here several numerical examples.

Hyper-systolic parallel computing

We introduce a new class of parallel algorithms for the exact computation of systems with pairwise mutual interactions of n elements, so called n/sup 2/-problems. Hitherto, practical conventional parallelization strategies could achieve a complexity of O(np) with respect to the inter-processor communication, p being the number of processors. Our new approach can reduce the inter-processor communication complexity to a number O(np). In the framework of Additive Number Theory, the determination of the optimal communication pattern can be formulated as h-range minimization problem that can be solved numerically. Based on a complexity model, the scaling behavior of the new algorithm is numerically tested on the connection machine CM5. As a real life example, we have implemented a fast code for globular cluster n-body simulations, a generic n/sup 2/-problem, on the CRAY T3D, with striking success. Our parallel method promises to be useful in various scientific and engineering fields like polymer chain computations, protein folding, signal processing, and, in particular, for parallel level-3 BLAS.

Benchmark kernels as a tool for performance evaluation of MPP‘s

The performance achieved by a parallel architecture over a complete application is determined by the combination of the hardware and software modules. When we talk about hardware we mean node processing power and network parameters, while software entails all from the optimization capabilities of the compiler to the high level programming model. They interact in a non-simple way delivering variable results for different problem sizes and making the task of predicting performance a very difficult one. Performance is predictable once, given an algorithm, you can parameterize it in terms of floating-point operations needed, bandwidth and latency requirements, granularity of the problem itself and few parameters, obviously machine dependent. We attack the issue of predicting performance for a large class of regular synchronous problems on rectangular grids (only 2D in this paper). The aim of the paper is to determine, by means of dedicated small benchmarking kernels, all the machine dependent parameters. These will be used to predict and compare, over a very wide range of data set sizes, the performances of the Connection Machine CM-5, the Cray T3D and the IBM SP2 for a simple but complete application like the Conjugate Gradient solution for the Poisson equation. We show that the parameterization can be done quite accurately for all of the studied platforms, thus predicting, from measurements performed on extremely simple kernels and some algorithmic understanding, the behavior of an MPP over a very wide range of parameters. We argue in favor of adopting this methodology to produce meaningful benchmarks of MPP platforms. © 1998 John Wiley & Sons, Ltd.

Unifying Themes for Selection on Any Network

In this paper we present efficient deterministic and randomized algorithms for selection on any interconnection network when the number of input keys (n) is ≥ the number of processors (p). Our deterministic algorithm runs on any network in timeO(n/plog logp+Tpslogn), whereTpsis the time needed for sortingpkeys usingpprocessors. On the other hand, our randomized algorithm runs in an expected time ofO((n/p+Tpsparse) log logp) on any network, whereTpsparseis the time needed for collecting and sortingp1−ϵsample keys usingpprocessors. (Here ϵ is a constant <1). Application of the above algorithms on the mesh and the hypercube yields better results than known before. We have implemented our randomized algorithm on the Connection Machine CM2. Experimental results obtained are promising. In this paper we also report our implementation details.

Design and Performance of Parallel and Distributed Approximation Algorithms for Maxcut

We develop and experiment with a new parallel algorithm to approximate the maximum weight cut in a weighted undirected graph. Our implementation starts with the recent (serial) algorithm of Goemans and Williamson for this problem. We consider several different versions of this algorithm, varying the interior-point part of the algorithm in order to optimize the parallel efficiency of our method. Our work aims for an efficient, practical formulation of the algorithm with close-to-optimal parallelization. We analyze our parallel algorithm in the LogP model and predict linear speedup for a wide range of the parameters. We have implemented the algorithm using the message passing interface (MPI) and run it on several parallel machines. In particular, we present performance measurements on the IBM SP2, the Connection Machine CM5, and a cluster of workstations. We observe that the measured speedups are predicted well by our analysis in the LogP model. Finally, we test our implementation on several large graphs (up to 13,000 vertices), particularly on large instances of the Ising model.

SVD Computations on the Connection Machine CM-5/CM-5E: Implementation and Accuracy

The singular value decomposition (SVD) plays an essential role in many applications. One technique for obtaining the SVD of a real dense matrix is to first reduce the dense matrix to bidiagonal form and then compute the SVD of the bidiagonal matrix. Guidelines followed to implement this approach efficiently on the Connection Machine CM-5/CM-5E are described. Timing results show that use of the described techniques yields up to 44% of peak performance in the reduction from dense to bidiagonal form. The singular values are achieved by applying the parallel bisection algorithm to the symmetric tridiagonal matrix obtained by doing a perfect-shuffle permutation of the rows and columns of [[0 BT];[B 0]], where B is the bidiagonal matrix. The singular vectors are computed using inverse iteration on the symmetric tridiagonal matrix. SVD experiments done on bidiagonal matrices are presented and illustrate that this approach yields very good performance as well as orthogonal singular vectors even for ill-conditioned matrices as long as the singular values are computed to very high accuracy. The main conclusion is that extra accuracy in the eigenvalue computation very often enhance orthogonality of the eigenvectors computed with inverse iteration to the point where reorthogonalization is not needed. The conclusions presented regarding the SVD's numerical properties are general to the algorithm and not specific to the Connection Machine implementation.

Massively parallel search for linear factors in polynomials with many variables

We give here an effective massively parallel algorithm, searching for all linear factors in a multivariate polynomial with complex coefficients. This algorithm is multirecurrent and needs essentially polynomial manipulation tools such as variable changing, partial derivatives, and root finding of univariate polynomials. It also uses Bombieri's scalar product of polynomials. The parallel message-passing algorithm is implemented on a Connection Machine CM5 and is obtained by a parallelization of the recurrences in the sequential algorithm.