Parallel Linear Algebra Library Research Articles

Bethe–Salpeter equation for absorption and scattering spectroscopy: implementation in the exciting code

The Bethe–Salpeter equation for the electron–hole correlation function is the state-of-the-art formalism for optical and core spectroscopy in condensed matter. Solutions of this equation yield the full dielectric response, including both the absorption and the inelastic scattering spectra. Here, we present an efficient implementation within the all-electron full-potential code exciting, which employs the linearized augmented plane-wave (L)APW+LO basis set. Being an all-electron code, exciting allows the calculation of optical and core excitations on the same footing. The implementation fully includes the effects of finite momentum transfer which may occur in inelastic x-ray spectroscopy and electron energy-loss spectroscopy. Our implementation does not require the application of the Tamm–Dancoff approximation that is commonly employed in the determination of absorption spectra in condensed matter. The interface with parallel linear-algebra libraries enables the calculation for complex systems. The capability of our implementation to compute, analyze, and interpret the results of different spectroscopic techniques is demonstrated by selected examples of prototypical inorganic and organic semiconductors and insulators.

On Improving Computational Efficiency of Simplified Fluid Flow Models

Single-core computational efficiency of several iterative methods for numerical solution of nonsymmetric linear systems originating from simplified fluid flow models is evaluated together with different preconditioning techniques in terms of solution behaviour and the overall rate of convergence. A previously developed simplified 3D CFD model, which involves the solution of linear systems of orders usually from units to tens of thousands, is used to generate test cases. The respective Java software application employs the Parallel Colt linear algebra library. This is to ensure that the corresponding sparse matrix computations needed in different solution and preconditioning methods are carried out in as efficient a manner as possible to minimize the influence of the computer implementation itself. Measures (warm-up phase etc.) are taken to eliminate the effects of JVM specific behaviour such as JIT compilation.

A parallel solver for huge dense linear systems

HDSS (Huge Dense Linear System Solver) is a Fortran Application Programming Interface (API) to facilitate the parallel solution of very large dense systems to scientists and engineers. The API makes use of parallelism to yield an efficient solution of the systems on a wide range of parallel platforms, from clusters of processors to massively parallel multiprocessors. It exploits out-of-core strategies to leverage the secondary memory in order to solve huge linear systems O ( 100.000 ) . The API is based on the parallel linear algebra library PLAPACK, and on its Out-Of-Core (OOC) extension POOCLAPACK. Both PLAPACK and POOCLAPACK use the Message Passing Interface (MPI) as the communication layer and BLAS to perform the local matrix operations. The API provides a friendly interface to the users, hiding almost all the technical aspects related to the parallel execution of the code and the use of the secondary memory to solve the systems. In particular, the API can automatically select the best way to store and solve the systems, depending of the dimension of the system, the number of processes and the main memory of the platform. Experimental results on several parallel platforms report high performance, reaching more than 1 TFLOP with 64 cores to solve a system with more than 200 000 equations and more than 10 000 right-hand side vectors. New version program summary Program title: Huge Dense System Solver (HDSS) Catalogue identifier: AEHU_v1_1 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEHU_v1_1.html Program obtainable from: CPC Program Library, Queenʼs University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 87 062 No. of bytes in distributed program, including test data, etc.: 1 069 110 Distribution format: tar.gz Programming language: Fortran90, C Computer: Parallel architectures: multiprocessors, computer clusters Operating system: Linux/Unix Has the code been vectorized or parallelized?: Yes, includes MPI primitives. RAM: Tested for up to 190 GB Classification: 6.5 External routines: MPI ( http://www.mpi-forum.org/), BLAS ( http://www.netlib.org/blas/), PLAPACK ( http://www.cs.utexas.edu/~plapack/), POOCLAPACK ( ftp://ftp.cs.utexas.edu/pub/rvdg/PLAPACK/pooclapack.ps) (code for PLAPACK and POOCLAPACK is included in the distribution). Catalogue identifier of previous version: AEHU_v1_0 Journal reference of previous version: Comput. Phys. Comm. 182 (2011) 533 Does the new version supersede the previous version?: Yes Nature of problem: Huge scale dense systems of linear equations, A x = B , beyond standard LAPACK capabilities. Solution method: The linear systems are solved by means of parallelized routines based on the LU factorization, using efficient secondary storage algorithms when the available main memory is insufficient. Reasons for new version: In many applications we need to guarantee a high accuracy in the solution of very large linear systems and we can do it by using double-precision arithmetic. Summary of revisions: Version 1.1 • Can be used to solve linear systems using double-precision arithmetic. • New version of the initialization routine. The user can choose the kind of arithmetic and the values of several parameters of the environment. Running time: About 5 hours to solve a system with more than 200 000 equations and more than 10 000 right-hand side vectors using double-precision arithmetic on an eight-node commodity cluster with a total of 64 Intel cores.

Large-scale linear system solver using secondary storage: Self-energy in hybrid nanostructures

We present a Fortran library which can be used to solve large-scale dense linear systems, A x = b . The library is based on the LU decomposition included in the parallel linear algebra library PLAPACK and on its out-of-core extension POOCLAPACK. The library is complemented with a code which calculates the self-polarization charges and self-energy potential of axially symmetric nanostructures, following an induced charge computation method. Illustrative calculations are provided for hybrid semiconductor–quasi-metal zero-dimensional nanostructures. In these systems, the numerical integration of the self-polarization equations requires using a very fine mesh. This translates into very large and dense linear systems, which we solve for ranks up to 3 × 10 5 . It is shown that the self-energy potential on the semiconductor–metal interface has important effects on the electronic wavefunction. Program summary Program title: HDSS (Huge Dense System Solver) Catalogue identifier: AEHU_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEHU_v1_0.html Program obtainable from: CPC Program Library, Queen's University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 98 889 No. of bytes in distributed program, including test data, etc.: 1 009 622 Distribution format: tar.gz Programming language: Fortran 90, C Computer: Parallel architectures: multiprocessors, computer clusters Operating system: Linux/Unix Has the code been vectorized or parallelized?: Yes. 4 processors used in the sample tests; tested from 1 to 288 processors RAM: 2 GB for the sample tests; tested for up to 80 GB Classification: 7.3 External routines: MPI, BLAS, PLAPACK, POOCLAPACK. PLAPACK and POOCLAPACK are included in the distribution file. Nature of problem: Huge scale dense systems of linear equations, A x = B , beyond standard LAPACK capabilities. Application to calculations of self-energy potential in dielectrically mismatched semiconductor quantum dots. Solution method: The linear systems are solved by means of parallelized routines based on the LU factorization, using efficient secondary storage algorithms when the available main memory is insufficient. The self-energy solver relies on an induced charge computation method. The differential equation is discretized to yield linear systems of equations, which we then solve by calling the HDSS library. Restrictions: Simple precision. For the self-energy solver, axially symmetric systems must be considered. Running time: About 32 minutes to solve a system with approximately 100 000 equations and more than 6000 right-hand side vectors using a four-node commodity cluster with a total of 32 Intel cores.

Interfaces for parallel numerical linear algebra libraries in high level languages

In many high performance engineering and scientific applications there is a need to use parallel software libraries. Researchers behind these applications find it difficult to understand the interfaces to these libraries because they carry arguments that are related to the parallel environment and performance in addition to arguments related to the problem at hand. In this paper we introduce the use of high level user interfaces for ScaLAPACK. Concretely, a Python-based interface to ScaLAPACK is proposed. Numerical experiments comparing traditional programming practices with our proposed approach are presented. These experiments evaluate not only the performance of the Python interfaces but also how user friendlier they are, compared to the original calls, and show that PyScaLAPACK does not hinder the performance deliverance of ScaLAPACK. Finally, an example of a real scientific application code, whose functionality can be prototyped or extended with the use of PyScaLAPACK, is presented.

A parallel Broyden approach to the Toeplitz inverse eigenproblem

AbstractIn this work we show a portable sequential and a portable parallel algorithm for solving the inverse eigenproblem for real symmetric Toeplitz matrices. Both algorithms are based on Broyden's method for solving nonlinear systems. We reduced the computational cost for some problem sizes, and furthermore we managed to reduce spatial cost considerably, compared in both cases with parallel algorithms proposed by other authors and by us, although sometimes quasi‐Newton methods (as Broyden) do not reach convergence in all the test cases. We have implemented the parallel algorithm using the parallel numerical linear algebra library SCALAPACK based on the MPI environment. Experimental results have been obtained using two different architectures: a shared memory multiprocessor, the SGI PowerChallenge, and a cluster of Pentium II PCs connected through a myrinet network. The algorithms obtained are scalable in all the cases. Copyright © 2004 John Wiley & Sons, Ltd.

PlapackJava: Towards an efficient Java interface for high performance parallel linear algebra

Java is gaining acceptance as a language for high performance computing, as it is platform independent and safe. A parallel linear algebra package is fundamental for developing parallel numerical applications. In this paper, we present plapackJava, a Java interface to PLAPACK, a parallel linear algebra library. This interface is simple to use and object-oriented, with good support for initialization of distributed objects. The experiments we have performed indicate that plapackJava does not introduce a significant overhead with respect to PLAPACK.

An annotation language for optimizing software libraries

This paper introduces an annotation language and a compiler that together can customize a library implementation for specific application needs. Our approach is distinguished by its ability to exploit high level, domain-specific information in the customization process. In particular, the annotations provide semantic information that enables our compiler to analyze and optimize library operations as if they were primitives of a domain-specific language. Thus, our approach yields many of the performance benefits of domain-specific languages, without the effort of developing a new compiler for each domain. This paper presents the annotation language, describes its role in optimization, and illustrates the benefits of the overall approach. Using a partially implemented compiler, we show how our system can significantly improve the performance of two applications written using the PLAPACK parallel linear algebra library.

Design of a parallel linear algebra library for verified computation

In this paper we discuss design principles to implement a set of linear algebra subroutines in a portable libraty for parallel computers. Our design supports reuse of code and easy adaption to new parallel programming paradigms or network configurations.

A reliable linear algebra library for transputer networks

This paper presents a collection of linear algebra subroutines for transputer networks. The developed pilot library is intended to form a basis of a complete parallel linear algebra library for validating computations, whose routines will deliver (as accurately as necessary) either the best possible result, or a corresponding inclusion based on controlled rounding and an optimal scalar product.

Solving the least squares problem using a parallel linear algebra library

One of the important issues in the construction of a parallel Linear Algebra library is the choice of the process structure. The structure that is presented in this article allows for simple functional specifications of the processes and for their compositionality. Each functional specification describes the meaning of the parallel composition of a number of instances of a single process. The communication behaviours of the instances of a process do not occur in its specification. In such a specification, matrices and vectors occur as ordinary mathematical variables. The representations of the matrices and vectors are distributed across the process instances. All library processes conform to the same communication conventions. The library processes can be composed sequentially, without requiring global synchronisation between process calls. As an example, the parallel solution of the least squares problem is discussed.