1
$\begingroup$

I have searched through the archives without success. Apparently, the question is simple:

What linear algebra library can I use that is parallel (shared memory) but without OpenMP?

As far as I've seen, OpenMP seems a requirement. Since I need to interact with colleagues using a Mac, I cannot opt for OpenMP (no, I cannot ask them to compile gcc). The usage would be a classic FEM, so matrices, vectors, and decompositions (or some kind of parallel linear solver).

Intel's TBB is ok, of course, pthreads are good, standard C++ std::thread would be the perfection. But I'm not looking for perfection :)

Thanks!

$\endgroup$
  • $\begingroup$ Is the threading in the apple BLAS implementation sufficient for your purposes? $\endgroup$ – origimbo May 31 '16 at 16:21
  • $\begingroup$ As far as I remember it doesn't have solvers. $\endgroup$ – senseiwa May 31 '16 at 16:23
  • $\begingroup$ As I recall, you get the usual LAPACK suite, so basically LU. $\endgroup$ – origimbo May 31 '16 at 16:33
  • $\begingroup$ Recent versions of clang (3.8.0) do support OpenMP, but I don't think they've made it into Xcode yet, so at least there is some way to get OpenMP on osx without installing gcc. $\endgroup$ – Kirill May 31 '16 at 20:20
  • $\begingroup$ How large are the FE problems you are planning to solve? As you may already know, for large models, the decomposition of the global matrix tends to dominate the computational cost. $\endgroup$ – Bill Greene May 31 '16 at 21:04
3
$\begingroup$

For the relatively large problems you are targeting, I suggest you focus on the sparse matrix solver because that's where you'll get the biggest benefit from parallelism.

From the comments it wasn't clear if you had access to a high-quality multi-threaded BLAS library on all your target platforms.

If you do, and are also able to compile FORTRAN code, the MUMPS solver is in my opinion the best free sparse solver for FE applications.

http://mumps.enseeiht.fr/

It is actually designed for distributed memory parallelism (MPI) but it does an amazingly-good job with just a multi-threaded BLAS on multicore machines. It also has an out-of-core option which is very useful for solving large problems on desktop machines with limited memory.

A second option is SPOOLES.

http://www.netlib.org/linalg/spooles/spooles.2.2.html

It is an older sparse solver, not quite at the state of the art, but it can be built with pthreads and it is written entirely in C.

Finally, a third option is PaStiX.

http://pastix.gforge.inria.fr/files/README-txt.html

I haven't actually tried it, myself, so can't comment further except to say that it, too, supports pthreads.

$\endgroup$
  • $\begingroup$ Thanks, @Bill. Do you have any pointers for "pseudo-sparse" matrices, aka, banded, triangular, symmetric, ..., the standard ones used also in LAPACK. Not managing memory layout would be definitely a plus. $\endgroup$ – senseiwa Jun 3 '16 at 13:49
  • 2
    $\begingroup$ General sparse solvers have largely replaced banded and even variable-band (profile) solvers for all but academic FE applications. So I would not recommend going in that direction. $\endgroup$ – Bill Greene Jun 3 '16 at 14:50

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.