Good Speedup Research Articles

Solving unsymmetric sparse systems of linear equations with PARDISO

Supernode partitioning for unsymmetric matrices together with complete block diagonal supernode pivoting and asynchronous computation can achieve high gigaflop rates for parallel sparse LU factorization on shared memory parallel computers. The progress in weighted graph matching algorithms helps to extend these concepts further and unsymmetric prepermutation of rows is used to place large matrix entries on the diagonal. Complete block diagonal supernode pivoting allows dynamical interchanges of columns and rows during the factorization process. The level-3 BLAS efficiency is retained and an advanced two-level left–right looking scheduling scheme results in good speedup on SMP machines. These algorithms have been integrated into the recent unsymmetric version of the PARDISO solver. Experiments demonstrate that a wide set of unsymmetric linear systems can be solved and high performance is consistently achieved for large sparse unsymmetric matrices from real world applications.

Solving unsymmetric sparse systems of linear equations with PARDISO

Supernode partitioning for unsymmetric matrices together with complete block diagonal supernode pivoting and asynchronous computation can achieve high gigaflop rates for parallel sparse LU factorization on shared memory parallel computers. The progress in weighted graph matching algorithms helps to extend these concepts further and unsymmetric prepermutation of rows is used to place large matrix entries on the diagonal. Complete block diagonal supernode pivoting allows dynamical interchanges of columns and rows during the factorization process. The level-3 BLAS efficiency is retained and an advanced two-level left–right looking scheduling scheme results in good speedup on SMP machines. These algorithms have been integrated into the recent unsymmetric version of the PARDISO solver. Experiments demonstrate that a wide set of unsymmetric linear systems can be solved and high performance is consistently achieved for large sparse unsymmetric matrices from real world applications.

Parallel Computing of an Integral Formulation of Transient Radiation Transport

Parallel computing of the transient radiative transfer process in participating media is studied with an integral equation model. Two numerical quadratures are used: the discrete rectangular volume (DRV) method and YIX method. The parallel versions of both methods are developed for one-dimensional and three-dimensional geometries, respectively. Both quadratures achieve good speedup in parallel performance. Because the integral equation model uses very small amount of memory, the parallel computing can take advantage of having each processor store the full spatial domain information without using the typical domain decomposition parallelism, which will be necessary in other solution methods, for example, discrete ordinates and finite volume methods, for large-scale simulations. The parallel computation is conducted by assigning a different portion of the quadrature to different compute node. In DRV method a variation of the spatial domain decomposition is used. In the case of YIX scheme, the angular quadrature is divided up according to the number of compute nodes. These parallel schemes minimize the communications overhead

Phoenix

This paper proposes Phoenix, a programming model for writing parallel and distributed applications that accommodate dynamically joining/leaving compute resources. In the proposed model, nodes involved in an application see a large and fixed virtual node name space . They communicate via messages, whose destinations are specified by virtual node names, rather than names bound to a physical resource. We describe Phoenix API and show how it allows a transparent migration of application states, as well as dynamically joining/leaving nodes as its by-product. We also demonstrate through several application studies that Phoenix model is close enough to regular message passing, thus it is a general programming model that facilitates porting many parallel applications/algorithms to more dynamic environments. Experimental results indicate applications that have a small task migration cost can quickly take advantage of dynamically joining resources using Phoenix. Divide-and-conq! uer algorithms written in Phoenix achieved a good speedup with a large number of nodes across multiple LANs (120 times speedup using 169 CPUs across three LANs). We believe Phoenix provides a useful programming abstraction and platform for emerging parallel applications that must be deployed across multiple LANs and/or shared clusters having dynamically varying resource conditions.

P‐Jigsaw: a cluster‐based Web server with cooperative caching support

AbstractClustering provides a viable approach to building scalable Web systems with increased computing power and abundant storage space for data and contents. In this paper, we present a pure‐Java‐based parallel Web server system, p‐Jigsaw, which operates on a cluster and uses the technique of cooperative caching to achieve high performance. We introduce the design of an in‐memory cache layer, called Global Object Space (GOS), for dynamic caching of frequently requested Web objects. The GOS provides a unified view of cluster‐wide memory resources for achieving location‐transparent Web object accesses. The GOS relies on cooperative caching to minimize disk accesses. A requested Web object can be fetched from a server node's local cache or a peer node's local cache, with the disk serving only as the last resort. A prototype system based on the W3C Jigsaw server has been implemented on a 16‐node PC cluster. Three cluster‐aware cache replacement algorithms were tested and evaluated. The benchmark results show good speedups with a real‐life access log, proving that cooperative caching can have significant positive impacts on the performance of cluster‐based parallel Web servers. Copyright © 2003 John Wiley & Sons, Ltd.

Performance of a distributed architecture for query processing on workstation clusters

A network of workstations (NOWs) is an attractive alternative to parallel database systems due to the cost advantage. In a typical database, client workstations (nodes) submit queries/transactions and receive responses from the database server. With even recent PC-based client nodes providing traditional workstation-class performance, performance improvements can be obtained by offloading some of the processing typically done on the traditional server node to these powerful client nodes. Parallel query processing takes advantage of the idle cycles on the client nodes to process the query. In this paper we introduce a distributed architecture for parallel query processing and study the performance of this architecture in various scenarios. We have implemented the distributed architecture using parallel virtual machine (PVM) on a Pentium-based NOW system. Our results show that the distributed architecture successfully achieves good speedups and scaleups. Furthermore, our results show that the distributed architecture handles both light and heavy workloads in the presence of a background (non-query) load.

Distributed Maple: parallel computer algebra in networked environments

We describe the design and use of Distributed Maple, an environment for executing parallel computer algebra programs on multiprocessors and heterogeneous clusters. The system embeds kernels of the computer algebra system Maple as computational engines into a networked coordination layer implemented in the programming language Java. On the basis of a comparatively high-level programming model, one may write parallel Maple programs that show good speedups in medium-scaled environments. We report on the use of the system for the parallelization of various functions of the algebraic geometry library CASA and demonstrate how design decisions affect the dynamic behaviour and performance of a parallel application. Numerous experimental results allow comparison of Distributed Maple with other systems for parallel computer algebra.

A Neural Network Implementation For Data Assimilation Using MPI

The meteorological data assimilation process can be described as a procedure that uses observational data to improve the weather forecast produced by means of a mathematical model. Traditional metlods include deterministic and probabilistic approaches. Included in the latter class, Kahnan filtering has the advantage of minimizing tie error propagated during the data assimilation. However, this method demands a heavy computational power as it usually deals with meteorological parameters for a huge number of grid points. Recently, neural networks have been proposed as a new method for meteorological data assimilation by employing a Multilayer Perception network with backpropagation learning to emulate Kalrnan filtering at a lower computational cost. In order to further reduce that cost and to overcome performance bottlenecks of the training phase, code opdmizations were performe& making use of classical, hardware-independent techniques and Fortran 95 intrinsic functions, thus eliminating inefficient routines. A former attempt to parallelize the code and run it in a 4-processor shared memory machine, made use of HPF (High Performance Fortran) dwectives imbedded in the optimized code. Performance was poor and therefore a new version of the Fortran 95 code was developed using Message Passing Interface library calls. This code was executed in a 16-node multicomputer showing good speed-up up to 4 processors.

Parallelizing graph construction operations in programs with cyclic graphs

Pointer analysis has been an active research field in recent years. Combining pointer analysis and dependence analysis can identify parallelism in programs with pointers or graphs, which are in turn represented by dynamic pointer-linked data structures. After parallelism is identified, programs can be parallelized and then executed on parallel multiprocessor systems to achieve high performance. The compiler analysis techniques that have been proposed so far can only recognize parallelism in the traversal references of programs with cyclic graphs by analyzing the traversal patterns on graphs. Consequently, only the graph traversal operations will be parallelized while the graph construction operations will be left to be executed in sequential. Although this approach can usually parallelize the most time-consuming part of these programs (the graph traversal operations account for over 90% of total execution times in most programs), the rest of programs that accounts for less than 10% will dominate the execution on multiprocessor systems according to Amdahl's law. This paper presents a technique that can identify parallelism in the construction operations of programs even with cyclic graphs. This technique is designed to facilitate automatic parallelization of scientific computational applications that construct cyclic graphs to represent adjacent lists, which in turn describe the interactions of simulated objects. Experimental results show this approach can parallelize the construction phase of such programs and achieve good speedup on multiprocessor systems.

Parallel PSM/FDM Hybrid Simulation of Ground Motions from the 1999 Chi-Chi, Taiwan, Earthquake

— A new technique for the parallel computing of 3-D seismic wave propagation simulation is developed by hybridizing the Fourier pseudospectral method (PSM) and the finite-difference method (FDM). This PSM/FDM hybrid offers a good speed-up rate using a large number of processors. To show the feasibility of the hybrid, a numerical 3-D simulation of strong ground motion was conducted for the 1999 Chi-Chi, Taiwan earthquake (Mw 7.6). Comparisons between the simulation results and observed waveforms from a dense strong ground motion network in Taiwan clearly demonstrate that the variation of the subsurface structure and the complex fault slip distribution greatly affect the damage during the Chi-Chi earthquake. The directivity effect of the fault rupture produced large S-wave pulses along the direction of the rupture propagation. Slips in the shallow part of the fault generate significant surface waves in Coastal Plain along the western coast. A large velocity gradient in the upper crust can propagate seismic waves to longer distances with minimum attenuation. The S waves and surface waves were finally amplified further by the site effect of low-velocity sediments in basins, and caused the significant disasters.

Dust Dynamics in Protoplanetary Disks: Parallel Computing with PVM

We describe a parallel version of our high-order-accuracy particle-mesh code for the simulation of collisionless protoplanetary disks. We use this code to carry out a massively parallel, two-dimensional, time-dependent, numerical simulation, which includes dust particles, to study the potential role of large-scale, gaseous vortices in protoplanetary disks. This noncollisional problem is easy to parallelize on message-passing multicomputer architectures. We performed the simulations on a cache-coherent nonuniform memory access Origin 2000 machine, using both the parallel virtual machine (PVM) and message-passing interface (MPI) message-passing libraries. Our performance analysis suggests that, for our problem, PVM is about 25% faster than MPI. Using PVM and MPI made it possible to reduce CPU time and increase code performance. This allows for simulations with a large number of particles (N ∼ 105–106) in reasonable CPU times. The performances of our implementation of the parallel code on an Origin 2000 supercomputer are presented and discussed. They exhibit very good speedup behavior and low load unbalancing. Our results confirm that giant gaseous vortices can play a dominant role in giant planet formation.

One-by-One Cleaning for Practical Parallel List Ranking

It is hard to achieve good speed-ups for parallel list ranking on distributed-memory machines because the problem requires a substantial number of communication rounds, each incurring some start-up delay. For input sizes Nthat are very large in comparison with the number of processors Pthese start-up costs can be amortized to a certain extent. For modest N/Pvalues, so far the best approach was the basic pointer-jumping approach. In this paper a novel algorithm, one-by-one cleaning , is presented. It has the unique property that the routing consists of O(P)rounds in which each processing unit (PU) sends a packet to only one other PU. Pointer jumping requires a logarithmic number of rounds in which each PU sends a packet to all other PUs. Because the constants are small, and the internal work performed is less than that of pointer jumping, one-by-one cleaning is about twice as fast, which is demonstrated by comparing the performance of implementations of both algorithms on the Intel Paragon.

OpenMP Programming for a Global Inverse Model

The objective of our investigation is to establish robust inverse algorithms to convert GRACE gravity and ICESat altimetry mission data into global current and past surface mass variations. To assess separation of global sources of change and to evaluate spatio‐temporal resolution and accuracy statistically from full posterior covariance matrices, a high performance version of a global simultaneous grid inverse algorithm is essential. One means to accomplish this is to implement a general, well‐optimized, parallel global model on massively parallel supercomputers. In our present work, an efficient parallel version of a global inverse program has been implemented on the Origin 2000 using the OpenMP programming model. In this paper, porting a sequential global code to a shared‐memory computing system is discussed; several efficient strategies to optimize the code are reported; well‐optimized scientific libraries are used; detailed parallel implementation of the global model is reported; performance data of the code are analyzed. Scaling performance on a shared‐memory system is also discussed. The parallel version software gives good speedup and dramatically reduces total data processing time.

Automatic compilation of loops to exploit operator parallelism on configurable arithmetic logic units

Configurable arithmetic logic units (ALUs) offer opportunities for adapting the underlying hardware to support the varying amount of parallelism in the computation. The problem of identifying the optimal parallel configurations (a configuration is defined as a given hardware implementation of different operators along with their multiplicities) at different steps in a program is a very complex issue but, if solved, allows the power of these ALUs to be maximally used. This paper focuses on developing an automatic compilation framework for configuration analysis to exploit operator parallelism within loop nests. The focus of this work is on performing configuration analysis to minimize costly reconfiguration overheads. In our framework, we initially carry out some operator and loop transformations to expose more opportunities for configuration reuse. We then present a two pass solution. The first pass attempts to generate either maximal cutsets (a cutset is defined as a group of statements that execute under a given configuration) or maximally parallel configurations by performing an analysis on the program dependency graph (PDG) of a loop nest. The second pass analyzes the trade-offs between the costs and benefits of reconfigurations across different cutsets and attempts to eliminate the reconfiguration overheads by merging cutsets. This methodology is implemented in the SUIF compilation system and is tested using some loops extracted from Perfect benchmarks and Livermore kernels. Good speedups are obtained, showing the merit of the proposed method. The method also scales well with the loop sizes and the amount of space available on FPGAs for configurable logic.

Orbital debris impact simulation using a parallel hybrid particle-element code

Simulations of three dimensional orbital debris impact problems, using a parallel hybrid particle-finite element code, show good agreement with experiment and good speedup in parallel computation. The simulations included single and multi-plate shields as well as aluminum and composite shielding materials, at an impact velocity of eleven kilometers per second.

Point‐to‐point and multi‐goal path planning for industrial robots

AbstractThis article presents contributions in the field of path planning for industrial robots with 6 degrees of freedom. This work presents the results of our research in the last 4 years at the Institute for Process Control and Robotics at the University of Karlsruhe. The path planning approach we present works in an implicit and discretized C‐space. Collisions are detected in the Cartesian workspace by a hierarchical distance computation. The method is based on the A* search algorithm and needs no essential off‐line computation. A new optimal discretization method leads to smaller search spaces, thus speeding up the planning. For a further acceleration, the search was parallelized. With a static load distribution good speedups can be achieved. By extending the algorithm to a bidirectional search, the planner is able to automatically select the easier search direction. The new dynamic switching of start and goal leads finally to the multi‐goal path planning, which is able to compute a collision‐free path between a set of goal poses (e.g., spot welding points) while minimizing the total path length. © 2001 John Wiley & Sons, Inc.

Local versus global lookahead in conservative parallel simulations

This paper presents an algorithm, which we refer to as SGTNE, to efficiently obtain lookahead information from a cluster of processors in a parallel simulation in order to unblock (logical) processes (LP) in a given processor. The SGTNE algorithm is based on a TNE conservative synchronization scheme that relies on an independent execution of a shortest path algorithm in individual processors in order to provide lookahead to the resident LPs. Because TNE is executed on individual processors, it is susceptible to inter-processor deadlocks, which must be detected and broken at some cost. SGTNE (Semi-Global TNE) avoids these deadlocks by executing a shortest path algorithm over a snapshot of the LPs in a cluster of processors. An experimental study of SGTNE was conducted on an Intel Paragon A4. The study compared SGTNE to TNE and to an optimized version of Chandy–Misra (CM) null message algorithms. We also investigated several scheduling algorithms for SGTNE and determined factors influencing its performance, most notably the influence of partitioning. Our results indicate that SGTNE provides good speedup relative to the fastest sequential algorithm and that it out-performs TNE for the population level examined, SGTNE was 3–5 times as fast as the CM-algorithm.

Continuous genetic networks

We show how random Boolean networks, a well-known model of the interaction among genes within a living cell, can be generalized by relaxing the Boolean approximation, therefore defining a class of continuous genetic networks, and by explicitly describing gene–chemical interactions. It is also shown that population growth can be modelled by describing in detail the interactions among a limited number of genes, while the effects of the remaining genes are represented by a collective variable. The model can describe specific metabolic systems, as shown by the case of a microorganism able to degrade aromatic compounds, and it can also be used to study the generic properties of genetic networks. For this purpose, theoretical and simulation results are given in the case where all the genes are arranged on a 2-D regular square topology, with connections among neighbouring sites, which represents a cellular-automata like model. Parallel simulation on a MIMD machine shows a good speed-up, thus confirming that these models are amenable to efficient parallel implementation.

Parallel Sequence Mining on Shared-Memory Machines

We present pSPADE, a parallel algorithm for fast discovery of frequent sequences in large databases. pSPADE decomposes the original search space into smaller suffix-based classes. Each class can be solved in main-memory using efficient search techniques and simple join operations. Furthermore, each class can be solved independently on each processor requiring no synchronization. However, dynamic interclass and intraclass load balancing must be exploited to ensure that each processor gets an equal amount of work. Experiments on a 12 processor SGI Origin 2000 shared memory system show good speedup and excellent scaleup results.

PARSIMONY: An Infrastructure for Parallel Multidimensional Analysis and Data Mining

Multidimensional analysis and online analytical processing (OLAP) operations require summary information on multidimensional data sets. Most common are aggregate operations along one or more dimensions of numerical data values. Simultaneous calculation of multidimensional aggregates are provided by the Data Cube operator, used to calculate and store summary information on a number of dimensions. This is computed only partially if the number of dimensions is large. Query processing for these applications requires different views of data to gain insight and for effective decision support. Queries may either be answered from a materialized cube in the data cube or calculated on the fly. The multidimensionality of the underlying problem can be represented both in relational and in multidimensional databases, the latter being a better fit when query performance is the criteria for judgment. Relational databases are scalable in size for OLAP and multidimensional analysis and efforts are on to make their performance acceptable. On the other hand multidimensional databases have proven to provide good performance for such queries, although they are not very scalable. In this article we address (1) scalability in multidimensional systems for OLAP and multidimensional analysis and (2) integration of data mining with the OLAP framework. We describe our system PARSIMONY, parallel and scalable infrastructure for multidimensional online analytical processing, used for both OLAP and data mining. Sparsity of data sets is handled by using chunks to store data either as a dense block using multidimensional arrays or as sparse representation using a bit encoded sparse structure. Chunks provide a multidimensional index structure for efficient dimension oriented data accesses much the same as multidimensional arrays do. Operations within chunks and between chunks are a combination of relational and multidimensional operations depending on whether the chunk is sparse or dense. Further, we develop parallel algorithms for data mining on the multidimensional cube structure for attribute-oriented association rules and decision-tree-based classification. These take advantage of the data organization provided by the multidimensional data model. Performance results for high dimensional data sets on a distributed memory parallel machine (IBM SP-2) show good speedup and scalability.