Machine CM-2 Research Articles

Development of automatic regrinding program for PC-based tool grinding machine

The main goal of this development is the PC-based controller setup on the CM2 tool grinding machine. Concerned cutting parameters with know-hows can be transferred to a useful program and then embedded in the PC-based controller. By automatic positioning of probes the automatic procedure can be achieved. An automatic and intelligent PC-based grinding machine for regrinding has been developed in this investigation. With the new machine and automatic procedure, regrinding process will be distinctly simplified. Based on a manual grinding machine CM2, a PC-based controller is integrated in the machine. The know-hows of the regrinding technology have been integrated with a self-developed program. For automatic dimensional inspection a contact probe is utilized as inspection sensor. By the programming and automatic dimensional inspection, the functions of tool regrinding machine have been enhanced greatly.

PERFORMANCE EVALUATION OF PRACTICAL PARALLEL COMPUTER MODEL LogPQ

The present super computer will be replaced by a massively parallel computer consisting of a large number of processing elements which satisfy the continuous increasing depend for computing power. Practical parallel computing model has been expected to develop efficient parallel algorithms on massively parallel computers. Thus, we have presented a practical parallel computation model LogPQ by taking account of communication queues into the LogP model. This paper addresses the performance of a parallel matrix multiplication algorithm using LogPQ and LogP models. The parallel algorithm is implemented on Cray T3E and the parallel performances are compared with on the old machine CM-5. This shows that the communication network of T3E has superior buffering behavior than CM-5, in which we don't need to prepare extra buffering on T3E. Although, a little effect remains for both of the send and receive bufferings. On the other hand, the effect of message size remains, which shows the necessity of the overhead and gap proportional to the message size.

General Algorithm for Improved Lattice Actions on Parallel Computing Architectures

Quantum field theories underlie all of our understanding of the fundamental forces of nature. There are relatively few first-principles approaches to the study of quantum field theories (such as quantum chromodynamics [QCD] relevant to the strong interaction) apart from the perturbative (i.e., weak-coupling) regime. Currently, the most commonly used method is the Monte Carlo method on a hypercubic space–time lattice. These methods consume enormous computing power for large lattices, and it is essential that increasingly efficient algorithms be developed to perform standard tasks in these lattice calculations. Here we present a general algorithm for QCD that allows one to put any planar improved gluonic lattice action onto a parallel computing architecture. High performance masks for specific actions (including nonplanar actions) are also presented. These algorithms have been successfully employed by us in a variety of lattice QCD calculations using improved lattice actions on a 128 node Thinking Machines CM-5.

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.

A neural network approach for a robot task sequencing problem

This paper presents a neural network approach with successful implementation for the robot task-sequencing problem. The problem addresses the sequencing of tasks comprising loading and unloading of parts into and from the machines by a material-handling robot. The performance criterion is to minimize a weighted objective of the total robot travel time for a set of tasks and the tardiness of the tasks being sequenced. A three-phased parallel implementation of the neural network algorithm on Thinking Machine's CM-5 parallel computer is also presented which resulted in a dramatic increase in the speed of finding solutions. To evaluate the performance of the neural network approach, a branch-and-bound method and a heuristic procedure have been developed for the problem. The neural network method is shown to give good results and is especially useful for solving large problems on a parallel-computing platform.

The implementation and performance evaluation of N-body gravitational simulation algorithm on high-performance computers

Gravity determines the dynamical evaluation of many astrophysical systems. Each of these systems can be described as N gravitationally interacting particles. Solutions of the resulting N-body problem by direct simulation entails the calculation of O( N 2) forces at each time step. To increase the number of particles that can be simulated, approximate algorithms have been developed and implemented in so-called tree codes. In these algorithms the particles are stored into a spatial hierarchy that forms a tree data structure. For a fixed level of accuracy the complexity of this algorithm is O( Nlog( N)). In this paper, a “manager–worker” model for a parallel implementation of hierarchical N-body algorithm is introduced. We describe a load-balanced, efficient algorithm for solving the Astrophysics simulation of N-body problem using tree-based data structures and massively parallel computing architectures. This algorithm, based on the Barnes–Hut method, first assembles a tree data structure that represents the distribution of bodies, or particles, at all length-scales. An adaptive load balancing technique is used to assign bodies to processors as well as to insure that processors are assigned equal amounts of work. A number of performance measurements were carried out in order to reveal the behavior of the N-body application with respect to a partitioning technique and load imbalance overhead. We also show that, with using the introduced manager–worker model and the cost zones domain decomposition technique, the algorithm is load balanced and that the majority of the time of the algorithm is spent in performing on-processor functions and not in inter-processor communications. We have conducted our study on several high-performance MIMD supercomputer machines such as the 256-processor Cray T3D and the 64-processor Intel Paragon at NASA/JPL and on the 32-processor Thinking Machines CM-5 at UMC.

Random test problems and parallel methods for quadratic programs and quadratic stochastic programs*

This paper proposes a data parallel procedure for randomly generating test problems for two-stage quadratic stochastic programming. Multiple quadratic programs in the second stage are randomly generated in parallel. A solution of the quadratic stochastic program is determined by multiple symmetric linear complementarity problems. The procedure allows the user to specify the size of the problem, the condition numbers of the Hessian matrices of the objective functions and the structure of the feasible regions in the first and the second stages. These test problems are used to evaluate three parallel algorithms for multiple quadratic programs and a parallel inexact Newton method for quadratic stochastic programming. Numerical experiments on a Thinking Machine CM-5, Silicon Graphics Power Challenge, and DEC Alpha Server are reported

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.

Ace

Customizing the protocols that manage accesses to different data structures within an application can improve the performance of software shared-memory programs substantially. Existing systems for using customizable protocols are hard to use directly because the mechanisms they provide for manipulating protocols are low-level ones. This article is an in-depth study of the issues involved in providing language support for application-specific protocols. We describe the design and implementation of a new language for parallel programming, Ace, that integrates support for customizable protocols with minimal extensions to C. Ace applications are developed using a shared-memory model with a default sequentially consistent protocol. Performance can then be optimized, with minor modifications to the application, by experimenting with different protocol libraries. The design of Ace was driven by a detailed study of the use of customizable protocols. We delineate the issues that arise when programming with customizable protocols and present novel abstractions that allow for their easy use. We describe the design and implementation of a runtime system and compiler for Ace nd discuss compiler optimizations that improve the performance of such software shared-memory systems. We study the communication patterns of a set of benchmark applications and consider the use of customizable protocols to optimize their performance. We evaluate the performance of our system through experiments on a Thinking Machine CM-5 and a Cray T3E. We also present measurements that demonstrate that Ace has good performance compared to that of a modern distributed shared-memory system.

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.

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.

A new deterministic parallel sorting algorithm with an experimental evaluation

We introduce a new deterministic parallel sorting algorithm for distributed memory machines based on the regular sampling approach. The algorithm uses only two rounds of regular all-to-all personalized communication in a scheme that yields very good load balancing with virtually no overhead. Moreover, unlike previous variations, our algorithm efficiently handles the presence of duplicate values without the overhead of tagging each element with a unique identifier. This algorithm was implemented in SPLIT-C and run on a variety of platforms, including the Thinking Machines CM-5, the IBM SP-2-WN, and the Cray Research T3D. We ran our code using widely different benchmarks to examine the dependence of our algorithm on the input distribution. Our experimental results illustrate the efficiency and scalability of our algorithm across different platforms. In fact, the performance compares closely to that of our random sample sort algorithm, which seems to outperform all similar algorithms known to the authors on these platforms. Together, their performance is nearly invariant over the set of input distributions, unlike previous efficient algorithms. However, unlike our randomized sorting algorithm, the performance and memory requirements of our regular sorting algorithm can be deterministically guaranteed.

A quantitative comparison of parallel computation models

In recent years, a large number of parallel computation models have been proposed to replace the PRAM as the parallel computation model presented to the algorithm designer. Although mostly the theoretical justifications for these models are sound, and many algorithmic results where obtained through these models, little experimentation has been conducted to validate the effectiveness of these models for developing cost-effective algorithms and applications on existing hardware platforms. In this article a first attempt is made to perform a detailed experimental account on the preciseness of these models. The achieve this, three models (BSP, E-BSP, and BPRAM) were selected and validated on five parallel platforms (Cray T3E, Thinking Machines CM-5, Intel Paragon, MasPar MP-1, and Parsytec GCel). The work described in this article consists of three parts. First, the predictive capabilities of the models are investigated. Unlike previous experimental work, which mostly demonstrated a close match between the measuredd and predicted execution times, this article shows that there are several situations in which the models do not precisely predict the actual runtime behavior of an algorithm implementation. Second, a comparison between the models is provided in order to determine the model that induces that most efficient algorithms. Lastly, the performance achieved by the model-derived algorithms is compared with the performace attained by machine-specific algorithms in order to examine the effectiveness of deriving fast algorithms through the formalisms of the models.

A Randomized Parallel Sorting Algorithm with an Experimental Study

Previous schemes for sorting on general-purpose parallel machines have had to choose between poor load balancing and irregular communication or multiple rounds of all-to-all personalized communication. In this paper, we introduce a novel variation on sample sort which uses only two rounds of regular all-to-all personalized communication in a scheme that yields very good load balancing with virtually no overhead. Moreover, unlike previous variations, our algorithm efficiently handles the presence of duplicate values without the overhead of tagging each element with a unique identifier. This algorithm was implemented in Split-C and run on a variety of platforms, including the Thinking Machines CM-5, the IBM SP-2, and the Cray Research T3D. We ran our code using widely different benchmarks to examine the dependence of our algorithm on the input distribution. Our experimental results illustrate the efficiency and scalability of our algorithm across different platforms. In fact, it seems to outperform all similar algorithms known to the authors on these platforms, and its performance is invariant over the set of input distributions unlike previous efficient algorithms. Our results also compare favorably with those reported for the simpler ranking problem posed by the NAS Integer Sorting (IS) Benchmark.

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.

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.