bluuebunny/crossref_metadata_2025_split huggingface dataset:
A transputer‐based instrument for the ESA/NASA Cluster mission
Authors: Dunford C. M. , Thompson J. A. , Yearby K. H. 
Published: November 2006

AbstractThis paper describes the evolution and implementation of a multiple transputer based instrument, the Digital Wave Processor (DWP), for the ESA Cluster mission. The DWP is a fault‐tolerant instrument responsible for the control of five wave‐processing experiments, and the data processing and compression of their output. Novel features include low‐power modes of the DWP where some transputers are powered off and others may run at a reduced clock speed.
Algorithms and timing for identification of objects from 2‐D images
Authors: Lin W. , Fraser D. A. 
Published: November 2006

AbstractAn algorithm is presented for recognizing objects arriving under a TV camera on a conveyor belt. A stored description of a 3‐D object is rotated and translated, and its projected image is matched to the observed image. Implementations of the basic algorithm in parallel C on one, two, four, or eight T414 transputers show full speed‐up; for a version using effective heuristics which offers further saving of time, four transputers are enough.
A visual tracking system for the measurement of dynamic structural displacements
Authors: Stephen G. A. , Dagless E. L. , Taylor C. A. 
Published: November 2006

AbstractA transputer‐based system has been developed for the measurement of dynamic displacements in real time by visually tracking moving objects from a video Input. Parallel processing techniques have been used to track multiple objects at frame rate, and various predictive tracking algorithms have been assessed and implemented on the transputer network. The system is primarily intended for applications such as the monitoring or testing of large physical structures where actual displacements may not easily be otherwise determined. Results from the monitoring of the behaviour of the Humber Bridge at the centre of its span are presented.
DACAPO‐III: Parallel multilevel hardware simulation on transputers
Authors: Grabienski Peter 
Published: November 2006

AbstractDigital simulators are widely used in the design of digital integrated circuits. The complexity of these circuits is increasing, leading to higher simulation times. One strategy to increase simulation speed is parallel processing. In this paper the implementation of the DACAPO‐III simulation system is described in two steps. In the first step this system was implemented on one transputer and in a second step, on multiple transputers. For synchronization between the processors the 'time warp' method was chosen. Problems and results in using parallel processing for distributed simulation are discussed.
Object‐oriented simulations in mechatronics
Authors: Eppinger A. 
Published: November 2006

AbstractThe artificial word 'mechatronics' represents the symbiosis of 'classical' mechanical systems and 'modern' electmnics that has opened up a wide range of new possibilities. A typical application is an anti‐lock braking system (ABS), a very complex combination of sensors, microprocessor‐based controllers, electromagnetic actuators and mechanical as well as hydraulic components.Increasing complexity and their mostly non‐linear behaviour are the major challenges in designing, implementing and testing these systems. A very promising design methodology is based on the idea of integrating real hardware via interfaces into a system simulation ('hardware‐in‐the‐loop'). Development may start with a completely simulated model. With hardware being designed and becoming available, it is step by step incorporated into the system. This methodology significantly reduces development time since there is early feedback on the design approaches and the final solution is proved under real operating conditions.Obviously the real‐time simulation of fast mechatronical systems requires tremendous computing power. Supposing one finds a way to express the simulation problem in a parallel form, a multi‐transputer system could provide the necessary computing power for a relatively low price.One solution is a modelling approach that decomposes the systems hierarchically into components with a strong relationship to the physical world. Each component is described by a set of equations operating on the component's own local state. The communication of physical interface data is modelled by sending messages via connections between the components. This approach may be attributed as 'object‐oriented' since computer science defines objects as independent elements maintaining their own internal state and communicating via message‐passing mechanisms.Taking a close look at a transputer, it reveals a very 'object'‐like architecture: local memory to maintain its own local state and links designed to pass messages between transputers. Therefore transputers are the ideal vehicle for fast real‐time simulation by following the principle of object‐orientation, from system modelling all the way down to simulation.
Visual simulation by means of a transputer network for a driving simulator
Authors: Zimmermann Peter 
Published: November 2006

AbstractVisual simulation is one of the most important parts of a driving simulator. Unfortunately it is in general the most expensive part too. CGI‐manufacturers tend to develop more complex systems because of the demands of the military market. The common systems are strongly hardware‐oriented.On the basis of a new type of microprocessor, the transputer, a more software‐oriented approach is introduced. Transputers in connection with the new high‐level language occam are well suited for pipelining and parallelization owing to their communication concept. The advantages of this approach are reduced costs and development time, and also the capability for fast and cheap changes in algorithms. The achievable performance meets the requirements for a driving simulator very well.
VLSI design stations using transputers
Authors: Christian Stephen 
Published: November 2006

AbstractThis paper presents some of the work done at INMOS towards the development of a transputer‐based workstation to support its VLSI design community. The emphasis is on the practical application of multiple CPU technology to the solution of a specific problem and the advantages that transputers bring to such a system development. The more general use of transputer arrays for the acceleration of CAD algorithms is facilitated by the use of facilities within this workstation.
The EMMA2 multiprocessor operating system
Authors: Appiani E. , Bianco D. , Merlo L. , Roncarolo L. 
Published: November 2006

AbstractThe EMMA2EMMA is a registered trademark of Elsag—Elettronica San Giorgio.
parallel architecture is a network of nodes, named 'Regions': each region is based on two shared‐memory hierarchical bus levels, on which a large series of monocpu, multicpu and specialized I/O boards can be inserted, grouped in 'Families'.Its typical applications are Image processing, pattern recognition and artificial intelligence, characterized by intensive computation requirements, real‐time constraints and good price‐performance ratio for building large industrial systems. This paper presents the main characteristics of the EMMA2 parallel operating system, highlighting the internal organization and mechanisms offering the parallel co‐operation model for user programs.Section 1 briefly introduces the overall hardware architecture. It allows application partitioning into parallel independent subsystems, on two levels of computation: the lower level (family) is dedicated to massive number crunching, while the upper (region) permits the interaction of these lower machines.Section 2 deals with the system software environment, based on a host‐target configuration: the host is mainly devoted to machine control, system monitoring, program development and debugging in a multi‐user environment.Sections 3, 4 and 5 describe respectively the fundamental concepts of the operating system internal organization and the basic mechanisms with respect to the machine architecture; the basic functions that constitute the internal layers and services; the resulting parallel programming and co‐operation model and the typical mapping rules of algorithms to this architecture, completed with some examples of their functionalities.The most important aspect of the EMMA2 operating system is the fact that it offers a uniform interface to user tasks, independently of their allocation on the target machine. Objects managed by system services can be referred to via logical names. Code for system services is distributed among processors and resides on a private read‐only memory. The operating system's data reside in shared memory only for system functions that need to be distributed, while private functions are based on different copies of data in private memories.Section 6 gives more details on the most relevant EMMA2 industrial applications, also showing their mapping to the parallel architecture and some performance‐related information. Section 7 contains a brief outline of the novel architecture currently in development and of the subsequent OS Improvements.In conclusion, we report some considerations about the present status of the EMMA2 system, compared with some other well‐known architectures, and about research efforts for its future evolution.
Multiprocessors and run‐time compilation
Authors: Saltz Joel , Berryman Harry , Wu Janet 
Published: November 2006

AbstractRun‐time preprocessing plays a major role in many efficient algorithms in computer science, as well as playing an important role in exploiting multiprocessor architectures. We give examples that elucidate the importance of run‐time preprocessing and show how these optimizations can be integrated into compilers. To support our arguments, we describe transformations implemented in prototype multiprocessor compilers and present benchmarks from the iPSC2/860, the CM‐2 and the Encore Multimax/320.
Synchronization and load imbalance effects in distributed memory multi‐processor systems
Authors: Marinescu Dan C. , Rice John R. 
Published: November 2006

AbstractSynchronization is a major cause of wasted computing cycles and of diminished performance in parallel computing. This paper investigates the effects of synchronization upon the performance of iterative methods on distributed memory MIMD machines. A quantitative analysis of the effects of the communication latency and of the load imbalance due to the non‐deterministic execution times for iterative methods is presented. This analysis explains the rather poor performance observed often in actual implementations of such methods and suggests better ways to achieve convergence without frequent synchronization.
Physical computation
Authors: Fox Geoffrey C. 
Published: November 2006

AbstractPhysical computation embraces a variety of physical analogies used to tackle non‐traditional problems. We describe Monte Carlo and deterministic methods, including simulated annealing and neural networks. Applications include economic change in Eastern Europe, the travelling salesman problem, vehicle navigation, track finding, and parallel computer load balancing. We show how different problems are suitable for the different various approaches to optimizatton—there is no universally applicable method.
Achievements and prospects for parallel computing
Authors: Fox Geoffrey C. 
Published: November 2006

AbstractParallel computing works for the majority of large‐scale computations. The development of parallel hardware designs has been largely transferred to industry, while universities continue major research efforts Into better software environments. We describe a classification of problems and how different software models are needed for portable user‐friendly, high‐performance Implementations on parallel machines. The education of a new generation of computational scientists will be a major challenge to our universities.
A performance analysis exemplar: Parallel ray tracing
Authors: Jensen D. W. , Reed D. A. 
Published: November 2006

AbstractAmong the many techniques in computer graphics, ray tracing is prized because it can render realistic images, albeit at great computational expense. Ray tracing's large computation requirements, coupled with its inherently parallel nature, make ray tracing algorithms attractive candidates for parallel implementation. In this paper we illustrate the utility and the importance of a suite of performance analysis tools when exploring the performance of several approaches to ray tracing on a distributed memory parallel system. These ray tracing algorithm variations introduce parallelism based on both ray and object partitions.Traditional timing analysis can quantify the performance effects of different algorithm choices (i.e. when an algorithm is best matched to a given problem), but it cannot identify the causes of these performance differences. We argue, by example, that a performance instrumentation system is needed that can trace the execution of distributed memory parallel programs by recording the occurrence of parallel program events. The resulting event traces can be used to compile summary stapistics that provide a global view of program performance. In addition, visualization tools permit the graphic display of event traces. Visual presentation of performance data is particularly useful, indeed, necessary for large‐scale, parallel computations; assimilating the enormous volume of performance data mandates visual display.
Highly efficient transputer arrays for the computation of robot dynamics
Authors: Zomaya Albert Y. 
Published: November 2006

AbstractThe modelling of the highly coupled and non‐linear dynamic models of robot manipulators is computationally expensive in terms of computer hardware. Hence this problem has always presented a major obstacle in on‐line dynamic control applications. However, the recent advent of the VLSI single on‐chip computer (Transputer) makes it possible to implement new algorithms that compute these dynamic models within real‐time constraints. This paper describes a solution of this problem by employing a parallel‐processing approach. The dynamic model of a robot manipulator is divided into different tasks. Further, each task is divided into several subtasks. A heuristic scheduling algorithm is used to produce different near‐optimum task allocations. Real‐time implementations of the proposed tasks allocations are given to demonstrate the efficiency and superiority of the parallel‐processing approach.
Parallelizing the spectral transform method
Authors: Worley Patrick H. , Drake John B. 
Published: November 2006

AbstractThe spectral transform method is a standard numerical technique used to solve partial differential equations on the sphere in global climate modeling. In particular, it is used in CCM1 and CCM2, the Community Climate Models developed at the National Center for Atmospheric Research. This paper describes initial experiences in parallelizing a program that uses the spectral transform method to solve the non‐linear shallow water equations on the sphere, showing that an efficient implementation is possible on the Intel iPSC/860. The use of PICL, a portable instrumented communication library, and Paragraph, a performance visualization tool, in tuning the implementation is also described.The Legendre transform and the Fourier transform comprise the computational kernel of the spectral transform method. This paper is a case study of parallelizing the Legendre transform. For many problem sizes and numbers of processors, the spectral transform method can be parallelized efficiently by parallelizing only the Legendre transform.
Network‐based concurrent computing on the PVM system
Authors: Geist G. A. , Sunderam V. S. 
Published: November 2006

AbstractConcurrent computing environments based on loosely coupled networks have proven effective as resources for multiprocessing. Experiences with and enhancements to version 1.0 of PVM (Parallel Virtual Machine) are described in this paper. PVM is a software package that allows the utilization of a heterogeneous network of parallel and serial computers as a single computational resource. This report also describes an interactive graphical interface to PVM, and porting and performance results from production applications.
Replication techniques for speeding up parallel applications on distributed systems
Authors: Bal Henri E. , Kaashoek M. Frans , Tanenbaum Andrew S. , Jansen Jack 
Published: November 2006

AbstractMost methods for programming loosely coupled systems are based on message‐passing. Recently, however, methods have emerged based on ‘virtually’ sharing data. These methods simplify distributed programming, but are hard to implement efficiently, as loosely coupled systems do not contain physical shared memory. We introduce a new model,the shared data‐object model, that eases the implementation of parallel applications on loosely coupled systems, but can still be implemented efficiently.In our model, shared data are encapsulated in passive data‐objects, which are variables of user‐defined abstract data types. To speed up access to shared data, data‐objects are replicated. This ability to replicate objects is a significant difference with other object‐based models (e.g. Emerald and Amber). Also, by replicating logical objects rather than physical pages, our model has many advantages over shared virtual memory systems.This paper discusses the design choices involved in replicating objects and their effect on performance. Important issues are: how to maintain consistency among different copies of an object; how to implement changes to objects; which strategy for object replication to use. We have implemented several options to determine which ones are the most efficient.
Parallel computing in aerospace using multi‐block grids. Part 1: Application to grid generation
Authors: Húuser J. , Wong H. , Gentzsch W. , Paap H. G. 
Published: November 2006

AbstractThe present paper describes the implementation of multi‐block codes, used to model complex 2‐D geometries for applications in computational fluid dynamics on massively parallel architectures. The work starts with a brief description of ongoing and planned major aerospace projects and gives an estimate of the computing power needed. In order to provide this computational speed, one has to resort to massively parallel systems. In the first section the essential features of multi‐block grids, along with the grid generation equations are discussed and it is shown that overlapping multi‐block grids are inherently parallel by construction. Since the number of blocks is not fixed, but can be matched to a large extent to the number of available processors, there are no principal limitations of this parallelization approach, provided the ratio of computation time to communication time remains large enough, which leads to the discussion of problem scalability. The details of implementation on the Intel iPSC/2 of a general 2‐D multi‐block mesh‐generation code are outlined in sections 2 and 3, together with the listings of the major communication function (Section 4). In section 5 the results for this code are presented, clearly demonstrating that the multi‐block concept is a viable tool for massively parallel computers, which can be applied to virtually all problems in science and engineering where computational meshes are used. In section 5.2 an outlook on the parallelization of more complex problems is given, and estimates for speed‐up and efficiency, based on the present experiences, are provided. It turns out that, as long as computation dominates communication time, which is usually the case for complex aerospace applications, parallelization will be the tool to provide the additional orders of magnitude of computing power needed to routinely design and analyse future aircraft as well as spacecraft, in particular at high Mach numbers, when chemical reactions become important.
Echidna, an estelle compiler to prototype protocols on distributed computers
Authors: Jard Claude , Jezequel Jean‐Marc 
Published: November 2006

AbstractWe report our experience in developing a compiler and a distributed run‐time kernel for distributed computers, called Echidna. Echidna is a software package which has been available for more than two years, and aims to support protocol designers in protocol modeling, validation and performance evaluation. It is basically oriented towards the rapid prototyping of distributed algorithms on distributed computers: the Intel iPSC hypercube, the Supernode machine, and networks of Transputers and Suns were considered. Algorithms are described using an ISO formal description technique called Estelle.First, we present and justify the concept of experimentation on distributed algorithms for which our Estelle compiler has been designed. Then we discuss how Estelle constructs are mapped onto C structures and how they are interpreted by a distributed run‐time kernel. We conclude by presenting typical uses of Echidna.
Transputer arrays for the on‐line computation of robot jacobians
Authors: Zomaya A. Y. H. , Morris A. S. 
Published: November 2006

AbstractOn‐line computation of forward and inverse Jacobian matrices is essential in robot manipulator controllers, where high‐speed robot motion is required. The complexity of Jacobian calculation is such that the computational burden is large, and parallel processing is necessary if on‐line computation is to be achieved. Various algorithms and parallel‐processing networks suitable for this are considered. All algorithms have been implemented on transputer networks and computation times measured. The paper emphasises the importance of including communication overheads in comparisons of the computational efficiency of alternative algorithms and processor networks. Theoretical processing times based on computer cycle times and arithmetic operation counts are shown to be a false basis for comparison.Whilst considering the specific case of computation of Jacobian matrices for a robot manipulator, the paper provides a useful example of the considerations and constraints involved in distributing any algorithm across a multi‐processor network.
MOVIE model for open‐systems‐based high‐performance distributed computing
Authors: Furmanski Wojtek , Faigle Chris , Haupt Tom , Niemiec Janusz , Podgorny Marek , Simoni Diglio 
Published: November 2006

AbstractMOVIE (Multitasking Object‐oriented Visual Interactive Environment) is a new software system for high‐performance distributed computing (HPDC), currently in the advanced design and implementation stage at Northeast Parallel Architectures Center (NPAC), Syracuse University. The MOVIE system is structured as a multiserver network of interpreters of the high‐level object‐oriented programming language MovieScript. MovieScript derives from PostScript and extends it in the C++ syntax‐based object‐oriented interpreted style towards 3D graphics, high‐performance computing and general‐purpose high‐level communication protocol for distributed and MIMD‐parallel computing. The paper describes the overall open systems‐based MOVIE design and itemizes currently implemented, developed and planned components of the system.
Particle simulation on heterogeneous distributed supercomputers
Authors: Becker Jeffrey C. , Dagum Leonardo 
Published: November 2006

AbstractWe describe the implementation and performance of a three dimensional particle simulation distributed between a Thinking Machines CM‐2 and a Cray Y‐MP. These are connected by a combination of two high‐speed networks: a high‐performance parallel Interface (HIPPI) and an optical network (UltraNct). This is the first application to use this configuration at NASA Ames Research Center. We describe our experience Implementing and using the application and report the results of several timing measurements. We show that the distribution of applications across disparate supcrcomputing platforms Is feasible and has reasonable performance. In addition, several practical aspects of the computing environment arc discussed.