Parallel/cluster/Beowulf

[Christopher Hamilton]

I just see people like me posing random questions about this, and I have
done some more thinking. So I thought I would update you all on my
ideas, since I am trying to figure out a plan.  Here is my one big
question, how modified is the included LAPACK and how easy would it be to
just have Octave build off another version?  

My plan has been modified slightly. I have looked into how ATLAS, LAPACK,
and ScaLAPACK build libraries. I also know that ScaLAPACK has other tools
and functions specific to prepping of matrices. Would anybody care for a
version that just included all of these extra parallel functions open
along with the normal functions? I think this would be a good first step,
and might be relatively easy. It would also take some load off of my
learning curve.

The next step the heuristic threshold from single processor to message
passing will take more thought. It was originally only really one matrix
operation size variable. However, this is a very weak implementation. 
The initial variable would only control scatter, this left gather as a
cleanup at the next function call. 

Gather should have a threshold as well and this one is much more
tricky. It should know relative costs in the program. For my purpose I
define implicit parallel calls as ones that reach scatter threshold,
explicit are functions called in parallel form, possible parallel calls
are non explicit calls that could be parallel but do not reach threshold,
non-parallel calls are calls that have no parallel implementation, and
quasi-parallel calls are calls that are level 1 or 2, but have an
equivalent 3 that is parallel.

Gather threshold properties:
 It would have to be forced when the next call on the data is
non-parallel. 

 It should know whether it costs more to gather for a quasi-parallel call
then scatter for the next explicit, or to just implement the
quasi-parallel call in a parallel way. Most of this could be done by
implementing a Level(1or2) call by a parallel Level 3. This would have to
be decided by parsing the next calls and determining if all of the next
calls could be parallelized before the next explicit or implicit parallel
call. If there is a non-parallel call in between it should gather now.
This kind of parsing is out of my league.

If I am wrong in my understanding of the blas based libraries please let
me know. I may be confused. I am definitely tired.

Answers, comments?

Chris Hamilton



-----------------------------------------------------------------------
Octave is freely available under the terms of the GNU GPL.

Octave's home on the web:  http://www.che.wisc.edu/octave/octave.html
How to fund new projects:  http://www.che.wisc.edu/octave/funding.html
Subscription information:  http://www.che.wisc.edu/octave/archive.html
-----------------------------------------------------------------------