dsyev eigenvalue solver

[nchilton]

Hi,

PLASMA only uses Pthreads.
No MPI.

Then are you really using single systems with 96 cores? Most we have is two 32 core boxes, but I most commonly use an 8 core box.

Can you post the result of the following command on your system, please ?
pkg-config --libs hwloc

no hwloc package I'm afraid.

also what value to you give to PLASMA_Init ?

This was the variable I was changing, 1, 2, 4, 6, 8, 10, 12, 14 or 16 cores.

It makes sense when I realized the '16 cores' was only hyper threading. If I get a chance I'll test with more cores on a bigger box!

Cheers!

[admin]

No, of course we're not running on 96 cores. We just made it up.
Yes, we are.
We ran PLASMA on as many as 1000 cores on the Nautilius machine at NICS
(http://www.nics.tennessee.edu/computing ... s/nautilus).
PLASMA SC'11 flier show the performance numbers
(http://icl.cs.utk.edu/graphics/posters/ ... PLASMA.pdf).
Jakub

[nchilton]

Awesome system, wish I had one of those to play with!

I was wondering if anyone had any advice on running multiple threads with their own instances of PLASMA? I'm using OpenMP in Fortran and have made everything that I need threadprivate, including the T pointer, but I'm getting the following errors:

PLASMA ERROR: plasma_desc_mat_alloc(): malloc() failed
PLASMA ERROR: plasma_alloc_ibnb_tile(): malloc() failed
PLASMA ERROR: plasma_desc_check(): NULL matrix pointer
PLASMA ERROR: PLASMA_dsyev(): invalid T descriptor

Any ideas?

[nchilton]

bump?

[nick.chepurniy]

I have large matrices (order 10,000 and much higher), and would like to get the eigenvalues (and eigenvectors when PLASMA will update). As matrices get larger (beyond order 1000) the Cholesky algorithm fails because sqrt gets negative arguments. I need Multiple-precision. Is it possible to have multiple-precision with PLASMA since double precision is not enough ? What changes would I need to make to get multiple-precision variables ?

Nick

[admin]

You are asking for extended precision, i.e. higher than double, e.g. quadruple, right?
There is no support in PLASMA for that right now.
It requires an orchestrated effort to populate PLASMA with such support.
Nothing we can do for you any time soon.
Jakub

[nick.chepurniy]

Thanks Jakub.

I understand that this cannot be done by your team, but I am trying to find out how hard
would it be for me to do it by myself. So since you know the code my questions is:

Do you think an ordinary user might be able to look at the PLASMA source code and make
appropriate changes or is that something that you think might be too difficult to undertake ?

There are two ways to go forward:

(A) Simple extension:
Extended precision can be easily handled by some compiler, e.g. intel has quad precision.
This requires that all variables declared as real*8 be redefined as real*16 and the compiler
handles everything else. This depends on the compiler and cannot go beyond real*16

(B) Arbitrary extension
Multiple precision packages use an arrays, so we could associate with a variable a real*8 array A(4)
or A(6) and use a package to do all the calculations. Very time consuming but yields higher precision
and runs much slower. I was thinking of using MPFUN90:

MPFUN90 is a Fortran-90 arbitrary precision package similar to the ARPREC package, except its developed
exclusively in Fortran-90. The library is written by David H. Bailey et. al from the Lawrence Berkeley
National Laboratory.

[admin]

I don't know of any optimized BLAS library that supports extended precision.
Everything else in the PLASMA software stack can be built from sources,
but if you don't provide fast BLAS, you are not going to get the performance benefit.
This may be a little different for the eigenvalue codes, which depend on BLAS less than other codes,
but in principle this is the story.
That being said, you can try to build PLASMA, and all its software dependencies, using compiler flags for quadruple precision.
That would include compiling Netlib BLAS from sources.
It has never been tried (for PLASMA), but no guts no glory

This is what I would do:
Use PLASMA installer with the --downall option.
This will make sure that all components are built from sources, after downloading from Netlib.
Also, use the --cc option to make sure you are using the Intel compiler,
and use the --ccflags and --fcflags options to compile with extended precision.
The installer should apply those options throughout all software components.
Keep saying Hail Marry throughout the process
Again, this has never been tried, but if you are brave enough, give it a shot.

If this succeeds, you are going to get extended precision LAPACK as a byproduct.
You can compare the performance of LAPACK eigensolver with PLASMA eigensolver.
That would be an interesting experiment.
Let us know how it goes.
Good luck,
Jakub