Parallelized reliability estimation of reconfigurable computer networks

A parallelized system, ASSURE, for computing the reliability of embedded avionics flight control systems which are able to reconfigure themselves in the event of failure is described. ASSURE accepts a grammar that describes a reliability semi-Markov state-space. From this it creates a parallel program that simultaneously generates and analyzes the state-space, placing upper and lower bounds on the probability of system failure. ASSURE is implemented on a 32-node Intel iPSC/860, and has achieved high processor efficiencies on real problems. Through a combination of improved algorithms, exploitation of parallelism, and use of an advanced microprocessor architecture, ASSURE has reduced the execution time on substantial problems by a factor of one thousand over previous workstation implementations. Furthermore, ASSURE's parallel execution rate on the iPSC/860 is an order of magnitude faster than its serial execution rate on a Cray-2 supercomputer. While dynamic load balancing is necessary for ASSURE's good performance, it is needed only infrequently; the particular method of load balancing used does not substantially affect performance

A grid-enabled problem solving environment for parallel computational engineering design

This paper describes the development and application of a piece of engineering software that provides a problem solving environment (PSE) capable of launching, and interfacing with, computational jobs executing on remote resources on a computational grid. In particular it is demonstrated how a complex, serial, engineering optimisation code may be efficiently parallelised, grid-enabled and embedded within a PSE. The environment is highly flexible, allowing remote users from different sites to collaborate, and permitting computational tasks to be executed in parallel across multiple grid resources, each of which may be a parallel architecture. A full working prototype has been built and successfully applied to a computationally demanding engineering optimisation problem. This particular problem stems from elastohydrodynamic lubrication and involves optimising the computational model for a lubricant based on the match between simulation results and experimentally observed data

Parallel Implementation of the PHOENIX Generalized Stellar Atmosphere Program

We describe the parallel implementation of our generalized stellar atmosphere and NLTE radiative transfer computer program PHOENIX. We discuss the parallel algorithms we have developed for radiative transfer, spectral line opacity, and NLTE opacity and rate calculations. Our implementation uses a MIMD design based on a relatively small number of MPI library calls. We report the results of test calculations on a number of different parallel computers and discuss the results of scalability tests.Comment: To appear in ApJ, 1997, vol 483. LaTeX, 34 pages, 3 Figures, uses AASTeX macros and styles natbib.sty, and psfig.st

Optimal Reconfiguration of Formation Flying Spacecraft--a Decentralized Approach

This paper introduces a hierarchical, decentralized, and parallelizable method for dealing with optimization problems with many agents. It is theoretically based on a hierarchical optimization theorem that establishes the equivalence of two forms of the problem, and this idea is implemented using DMOC (Discrete Mechanics and Optimal Control). The result is a method that is scalable to certain optimization problems for large numbers of agents, whereas the usual “monolithic” approach can only deal with systems with a rather small number of degrees of freedom. The method is illustrated with the example of deployment of spacecraft, motivated by the Darwin (ESA) and Terrestrial Planet Finder (NASA) missions

TIMEDELN: A programme for the detection and parametrization of overlapping resonances using the time-delay method

TIMEDELn implements the time-delay method of determining resonance parameters from the characteristic Lorentzian form displayed by the largest eigenvalues of the time-delay matrix. TIMEDELn constructs the time-delay matrix from input K-matrices and analyses its eigenvalues. This new version implements multi-resonance fitting and may be run serially or as a high performance parallel code with three levels of parallelism. TIMEDELn takes K-matrices from a scattering calculation, either read from a file or calculated on a dynamically adjusted grid, and calculates the time-delay matrix. This is then diagonalized, with the largest eigenvalue representing the longest time-delay experienced by the scattering particle. A resonance shows up as a characteristic Lorentzian form in the time-delay: the programme searches the time-delay eigenvalues for maxima and traces resonances when they pass through different eigenvalues, separating overlapping resonances. It also performs the fitting of the calculated data to the Lorentzian form and outputs resonance positions and widths. Any remaining overlapping resonances can be fitted jointly. The branching ratios of decay into the open channels can also be found. The programme may be run serially or in parallel with three levels of parallelism. The parallel code modules are abstracted from the main physics code and can be used independently

MRRR-based Eigensolvers for Multi-core Processors and Supercomputers

The real symmetric tridiagonal eigenproblem is of outstanding importance in numerical computations; it arises frequently as part of eigensolvers for standard and generalized dense Hermitian eigenproblems that are based on a reduction to tridiagonal form. For its solution, the algorithm of Multiple Relatively Robust Representations (MRRR or MR3 in short) - introduced in the late 1990s - is among the fastest methods. To compute k eigenpairs of a real n-by-n tridiagonal T, MRRR only requires O(kn) arithmetic operations; in contrast, all the other practical methods require O(k^2 n) or O(n^3) operations in the worst case. This thesis centers around the performance and accuracy of MRRR.Comment: PhD thesi

Parallelizing Timed Petri Net simulations

The possibility of using parallel processing to accelerate the simulation of Timed Petri Nets (TPN's) was studied. It was recognized that complex system development tools often transform system descriptions into TPN's or TPN-like models, which are then simulated to obtain information about system behavior. Viewed this way, it was important that the parallelization of TPN's be as automatic as possible, to admit the possibility of the parallelization being embedded in the system design tool. Later years of the grant were devoted to examining the problem of joint performance and reliability analysis, to explore whether both types of analysis could be accomplished within a single framework. In this final report, the results of our studies are summarized. We believe that the problem of parallelizing TPN's automatically for MIMD architectures has been almost completely solved for a large and important class of problems. Our initial investigations into joint performance/reliability analysis are two-fold; it was shown that Monte Carlo simulation, with importance sampling, offers promise of joint analysis in the context of a single tool, and methods for the parallel simulation of general Continuous Time Markov Chains, a model framework within which joint performance/reliability models can be cast, were developed. However, very much more work is needed to determine the scope and generality of these approaches. The results obtained in our two studies, future directions for this type of work, and a list of publications are included

CP2K - Sparse Linear Algebra on 1000s of cores

CP2K is a freely available atomistic and molecular simulation code, able to study of a wide range of molecular and bulk materials with methods including classical potentials, density functional theory (DFT), Hartree-Fock and post-HF methods. Following two earlier dCSE projects, we report here on an additional 6 months of work to optimisise the DBCSR sparse matrix multiplication library embedded within CP2K. Efficient and scalable sparse matrix operations are shown to benefit existing users of the code by reducing time to solution for typical simulations, and has enabled development of new algorithms including for the fully linear scaling DFT based on density matrix iterations

Inversion of sparse matrices using Monte Carlo methods

A frequent need in many scientific applications is the flexibility to compute some suitable elements of the inverse of well-conditioned, large, sparse, and positive definite matrices. In this research, we have explored some aspects of the inversion of such matrices. For this class of matrices, it has been shown that desired elements of their inverse may be evaluated with desired accuracy via a statistical approach. In this approach, each element of the inverse matrix is decomposed as the sum of two components: a fixed quantity and an expectation of a well defined random variable. This approach works directly with the original matrix W. Thus, it is devoid of the good ordering, fill-ins and choice of critical parameter problems. This approach will always yield positive estimates for variances. In addition, this approach has four attractive advantages. Firstly, it is flexible, that is, a desired entry of the inverse matrix can be evaluated, without computing any other entry. Secondly, it takes advantage of the sparsity of the matrix. Thirdly, it computes the exact value for some entries. And finally, it is easily parallelizable, which provides gains inefficiency and computing time;The expectation in the above decomposition may be computed using either the ordinary Importance Sampling technique or the Adaptive Importance Sampling;For moderate dimension of the matrix the ordinary importance sampling yields reasonable results when the importance sampler is the MVt3 with a diagonal covariance matrix;The A.I.S. may be started with three different covariance matrices. In general, A.I.S. provides \u27better\u27 results than the ordinary importance sampling and requires fewer iterations;Using an efficient sparse storage scheme, we have explored the implementation of this approach under a distributed system with PVM as a message passing protocol and under a shared memory environment using a 4 processor share memory machine. The method yields reasonable results under both environment