Week 8 - Practical Exercise

Aims

• This week we will continue on with last tutorial’s program, hello_combined_hosts.
• This will be the last PVM tutorial, next week we move onto MPI
• The idea will be to clean it up a little, and add some error checking
• The error checking we will use is described in lecture 16. http://turing.une.edu.au/~comp309/markdown_lectures/lecture_16/examples/ We will be looking at using PVM groups for ranking processes.
• Groups are covered in lecture 15. http://turing.une.edu.au/~comp309/markdown_lectures/lecture_15/examples/ We’ll also do some killing of children.

Tasks

Exercise 1

Firstly, make sure you have a working version of hello_combined_hosts from the last tutorial, use the solution if necessary. You will also need the pvm_lib.* files from the lecture 16 examples:

http://turing.une.edu.au/~comp309/markdown_lectures/lecture_16/examples/

• Add a target for pvm_lib.o to your makefile.

Exercise 2

Now copy hello_combined_hosts.c to hello_clean.c, and adjust the makefile by adding a target for hello_clean, and make it link with pvm_lib.o. Now, make the following changes: * Add #include "pvm_lib.h" * For every PVM function call, make sure you use the wrapper function, pvm_error_check. If you are not sure how it works, take a look at lecture 16. Your error checking should be similar to:

mytid = pvm_error_check(pvm_mytid(), "pvm_mytid");

• Replace all printfs with fprintfs.
• If you aren’t using last week’s solution make sure to remove all hard-coded constants, and set them using #define.

Exercise 3

• Now its time to clean up the pvm_spawn function call. Firstly, the tid argument. This needs to be changed to an array, so that we can store the tid of every task spawned. Seeing as ntask is a command line argument, your array will need to be initialized dynamically. I suggest you use calloc to do this:

turing.une.edu.au.Solutions> man calloc

• Now your call to pvm_spawn should take a single element (the ith element) of the array as its tid argument. If a spawn fails, the error code will be returned in place of a tid. You should also pass the command line args to the child, so it can get the ntask value itself (use parse_args), otherwise you will have to send it to all children from the master. Compile this version and make sure it works correctly before you move on, my answer looks like:

bourbaki.Solutions> ./hello_clean 3
from t80020: hello, world from b1
from tc0020: hello, world from b2
from t100020: hello, world from b3

Exercise 4

Now copy this working version to neighbours.c, and make the necessary adjustments to your makefile. In this version the idea is to get some information from the slaves regarding their neighbours. Imagine the slaves are a ring, which the master is not a part of. Each slave must work out where it is in the ring, and which slaves it has on its left and right.

An example of this can be found in lecture 16. You will need to:

• Have the master send the tids array to the children using pvm_pkint and pvm_mcast
• Have the child receive the tids array using pvm_recv and pvm_upkint. Knowing ntask will be useful here.
• Make sure you’re using calloc in both the parent and the child.
• The tids array should be allocated ntask elements.
• The child find its own position in the ring, then its neighbours (lecture 15). My output looks like:

bourbaki.Solutions> ./neighbours-1 4
from t80004: me=524292 left=1310724, right=786436, i'm from b1
from tc0004: me=786436 left=524292, right=1048580, i'm from b2
from t100004: me=1048580 left=786436, right=1310724, i'm from b3
from t140004: me=1310724 left=1048580, right=524292, i'm from b4

Exercise 5

OK, now copy neighbours-1.c to neighbours-2.c. Now make the following changes to neighbours-2.c:

• Remove the sending of the tids array from the parent code.
• Remove the receiving of the tids array from the child code.
• The child can now get its rank by joining the group:

    me = pvm_joingroup(GROUP);
    pvm_barrier(GROUP,ntask);

Note the use of the barrier, we want all spawned children to join the group before we move on. Also, you should make sure the child leaves the group before any call to pvm_exit().

pvm_lvgroup(GROUP);

• Of course you will now need to change how the child works out its neighbours. Instead of using the tids array, make use of pvm_gettid(). So, something like:

tids[me - 1]

Should be replaced using the pvm_gettid() function:

pvm_gettid(GROUP, me-1)

Make sure this compiles and runs. Don’t forget to link with the PVM group library i.e gpvm3 when compiling. Your output should be similar to that of the neighbours-1 program.

Exercise 6

• OK, now let’s start a new program, call it murderer.c.
• The idea here is that the parent spawns a number of children, and sends a message to only one of them.
• All the children will be waiting for a message, but only one will receive it.
• The child that receives the message will then kill all the other children in its group.

Exercise 7

Make your parent do the following:

• Spawn a number of children from a number given as a command-line argument.
• Send a message to one tid, and one tid only. The message can be an int, the value doesn’t really matter. The tid you send to is up to you. I send mine to ntask - 1 (the last tid).

Exercise 8

Now, you do the following in the child:

• Join the group, and wait at a barrier.
• Wait to receive a message from the parent.
• If you got a message, go on and kill the other children. This will involve you looping and killing on each iteration, so you will need to know the size of the group:

size = pvm_gsize(GROUP);

• Make sure you don’t kill yourself, so know who you are and check that you’re not the next target. To kill a task, you need to know the tid of the task:

k_tid = pvm_gettid(GROUP, i);

Then you can kill it:

pvm_kill(k_tid);

To see the effects of killing, you would need to try interacting with the killed children i.e. try sending or receiving from them.