bluuebunny/crossref_metadata_2025_split huggingface dataset:
The solution of radiation engineering problems on a transputer‐based system
Authors: Khaddaj S. A. , Al‐Bahadili H. , Goddard A. J. H. , de Oliveira C. R. E. , Wood J. 
Published: November 2006

AbstractMonte Carlo and finite element methods are numerical techniques used for solving complex problems in reactor physics and radiation shielding. In this paper we are concerned with the implementation of existing research‐level codes based on these two methods, written originally for serial computers, on an MIMD transputer‐based system. Results and performance of the parallelized codes are presented.
The Metrobridge—an application of transputers in transparent bridging
Authors: Robertson B. , Chopping M. , Zielinski K. , Milway D. 
Published: November 2006

AbstractThis paper describes the Metrobridge project—a distributed switch for connecting PC cards via a high‐speed backbone network. The paper outlines the communication and management functions that are provided, and describes the hardware and software modules that make up the system. Finally, the advantages and disadvantages of using the transputer are discussed.
Parallel computing in the 1980s—one person's view
Authors: Messina Paul C. 
Published: November 2006

AbstractThis paper is a survey of activities related to parallel computing that took place primarily during the 1980s. The major areas covered are hardware, software, and performance measurement and characterization. Emphasis is on identifying the major milestones of the decade and on commercial computers rather than present a comprehensive survey of the field. The material is treated from the user's point of view.
ES‐Kit: An object‐oriented distributed system
Authors: Chatterjee Arunodaya , Khanna Arjun , Hung Ying 
Published: November 2006

AbstractThis paper describes the design, implementation, and performance of ES‐Kit, a distributed object‐oriented system being developed by the Experimental Systems Project at the Microelectronics and Computer Technology Corporation. The operating system consists of a kernel and a set of Public Service Objects which dynamically extend the functionality of the kernel by providing several traditional operating system services when required by application objects. Applications for the ES‐Kit environment are written in GNU C++ and do not require additional language primitives for distributed execution. Initial performance results from a representative set of applications indicate that the object‐oriented paradigm provides a powerful solution to distributed programming.
Portable tools for Fortran parallel programming
Authors: Kumar Swarn P. , Philips Ivor R. 
Published: November 2006

AbstractThis paper presents a survey of some of the tools, techniques, and constructs for the development of portable, multitasked Fortran programs. The study mainly focuses on existing software tools that implement different approaches to achieving portability of multitasked Fortran programs for local and shared memory multiprocessor computers. However, some proposed approaches are also included. It appears that while each approach enjoys some advantages and suffers some disadvantages, at present, the development and use of portable multitasking tools is in its infancy, and thus no one system is clearly superior. Indeed, we expect that, for the foreseeable future, these and perhaps other techniques will all be actively pursued.
LAPACK: A portable linear algebra library for high‐performance computers
Authors: Demmel James 
Published: November 2006

AbstractThe goal of the LAPACK project is to design and implement a portable linear algebra library for etficient use on a variety of high‐performance computers. The library is based on the widely used LINPACK and EISPACK packages for solving linear equations, eigenvalue problems, and linear least‐squares problems, but extends their functionality in a number of ways. The major methodology for making the algorithms run faster is to restructure them to perform block matrix operations (e.g. matrix‐matrix multiplication) in their inner loops. These block operations may be optimized to exploit the memory hierarchy of a specific architecture. In particular, we discuss algorithms and benchmarks for the singular value decomposition.
Numerical simulation of incompressible fluid flows
Authors: Anagnostou George , Maday Yvon , Patera Anthony T. , Fischer Paul F. , Rønqist Einar M. 
Published: November 2006

AbstractIn this paper we discuss temporal, spatial, and architectural aspects of the numerical simulation of time‐dependent incompressible fluid flows. In particular, we consider: high‐order operator‐integration‐factor time‐splitting methods; sliding‐mesh spectral mortar‐element spatial discretizations; and data‐parallel distributed‐memory medium‐grained parallel solution techniques. Numerous flow examples are presented.
The use of the CAPE Environment in the simulation of rock fracturing
Authors: Norman M. G. , Henderson J. R. , Main I. G. , Wallace D. J. 
Published: November 2006

AbstractThe Cellular Automaton Programming Environment (CAPE) was developed as a programming paradigm specific tool for simulation of physical systems by cellular automata (CAs) on the Meiko Computing Surface. CAPE is structured in a way that allows application‐specific elements to be replaced whilst retaining the core of the tool.One of the applications areas where CAPE has been used is in the initial stages of a project which is studying the complex non‐linear processes of fracture evolution and fluid flow in geological materials. We describe the programming abstraction provided by CAPE, primarily concentrating on the approach that is taken to reducing the application programmer's initial exposure to issues in parallel computing. We give a brief description of the geological processes that have been simulated, and consider the problems that are associated with this application of CAPE.
Analysis of multidimensional images on the Connection Machine system
Authors: Marcenaro Giampiero , Tistarelli Massimo 
Published: November 2006

AbstractThe Connection Machine (CM) has been demonstrated to be an efficient and fast computational engine for the solution of many problems related to image processing. The high‐level parallelism of the CM naturally fits to many large‐scale data intensive applications.In this paper the implementation of parallel algorithms for the analysis of multidimensional images on the CM is presented. Different aspects in the analysis of multidimensional images are considered. In the field of artificial vision, the implementation of algorithms for the filtering of image sequences (both in space and time) and the estimation of the optical flow is described and some results in terms of accuracy and computation time are presented.The processing of three‐dimensional images is investigated in the field of biomedical engineering. In this case the goal is the development of algorithms for the 3‐D reconstruction of human body segments and their visualization.The parallel implementations exploit the fine grain parallelism allowed by the CM, processing each point of the data on a different processor. This mechanism is allowed by the possibility of dynamically reconfiguring the connectivity of the CM nodes and of defining a huge number of virtual processors. Moreover, as the CM processors operate on one‐bit data, it is possible to tune the number of bits for each data point to match the accuracy required by the application.
Aeroelastic applications of the Connection Machine
Authors: Sipcic Slobodan R. , Westbrook Thomas 
Published: November 2006

AbstractThis paper describes the implementation of a dynamical systems approach to aeroelastic analysis using the Connection Machine model 2 (CM‐2). Through numerical simulation, the regions of harmonic and chaotic behavior in the δ,Rx (velocity, in‐plane load) plane have been examined in detail. These regions are of interest in evaluation of the fatigue life of fluttering plates. The CM‐2 computer architecture allows the removal of many of the previous simplifying and limiting assumptions regarding the prediction of the stability regions maps. Owing to its high‐speed prediction capability, the CM‐2, with framebuffer, offers 'real‐time' display of the solution as it evolves during the prediction process. This feature gives insight into the fundamental way in which the solution evolves. This is essential in defining the scenarios describing roads to chaotic behavior of the dissipative dynamical systems.
Design, implementation and evaluation of a deadlock‐free routing algorithm for concurrent computers
Authors: Cannataro M. , Spezzano G. , Talia D. , Gallizzi E. 
Published: November 2006

AbstractThis paper describes the design, the implementation, and the performance results of a routing algorithm which provides deadlock‐free communication in a tightly coupled message‐passing concurrent computer. The algorithm is adaptive, isolated and uses the store‐and‐forward technique. It allows message communication between two processes regardless of where they are physically located on the network. The routing algorithm has many positive characteristics including provable deadlock freedom, guaranteed message arrival, and automatic local congestion reduction. It can be used as a basis for the design of high‐level communication primitives. An Occam implementation on a network of inmos Transputers is discussed. The experimental results show that the routing algorithm is effective to support process to process communication on a concurrent computer.
Parallel approaches to the solution of the assignment problem
Authors: Davis Nathaniel J. , Carpenter Barry A. , Glover Charles W. , Culioli Jean‐Christophe 
Published: November 2006

AbstractThis paper discusses efforts to develop parallel algorithms that can be used to solve large‐scale assignment problems typical of military battle management systems. Attempts to parallellze the classical Hungarian method are explored. Drawing on experimental data, a regresslon model is derived that relates the Hungarian method's run time to a cubic function of the number of parallel processors used in the solution. Four parallel heuristics for solving the assignment problem are developed and analysed. Two of them perform well in a parallel environment. The first, based on Vagel's approximation, can be used to identify a feasible, near‐optimal assignment. The second algorithm partitions the assignment problem into independent subproblems across the parallel array. The resulting solution, although infeasible in the strict definition of the assignment problem, is seen to be reasonably good and can be obtained very rapidly. Either of these two heuristics are of potential use in the stringent computing environment of a real‐time resource management system.
Run‐time data decomposition for parallel implementation of image processing and computer vision tasks
Authors: Choudhary Alok N. , Ponnusamy Ravi 
Published: November 2006

AbstractThis paper presents several static and dynamic data decomposition techniques for parallel implementation of common computer vision algorithms. These techniques use the distribution of features in the input data as a measure of load for data decomposition. Experimental results are presented by implementing algorithms from a motion estimation system using these techniques on a hypercube multiprocessor. Normally in a vision system a sequence of algorithms is employed in which output of an algorithm is input to the next algorithm in the sequence. The distribution of features computed as a by‐product of the current task is used to repartition the data for the next task in the system. This allows parallel computation of feature distribution, and therefore the overhead of estimating the load is kept small. It is observed that the communication overhead to repartition data using these run‐time decomposition techniques is very small. It is shown that significant performance improvements over uniform‐block‐oriented partitioning schemes are obtained.
The Genesis distributed‐memory benchmarks. Part 1: Methodology and general relativity benchmark with results for the SUPRENUM computer
Authors: Addison Cliff , Allwright James , Binsted Norman , Bishop Nigel , Carpenter Bryan , Dalloz Peter , Gee David , Getov Vladimir , Hey Tony , Hockney Roger , Lemke Max , Merlin John , Pinches Mark , Scott Chris , Wolton Ivan 
Published: November 2006

AbstractThis is the first of a series of papers on the Genesis distributed‐memory benchmarks, which were developed under the European ESPRIT research program. The benchmarks provide a standard reference Fortran77 uniprocessor version, a distributed memory. MIMD version, and in some cases a Fortran90 version suitable for SIMD computers. The problems selected all have a scientific origin (mostly from physics or theoretical chemistry), and range from synthetic code fragments designed to measure the basic hardware properties of the computer (especially communication and synchronisation overheads), through commonly used library subroutines, to full application codes. This first paper defines the methodology to be used to analyse the benchmark results, and gives an example of a fully analysed application benchmark from General Relativity (GR1). First, suitable absolute performance metrics are carefully defined, then the performance analysis treats the execution time and absolute performance as functions of at least two variables, namely the problem size and the number of proecssors. The theoretical predictions are compared with, or fitted to, the measured results, and then used to predict (with due caution) how the performance might scale for larger problems and more processors than were actually available during the benchmarking. Benchmark measurements are given primarily for the German SUPRENUM computer, but also for the IBM 3083J, Convex C210 and a Parsys Supernode with 32 T800‐20 transputers.
An overview of manifold and its implementation
Authors: Arbab F. , Herman I. , Spilling P. 
Published: November 2006

AbstractManagement of the communications among a set of concurrent processes arises in many applications and is a central concern in parallel computing. In this paper we introduce MANIFOLD: a co‐ordination language whose sole purpose is to describe and manage complex interconnections among independent, concurrent processes. In the underlying paradigm of this language the primary concern is not with what functionality the individual processes in a parallel system provide. Instead, the emphasis is on how these processes are interconnected and how their interaction patterns change during the execution life of the system. This paper also includes an overview of our implementation of MANIFOLD.As an example of the application of MANIFOLD, we present a series of small manifold programs which describe the skeletons of some adaptive recursive algorithms that are of particular interest in computer graphics. Our concern in this paper is to show the expressiveness of MANIFOLD, the feasibility of its implementation and its usefulness in practice. Issues regarding performance and optimization are beyond the scope of this paper.
Performance comparison of dynamic policies for remote caching
Authors: Pu Calton , Florissi Danilo , Scares Patricia , Yu Philip S. , Wu Kun‐Luno 
Published: November 2006

AbstractIn a distributed system, data servers (file systems and databases) can easily become bottlenecks. We propose an approach to offloading data access requests from overloaded data servers to nodes that are Idle or less busy. This approach is referred to asremote caching, and the idle or less busy nodes are calledmutual serversas they help out the busy server nodes on data accesses. In addition to server and client local caches, frequently accessed data are cached in the main memory of mutual servers, thus improving the data access time in the system. We evaluate several data propagation strategics among data servers and mutual servers. These include policies in which senders are active/passive and receivers are active/passive in initiating data propagation. For example, an active sender takes the initiative to offload data onto a passive receiver. Simulation results show that the active‐sender/passive‐receiver policy is the method of choice In most cases. Active‐Sender policies are best able to exploit the main memory of other Idle nodes in the expected normal condition where some nodes are overloaded and others are less loaded. AH active policies perform far better than the policy without remote caching even in the degenerated case where each node is equally loaded.
Data‐parallel programming on a network of heterogeneous workstations
Authors: Nedeljkovlc Nenad , Quinn Michael J. 
Published: November 2006

AbstractWe describe a compiler and run‐time system that allow data‐parallel programs to execute on a network of heterogeneous UNIX workstations. The programming language supported is Dataparallel C, a SIMD language with virtual processors and a global name space. This parallel programming environment allows the user to take advantage of the power of multiple workstations without adding any message‐passing calls to the source program. Because the performance of Individual workstations in a multi‐user environment may change during the execution of a Dataparallel C program, the run‐time system automatically performs dynamic load balancing. We present experimental results that demonstrate the usefulness of dynamic load‐balancing In a multi‐user environment These results suggest that initially allocating the same amount of work to each processor and letting the dynamic load balancing algorithm adjust the load during program execution yields very good performance. Hence neither the compiler nor the run‐time system need a priori knowledge of the speeds of the machines that will participate in a program execution.
ADAPTIVE: A dynamically assembled protocol transformation, integration and evaluation environment
Authors: Schmidt Douglas C. , Box Donald F. , Suda Tatsuya 
Published: November 2006

AbstractComputer communication systems must undergo significant changes to keep pace with the increasingly demanding and diverse multimedia applications that will run on the next generation of high‐performance networks. To facilitate these changes, we are developing A Dynamically Assembled Protocol Transformation, Integration and evaluation Environment (ADAPTIVE). ADAPTIVE provides an integrated environment for developing and experimenting with flexible transport system architectures that support lightweight and adaptive communication protocols for diverse multimedia applications running on high‐performance networks. Our approach employs a collection of reusable ‘building‐block’ protocol mechanisms that may be composed together automatically based upon functional specifications. The resulting protocols execute in parallel on several target platforms including shared‐memory and message‐passing multiprocessors. ADAPTIVE provides a framework for (1) determining the functionality of customized lightweight protocol configurations that efficiently support multimedia applications and (2) mapping this functionality onto efficient parallel process architectures.
No pain and gain!—experiences with Mentat on a biological application
Authors: Grimshaw Andrew S. , West Emily A. , Pearson William R. 
Published: November 2006

AbstractThroughout much of the parallel processing community there is the sense that writing software for distributed‐memory parallel processors Is subject to a ‘no pain—no gain’ rule: that In order to reap the benefits of parallel computation one must first suffer the pain of converting the application to run on a parallel machine. We believe this Is the result of Inadequate programming tools and not a problem Inherent to parallel processing. We will show that one can parallelize real scientific applications and obtain good performance with little effort If the right tools are used. Our vehicle for this demonstration is a 6000‐line DNA and protein sequence comparison application that we have implemented in Mental, an object‐oriented parallel processing system for both parallel and distributed architectures. We briefly describe the application and present performance information for both the Mentat version and a hand‐coded parallel version of the application.
Experiences with SLALOM on the distributed Pleiades/ESP system
Authors: Wilson Unda F. , Gonzalez Mario J. , Cruess Michael W. 
Published: November 2006

AbstractThe paper describes experiences gained during the process of Implementing a standard serial benchmark (SLALOM) on a distributed computing system (Pleiades running ESP/C++). Based on a real problem In computer graphics, SLALOM Is a timed benchmark that Includes problem set‐up and I/O costs. The purpose of our experiments has been to maximize the speedup of a distributed implementation of SLALOM when compared to Its serial implementation. As a result of these experiments, we have developed several guidelines for adapting algorithms for distributed systems.
Radiative Heat Transfer Simulation on a SPARCStation Farm
Authors: Minnich Ronald G. , Pryor Daniel V. 
Published: November 2006

AbstractAt the Supcrcomputing Research Center we have built a computing farm consisting of 16 SPARCStation. ELCs. The ELCs all support the Mother distributed shared memory, which has primitives to support efficient synchronization and use of the network and processors. Mother docs not support the traditional consistency semantics provided by, for example, Ivy or Mach external pagers.The first parallel application we ran on the farm was a Monte Carlo radiative heat transfer simulation. The performance we achieved on the farm was within an order of magnitude of the performance we would expect to achieve on a 16‐processor model of the C90 supercomputer available from Cray Research.With this application we found that the use of the Mother distributed shared memory allowed us to run the same code on the Cray as we ran on the SPARCStatlons, and we did not require the complex cache‐coherent memory semantics provided by, say, Ivy or Mach to run this application effectively.
Restructuring Fortran programs for Cedar
Authors: Eigenmann Rudolf , Hoeflinger Jay , Jaxon Greg , Li Zhiyuan , Padua David 
Published: November 2006

AbstractThe paper reports on the status of the Fortran translator for the Cedar computer at the end of March 1991. A brief description of the Cedar Fortran language is followed by a discussion of the Fortran‐77 to Cedar Fortran parallelizer that describes the techniques currently being implemented. A collection of experiments illustrate the effectiveness of the current implementation, and point toward new approaches to be incorporated into the system in the near future.
Engineering a data dependence test
Authors: Wolfe Michael 
Published: November 2006

AbstractMany papers have been written dealing with the science of data dependence tests, particularly for dependence of arrays in loops; the techniques typically reduce the dependence problem to an algebraic problem, then solve the algebraic problem by an algorithm which has some desired blend of efficiency, generality or precision. While a sound theoretical basis is necessary for dependence‐based tools, these papers often leave out many implementation details. This paper addresses the engineering aspects of data dependence testing, particularly focusing on details that are necessary in any competent implementation of a data dependence test.