Title: COMP309/509 - Lecture 14 class: middle, center, inverse

COMP309/509 - Parallel and Distributed Computing

Lecture 14 - Programming with PVM

By Mitchell Welch

University of New England

Reading

• The Introduction and Basic Programming Techniques from PVM: Parallel Virtual Machine A Users' Guide and Tutorial for Networked Parallel Computing

Summary

• Message Passing in PVM
• Master-Slave in PVM

Message Passing in PVM

• Lets have a look at a couple of example PVM programs.
• Before we try to do a real live industrial strength one.
• Multiplying matices on a torus (i.e a doughnut) Then we’ll cover MPI.

Message Passing in PVM

• The PVM model guarantees the following about message order:
  • If task 1 sends message A to task 2.
    • Then task 1 sends message B to task 2.
    • Message A will arrive at task 2 before message B.
    • Moreover, if both messages arrive before task 2 does a receive, then a wildcard receive will always return message A.
• Notice this says nothing about the order of messages sent to task 2 from separate tasks!!
• Terminating a PVM task immediately after sending a message or messages from it may result in those messages being lost.
• To be sure, always call pvm_exit() before stopping.

Message Passing in PVM

• Before a task starts sending messages it should first call pvm_initsend.
• This is to:
  • Initialize and or clear the send buffer of the task.
  • Specify the encoding to be used in the transmission of the message.
• It needs to be done prior to each send.
• For homogeneous clusters we can use PvmDataRaw.
• Why - All machines use the same platform, so type precision and endianness will match.
• For efficiency one can also use PvmDataInPlace, but read the man pages for pitfalls.
• For heterogeneous clusters we use PvmDataDefault.

Message Passing in PVM

• pvm_send immediately sends the data in the active message buffer.
• A typical call:

int info = pvm_send(int tid, int msgtag);

• tid is the id of the receiving process.
• msgtag is a user defined message tag.
• info is the returned status code.
• The routine pvm_send sends a message stored in the active send buffer to the PVM process identified by tid.
• The msgtag is used to label the content of the message.

Message Passing in PVM

• pvm_send returns 0 on success, and a negative error code on failure.
• The pvm_send routine is asynchronous.
• Computation on the sending processor resumes as soon as the message is safely on its way to the receiving processor.
• This is in contrast to synchronous communication, during which computation on the sending processor halts until the matching receive is executed by the receiving processor.

Message Passing in PVM

• The pvm_recv blocks the process until a message with label msgtag has arrived from tid.
• A typical call:

int bufid = pvm_recv(int tid, int msgtag);

• bufid is the new active receive buffer identifier.
• Values less than zero indicate an error. pvm_recv then places the message in a new active receive buffer, which also clears the current receive buffer.
• A -1 in msgtag or tid matches anything.

Message Passing in PVM

• This allows the user the following options.
  • If tid is -1 and msgtag is defined by the user, then pvm_recv will accept a message from any process which has a matching msgtag.
  • If msgtag is -1 and tid is defined by the user, then pvm_recv will accept any message that is sent from process tid.
  • If tid is -1 and msgtag is -1, then pvm_recv will accept any message from any process.

Message Passing in PVM

• pvm_bufinfo returns information about a message buffer.
• A typical call:

int info = pvm_bufinfo(int bufid, int *bytes, int msgtag, int *tid);

• bufid is the identifier of the buffer being queried.
• Information concerning the buffer is returned in:
  • bytes will store the length in bytes of the body of the message.
  • msgtag will store the message label
  • tid will store the source of the message. info is the status, values less than zero indicate an error.

Message Passing in PVM

• Typically it is used to determine facts about the last received message such as its size or source. Example use:

bufid = pvm_recv( -1, -1 );
info = pvm_bufinfo( bufid, &bytes, &type, &source );

Message Passing in PVM

• pvm_exit informs the local pvmd that this process is leaving PVM.
• A typical call:

int info = pvm_exit();

• info is the status code returned by the routine.
• Values less than zero indicate an error.
• This routine does not kill the process, which can continue to perform tasks just like any other serial process.
• pvm_exit should be called by all PVM processes before they stop or exit for good.

Message Passing in PVM

• It must be called by processes that were not started with pvm_spawn. Example use:

pvm_exit();
exit(EXIT_SUCCESS);

Master-Slave in PVM

• hello was a typical master slave program.
• Lets take a look at a more realistic scenario.
• A master/slave example where the master process creates and directs some number of slave processes that cooperate to do the work.
• This code comes from the book, and has all sorts of problems. I’ll put my polishing of the code, later in the lecture.

Master-Slave in PVM

• master.c
• slave.c

Master-Slave in PVM

• The Master uses pvm_mcast to multicast the message to all the slaves.
• The multicast message contains four blocks of data:
  • The number of slaves: nproc
  • The identifiers of the slaves: tids
  • The size of the data: n
  • The data itself: data.
• These are packed in a certain order into the master’s send buffer.
• Note that the slave unpacks the receive buffer in the same order as it was packed by the master!

Master-Slave in PVM

• Note the way each slave task discovers its rank.
  • I.e. a unique number me in 0...nproc - 1.
  • We will see other ways of doing this, shortly.
• Note all the hardwired constants!
• Note how changing one (e.g. 32) in one file, would probably break the program as a whole.
• When you have multiple executables like this, hardwired constants become even more of a danger.
• The solution to this is to have a shared header file, that contains all the required #defines.
• This is where the difference between globally defined variables and #defines becomes noticable:
  • #defines are easier to work with across multiple files. global’s can be used (via external declarations), but it is much more fiddly.

Master-Slave in PVM

• Note also that the message tags are defined separately in each file:
• If one was changed, again the program would be broken!
• These too should be replaced by #defines.
• At the end of this lecture, I have provided my version of this duo.
• Also notice the lack of error checking on the user input! - Its just begging for trouble.
• Lets return to pvm_mcast, packing and unpacking messages.

Master-Slave in PVM

• pvm_mcast multicasts the data in the active message buffer to a set of tasks.
• A typical call:

int info = pvm_mcast(tids, ntask, msgtag);

• info is the status code returned by the routine.
  • 0 indicates success.
  • Values less than zero indicate an error.
• tids is an array of task identifiers.
• ntask is the length of the tids array.
• msgtag is the user defioned message tag.
• The routine pvm_mcast multicasts a message stored in the active send buffer to ntask tasks specified in the tids array.
• The message is not sent to the caller even if listed in the array of tids.

Master-Slave in PVM

• Each type of PVM data has a pvm_pk operation associated with it:
  • pvm_pkbyte packs chars
  • pvm_pkint packs ints
  • pvm_pkshort packs shorts
  • pvm_pklong packs longs
  • pvm_pkfloat packs floats
  • pvm_pkdouble packs doubless
• Plus some complex number types.

Master-Slave in PVM

• pvm_pk packs the active message buffer with arrays of prescribed data type.
• A typical call:

int info = pvm_pk<type>(<type> *ip, int nitem, int stride);

• nitem is the total number of items to be packed.
• stride is used to pack a portion of an array.
• For example a stride of two means every second element of the array gets packed.
• A stride of three means every third element of the array gets packed.
• Its useful when dividing data up for the slaves.
• Messages should be unpacked exactly like they were packed to insure data integrity.
• Packing integers and unpacking them as floats will often fail :) .

Master-Slave in PVM

• constants.h
• good_master.c
• good_slave.c

Summary

• Message Passing in PVM
• Master-Slave in PVM

class: middle, center, inverse

Questions?

Reading

• The Introduction and Basic Programming Techniques from PVM: Parallel Virtual Machine A Users' Guide and Tutorial for Networked Parallel Computing