Search

The algorithms in the current sequential numerical linear algebra libraries (e.g. LAPACK) do not parallelize well on multicore architectures. A new family of algorithms, the tile algorithms, has recently been introduced. Previous research has shown that it is possible to write efficient and scalable tile algorithms for performing a Cholesky factorization, a (pseudo) LU factorization, a QR factorization, and computing the inverse of a symmetric positive definite matrix. In this extended abstract, we revisit the computation of the inverse of a symmetric positive definite matrix. We observe that, using a dynamic task scheduler, it is relatively painless to translate existing LAPACK code to obtain a ready-to-be-executed tile algorithm. However we demonstrate that, for some variants, non trivial compiler techniques (array renaming, loop reversal and pipelining) need then to be applied to further increase the parallelism of the application. We present preliminary experimental results. [ABSTRACT FROM AUTHOR]

Sparse direct solvers, and in particular multifrontal methods, are widely used in various simulation problems. Because of their large memory requirements, the use of out-of-core solvers is compulsory for large-scale problems, where disks are used to extend the core memory. This study is at the junction of two previous independent works: it extends the problem of the minimization of the volume of I/O [4] in the multifrontal method to the more general flexible parent allocation algorithm [8]. We explain how to compute the I/O volume with respect to this scheme and propose an efficient greedy heuristic which significantly reduces the I/O volume on real-life problems in this new context. [ABSTRACT FROM AUTHOR]

High performance sparse direct solvers are often a method of choice in various simulation problems. However, they require a large amount of memory compared to iterative methods. In this context, out-of-core solvers must be employed, where disks are used when the storage requirements are too large with respect to the physical memory available. In this paper, we study how to minimize the I/O requirements in the multifrontal method, a particular direct method to solve large-scale problems efficiently. Experiments on large real-life problems also show that the volume of I/O obtained when minimizing the storage requirement can be significantly reduced by applying algorithms designed to reduce the I/O volume. [ABSTRACT FROM AUTHOR]

The memory usage of sparse direct solvers can be the bottleneck to solve large-scale problems. This paper describes a first implementation of an out-of-core extension to a parallel multifrontal solver (MUMPS). We show that larger problems can be solved on limited-memory machines with reasonable performance, and we illustrate the behaviour of our parallel out-of-core factorization. Then we use simulations to discuss how our algorithms can be modified to solve much larger problems. [ABSTRACT FROM AUTHOR]