2
$\begingroup$

A dense matrix is distributed for parallel computation column-wise, then multiplied from left & right by sparse matrices. What would be appropriate c++ libraries for these tasks?

$\endgroup$
5
$\begingroup$

For dense distributed memory linear algebra, you can't do better than Elemental these days. Although, it does not currently handle sparse matrices, I believe. Dense-sparse operations will probably require you to do some custom coding.

$\endgroup$
  • $\begingroup$ ... so the question is still open. $\endgroup$ – user66081 Apr 23 '14 at 15:47
  • 1
    $\begingroup$ You should consider requesting this feature in Elemental. See libelemental.org/help for contact info. $\endgroup$ – Jeff May 5 '14 at 19:15
  • $\begingroup$ I second Jeff's suggestion. To my knowledge, there is no existing library for the exact functionality you described. Elemental is the closest. $\endgroup$ – Victor Liu May 5 '14 at 19:30
  • $\begingroup$ @VictorLiu: I am wondering, what "can't do better" means. Are there supporting benchmarks? $\endgroup$ – user66081 May 6 '14 at 19:19
  • $\begingroup$ "Can't do better" as in this is the closest match to your requirements in terms of features (distributed,dense). It is also probably the fastest such library. $\endgroup$ – Victor Liu May 6 '14 at 19:30
0
$\begingroup$

The ScaLAPACK library is designed for dense matrix operations on distributed memory machines. It will still work on a shared-memory machine though, provided that you have MPI installed (installation requires mpicc and mpif77 compilers on linux). I haven't used it before, so I can't attest to its user-friendliness.

http://www.netlib.org/scalapack/

$\endgroup$
  • 1
    $\begingroup$ ScaLAPACK is not a C++ library. $\endgroup$ – Jeff May 5 '14 at 19:14
0
+50
$\begingroup$

I would day it definitely depends on the parallelization architecture and what you want. If using shared memory CPU's, probably Elemental even though I have not used it. Note that PETSc also has tools for sparse matrices. But if you really need it to go as fast as you can, and the sparse matrices have some known structure that you can take advantage of, then I would write the whole thing using MPI. In my experience that is always much faster, but also requires more work. So it depends on your needs and time to code.

If you want to go with GPU's, nvidia has a sparse matrix library that you could try using CUDA.

CUDA 5 also let's you do some kind of mpi+cuda, so you can have a clusters of gpu's, but I have no idea if the sparse-matrix libraries are capable of that but I don't see why not. It's worth to take a look at. But again, if you need it to fly, I would make my own code.

$\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.