Request for pointers to books or articles on how to efficiently program Beowulf clusters

[Ed Porter]

What are some good books and good articles on how to write parallel programs to run on Beowulf clusters (particularly relatively large clusters) for a beginner at parallel programming.  My particular interest relates to computations on large semantic networks.

 It would probably be best to start out with some articles which give an overview, since I only know about parallel programming at a very high level of abstraction.

 I am interested in understanding issues such as:

   -how threads are spawned and the costs in terms of time and computational resources of spawning a new instance of a thread,

  -how instances of the same thread communicate to each other or to instances of other threads (how do they know which machines other instance of the same thread may be on, and do they normally communicate through a message queue),

  -how does a process on one node read and write data into memory stored on another node,

  -what control mechanisms are used for allocating computational and memory resources between competing processes,

  -how threads are terminated,

  -is there a mechanism for suspending a thread or computation on a task until data relative to it has been loaded into memory (for example if data from a list of different places has to be examined, can a prefetch be done for the data associated with each different location, and then can a list be kept of which of those different locations have their data in cache ready to be computed upon, so that CPU can keep busy processing the data that has already been loaded while data for other locations is being loaded into cache, 

  -how large collections of data on hard disk are mapped into memory, and how the system knows which portions of the data are resident on the memories of which machines,

  -how 32 bit processors are used to address information on machines having a lot more than 2^32 bytes or words of RAM,

  -how to design parallel programs to run efficiently on Beowulf clusters, 

  -how memory allocation and de-allocation is done,

  -how memory consistency is maintained when multiple processes on different machines are working on the same data, and

  -so on.

 I would be thankful for some good pointers. Particularly to books and/or articles which are good for beginners to parallel programming.  In particular I have not programmed much (the last time I wrote a program of any size was over 12 years ago) and I have never used UNIX.  So it would be particularly helpful if you could find some articles which don’t require deep programming language or UNIX knowledge.

 

Thanks for your help.

 

Ed Porter

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.beowulf.org/pipermail/beowulf/attachments/20010508/bf2b3ca1/attachment.html>