On the performance of parallel approximate inverse preconditioning using Java multithreading techniques

Abstract

In this paper a parallel shared memory Java multithreaded design and implementation of the explicit approximate inverse preconditioning is presented for solving efficiently arrow-type linear systems on symmetric multiprocessor systems. A new parallel algorithm for computing a class of optimized approximate inverse matrix is introduced. The performance on a symmetric multiprocessor system, using Java multithreading, is investigated by solving characteristic arrow-type linear systems and numerical results are given, considering the parallel performance of the construction of the optimized approximate inverse and the explicit preconditioned generalized conjugate gradient square scheme.

Introduction

Sparse matrix computations, which have inherent parallelism, are of central importance, because of the applicability to real-life problems and are the most time-consuming part in computational science and engineering computations. Hence, research efforts were focused on the production of efficient parallel computational methods and related software suitable for multiprocessor systems.

An important achievement over the last decades is the appearance and use of Explicit Preconditioned Methods, cf. [5], for solving sparse linear systems, and the preconditioned form of a linear system Au = s is MAu = Ms, where M is preconditioner, cf. [5]. The preconditioner M has therefore to satisfy the following conditions: (i) MA should have a “clustered” spectrum, (ii) M can be efficiently computed in parallel and (iii) finally “M × vector” should be fast to compute in parallel, cf. [5].

Explicit Approximate Inverse Preconditioning methods, being composed mainly of linear operations between vectors and matrices, are inherently parallel and their performance when coupled with an efficiently constructed preconditioner M can be relatively easy to replicate across a broad spectrum of hardware and software platforms and languages. However, since constructing an efficient preconditioner M is generally a computationally intensive task on its own, methods for efficiently computing the preconditioner M in parallel have also been the object of research and investigation, usually presenting greater design difficulties than the preconditioned conjugate gradient type methods.

For the development of parallel programs, the scientific computing community predominantly uses parallel extensions to C or FORTRAN, usually via well-established standards such as OpenMP and MPI. While those standards are beyond doubt well-documented, functional and reliable, the targeted languages themselves lack any direct multithreading support at a functions/library level, which is instead provided entirely by third party tools or thread programming models such as POSIX threads. While this is usually not a problem since documentation and standardization is more than sufficient, there are still issues with portability and specific implementations’ issues and peculiarities.

The Java programming language has been designed with built-in multithreading support, providing at least the most basic thread creation and management functionalities in its standard libraries, under most supported platforms. Other points in favour of Java as a generic use programming language are its C-like syntax and relative ease of use, which is generally considered to render software development faster and less error prone, as well as its portable nature. Last but not least, the language’s program execution performance is now generally considered to be comparable with traditional compiled languages, due to advancements in Just-In-Time (JIT) compilation technologies, so that even the once significant performance gap is slowly becoming less of an issue, cf. [1]. Recently research has been focused on subtler performance issues of Java such as data locality, garbage collection and JIT compilation details under modern operating systems, indicating that the language and its actual execution environments are mature enough to start examining performance minutiae instead of macroscopic performance issues, cf. [11].

One of the few, perhaps, issues that still prevent Java from gaining widespread acceptance as a parallel computing tool is the lack of officially defined standards and APIs such as transparent parallel Software Development Kits (SDKs), automatic loop parallelization or message passing, equivalent to OpenMP or MPI. While there have been attempts at constructing Java equivalents, for example the OpenMP-like JOMP, cf. [2], or distributed environment extensions to standard Java, using either MPI-compatible or ad hoc Remote Method Invocation (RMI) interfaces, cf. [13], or even combinations of all of the above, cf. [14], those projects ended up creating API and language divergences, “reinventing the wheel”, and virtually none of them has ever gained sufficient support and acceptance to be considered a well-established standard for Java developers to rely upon. Thus, most parallel programming in Java is still done manually, even though Java’s most recent versions (starting from version 1.5 and above) provide some relatively advanced multithreading tools, partly making up for the lack of a complete and universally accepted parallel SDK for Java.

In Section 2, approximate inverse matrix algorithms in conjunction with the explicit preconditioned generalized conjugate gradient square scheme, for the solution of sparse arrow-type linear systems are presented. In Section 3, a new parallel approximate inverse matrix algorithm for symmetric multiprocessor systems is given. The implementation details of the proposed parallel method, using Java multithreading, are presented in Section 4. Finally, in Section 5 the performance of the parallel approximate inverse matrix techniques and the parallel explicit preconditioned conjugate gradient type method is illustrated by solving characteristic sparse arrow-type linear systems on a symmetric multiprocessor system and numerical results are given.