From help-octave-request at bevo dot che dot wisc dot edu Mon Jul 10 16:37:43 2000 Subject: Parallel/cluster/Beowulf From: Christopher Hamilton To: help-octave at bevo dot che dot wisc dot edu Date: Mon, 10 Jul 2000 17:37:34 -0400 (EDT) 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 -----------------------------------------------------------------------