A performance study of normalized explicit finite element approximate inverse preconditioning on uniprocessor and multicomputer systems

A new class of normalized explicit approximate inverse matrix techniques, based on normalized approximate factorization procedures, for solving sparse linear systems resulting from the finite difference discretization of partial differential equations in three space variables are introduced. A new parallel normalized explicit preconditioned conjugate gradient square method in conjunction with normalized approximate inverse matrix techniques for solving efficiently sparse linear systems on distributed memory systems, using Message Passing Interface (MPI) communication library, is also presented along with theoretical estimates on speedups and efficiency. The implementation and performance on a distributed memory MIMD machine, using Message Passing Interface (MPI) is also investigated. Applications on characteristic initial/boundary value problems in three dimensions are discussed and numerical results are given.

High performance finite element approximate inverse preconditioning

During the last decades, research efforts have been focused on the derivation of effective preconditioned iterative methods. The preconditioned iterative methods are mainly categorized into implicit preconditioned methods and explicit preconditioned methods. In this manuscript we review implicit preconditioned methods, based on incomplete and approximate factorization, and explicit preconditioned methods, based on sparse approximate inverses and explicit approximate inverses. Modified Moore-Penrose conditions are presented and theoretical estimates for the sensitivity of the explicit approximate inverse matrix of the explicit preconditioned method are derived. Finally, the performance of the preconditioned iterative methods is illustrated by solving characteristic 2D elliptic problem and numerical results are given indicating a qualitative agreement with the theoretical estimates.

A new class of Java multithreading based parallel approximate inverse preconditioning is introduced, for efficiently solving sparse arrow-type linear systems. The Parallel Explicit Preconditioned Biconjugate Conjugate Gradient - STAB method for shared memory systems is presented in order to examine the parallel behavior of this scheme using explicit approximate inverses as the suitable preconditioner. Design and implementation issues of Java's multithreading techniques are also discussed. The performance in terms of speedups and parallel efficiencies of the method, using Java multithreading, is illustrated by solving sparse arrow-type linear systems. Static and dynamic workload scheduling systems implemented in Java and the results of their use are presented and discussed.

A new parallel normalized optimized approximate inverse algorithm, based on the concept of antidiagonal wave pattern, for computing classes of explicitly approximate inverses, is introduced for symmetric multiprocessor systems. The parallel normalized explicit approximate inverses are used in conjunction with parallel normalized explicit preconditioned conjugate gradient schemes for the efficient solution of finite element sparse linear systems. The parallel design and implementation issues of the new algorithm are discussed and the parallel performance is presented using OpenMP. Copyright © 2008 John Wiley & Sons, Ltd.

The Complex neuronal network models require support from simulation environment for efficient network simulations. To compute the models increasing complexity necessitated the efforts to parallelize the NEURON simulation environment. The computational neuroscientists have extended NEURON by dividing the equations for its subnet among multiple processors for increasing the competence of hardware. For spiking neuronal networks inter-processor spikes exchange consume significant portion of overall simulation time on parallel machines. In NEURON Message Passing Interface (MPI) is used for inter processor spikes exchange, MPI_Allgather collective operation is used for spikes exchange generated after each interval across distributed memory systems. However, as the number of processors become larger and larger MPI_Allgather method become bottleneck and needs efficient exchange method to reduce the spike exchange time. This work has improved MPI_Allgather method to Remote Memory Access (RMA) based on MPI-3.0 for NEURON simulation environment, MPI based on RMA provides significant advantages through increased communication concurrency in consequence enhances efficiency of NEURON and scaling the overall run time for the simulation of large network models.1

Confronted with uncertainties, especially from large amounts of renewable energy sources, power flow studies need further analysis to cover the range of voltage magnitude and transferred power. To address this issue, this work proposes a novel interval power flow for the radial network by the use of an extended, simplified DistFlow formulation, which can be transformed into a set of interval linear equations. Furthermore, the Krawczyk iteration method, including an approximate inverse preconditioner using Frobenius norm minimisation, is employed to solve this problem. The approximate inverse preconditioner guarantees the convergence of the iterative method and has the potential for parallel implementation. In addition, to avoid generating a dense approximate inverse matrix in the preconditioning step, a dropping strategy is introduced to perform a sparse representation, which can significantly reduce the memory requirement and ease the matrix operation burden. The proposed methods are demonstrated on 33‐bus, 69‐bus, 123‐bus, and several large systems. A comparison with interval LU decomposition, interval Gauss elimination method, and Monte Carlo simulation verifies its effectiveness.

An approximate inverse preconditioner and its implementation for conjugate gradient method

As distributed memory systems have become common, the de facto standard for communication is still the Message Passing Interface (MPI). pupyMPI is a pure Python implementation of a broad subset of the MPI 1.3 specifications that allows Python programmers to utilize multiple CPUs with datatypes and memory handled transparently. pupyMPI also implements a few non-standard extensions such as non-blocking collectives and the option of suspending, migrating and resuming the distributed computation of a pupyMPI program. This paper introduces pupyMPI and presents benchmarks against C implementations of MPI, which show acceptable performance.

New parallel computational techniques are introduced for the parallelization of explicit finite difference approximate inverse methods, using higher order approximation schemes, based on Portable Operating System Interface for UniX (POSIX) Threads, for multicore systems. Parallelization of the Optimized Banded Generalized Approximate Inverse Finite Element Matrix algorithm is achieved based on the concept of the fish bone approach with the use of a thread pool pattern. Theoretical estimates on speedups and efficiency are also presented. Finally, numerical results for the performance of the POBGAIFEM algorithm as well as the loop level and functional level parallelized Explicit Preconditioned Bi-conjugate Gradient Gradient-STAB method for solving two dimensional boundary value problems on multicore computer systems are presented.

A new class of explicit preconditioning methods based on the concept of sparse approximate factorization procedures and inverse matrix techniques is introduced for solving biharmonic equations. Isomorphic methods in conunction with explicit preconditioned schemes based on approximate inverse matrix techniques are presented for the efficient solution of biharmonic equations. Application of the proposed method on linear systems is discussed and numerical results are given.

Partitioned Global Address Space (PGAS) parallel programming models can provide an efficient mechanism for managing shared data stored across multiple nodes in a distributed memory system. However, these models are traditionally directly addressed and, for applications with loosely-structured or sparse data, determining the location of a given data element within a PGAS can incur significant overheads. Applications incur additional overhead from the network latency of lookups from remote location resolution structures. Further, for large data, caching such structures locally incurs space and coherence overheads that can limit scaling. We observe that the matching structures used by implementations of the Message Passing Interface (MPI) establish a separation between incoming data writes and the location where data will be stored. In this work, we investigate extending such structures to add a layer of indirection between incoming data reads and the location from which data will be read, effectively extending PGAS models with logical addressing.

Message passing interface (MPI) is the de facto standard in writing parallel scientific applications on distributed memory systems. Performance prediction of MPI programs on current or future parallel systems can help to find system bottleneck or optimize programs. To effectively analyze and predict performance of a large and complex MPI program, an efficient and accurate communication model is highly needed. A series of communication models have been proposed, such as the LogP model family, which assume that the sending overhead, message transmission, and receiving overhead of a communication is not overlapped and there is a maximum overlap degree between computation and communication. However, this assumption does not always hold for MPI programs because either sending or receiving overhead introduced by MPI implementations can decrease potential overlap for large messages. In this paper, we present a new communication model, named LogGPO, which captures the potential overlap between computation with communication of MPI programs. We design and implement a trace-driven simulator to verify the LogGPO model by predicting performance of point-to-point communication and two real applications CG and Sweep3D. The average prediction errors of LogGPO model are 2.4% and 2.0% for these two applications respectively, while the average prediction errors of LogGP model are 38.3% and 9.1% respectively.

The 64-bit OS provides ample memory address space that is beneficial for applications using a large amount of data. This paper proposes using a cluster as a memory resource for sequential applications requiring a large amount of memory. This system is an extension of our previously proposed socket-based distributed large memory system (DLM), which offers large virtual memory by using remote memory distributed over nodes in a cluster. The newly designed DLM is based on MPI (message passing interface) to exploit higher portability. MPI-based DLM provides fast and large virtual memory on widely available open clusters managed with an MPI batch queuing system. To access this remote memory, we rely on swap protocols adequate for MPI thread support levels. In experiments, we confirmed that it achieves 493 MB/s and 613 MB/s of remote memory bandwidth with the STREAM benchmark on 2.5 GB/s and 5 GB/s links (Myri-10G x2, x4) and high performance of applications with NPB and Himeno benchmarks. Additionally, this system enables users unfamiliar with parallel programming to use a cluster.

Multicomputers are distributed memory systems in which independent computers are connected with each other by a network. Multicomputers are widely used in business and scientific applications. Due to their flexibility, scalability, and cost performance, multicomputer systems are considered preferable to multiprocessor systems. They are also gaining attraction in the area of Internet-based computing, in which delays or interruptions in client—server interactions may be equally costly to service providers and customers. Multicomputer systems attributed with high available (HA) solutions may be used to with stand service unavailability due to the web servers' failures. In this paper we investigate a Markov model-based approach to estimate the availability of multicomputer systems with and without HA. The availability is computed as a function of server failure rate and the number of surviving servers. This model can estimate the number of nodes needed for a required availability measure.