2
$\begingroup$

I am looking for libraries for solving large scale linear system (10e5) of equations using parallelization and shared memory. 1. Sparse, complex symmetric, SPD. 2. Suitable for higher order FEM ,DGFEM using Domain decomposition. 3. Suitable for iterative solvers with built in preconditioners. 4. Suitable for C++ and/or MATLAB. OS preferred- Ubuntu. Intel compiler. ( Paradiso does not support intel Mkl)

$\endgroup$
  • 4
    $\begingroup$ How large is large? Are there any other properties of the matrices, i.e. sparse, SPD, etc. $\endgroup$ – Steve Aug 22 '17 at 8:34
  • $\begingroup$ You might also want to note that unless things have changed recently, most of PETSc is geared towards a distributed memory model, qv. mcs.anl.gov/petsc/miscellaneous/petscthreads.html $\endgroup$ – origimbo Aug 22 '17 at 10:25
  • $\begingroup$ Are your matrices sparse or dense ? $\endgroup$ – BrunoLevy Aug 23 '17 at 15:26
  • 1
    $\begingroup$ Sparse, SPD, complex symmetric, DOF's are usually in the range of 1e5 $\endgroup$ – Bullet Aug 24 '17 at 7:41
  • 2
    $\begingroup$ In fact, a version of Pardiso is supplied with the MKL. So, if you are already using MKL, that would probably be the best solution for you. $\endgroup$ – Bill Greene Aug 26 '17 at 20:00
0
$\begingroup$

Eigen does not use parallelism for solving linear systems (see comment in http://eigen.tuxfamily.org/index.php?title=FAQ#How_does_Eigen_compare_to_BLAS.2FLAPACK.3F ).

Trilinos provides different linear solvers (direct, preconditioners, iterative).

Pardiso and MUMPS are other direct solvers that can run in parallel.

$\endgroup$
  • $\begingroup$ I would add PETSC to that list. Both PETSC (in C) and Trilinos (in C++) provide a large array of direct and iterative (Krylov, etc.) linear solver for large sparse matrices in a distributed memory environment. Both libraries are at the top of their game IMO... $\endgroup$ – BlaB Aug 24 '17 at 12:59
1
$\begingroup$

For dense linear algebra, the LAPACK and BLAS libraries are nearly always the way to go. There are a number of C++ packages that interface to LAPACK and BLAS.

$\endgroup$
1
$\begingroup$

Some other packages in this space that might be of use:

UMFPACK: unsymmetric multifrontal method, sequential but robust

SuperLU: supernodal sparse LU, has parallel variants (both sharedmem and distmem)

TAUCS: sharedmem parallel multifrontal, can exploit complex-symmetry (I think)

MyraMath: sharedmem parallel multifrontal, can exploit complex-symmetry, has some interesting algorithms to support substructuring/DDM (disclaimer: I authored this one)

In my experience, PARDISO is generally the fastest.

$\endgroup$
  • $\begingroup$ In my experience, SuperLU performs very poorly and I would not recommend it. $\endgroup$ – cfh Aug 29 '17 at 10:46
1
$\begingroup$

This page offers comparisons between various linear solvers http://www.netlib.org/utk/people/JackDongarra/la-sw.html

For a distributed, C++ based solver which can handle SPD specifically for sparse matrices along with built-in preconditioning, I would strongly recommend Elemental

$\endgroup$
0
$\begingroup$

For sparse systems, you can use my own library OpenNL: https://gforge.inria.fr/frs/?group_id=1252

It has no dependency, simple API for matrix assembly, it is parallel, works also on the GPU. It has built-in iterative algorithms (CG, preCG, BiCG, GMRES) and supports sparse direct solvers (SuperLU, CHOLMOD) with a plugin.

Documentation of OpenNL: http://alice.loria.fr/software/geogram/doc/html/nl_8h.html#details

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.