20.2.1. The Message Passing Protocol

To implement this communication, we use a message passing scheme very similar to that found on parallel supercomputers. The big iron might use shared memory or high-speed interconnects to transfer megabytes of data, but this example just sends a few scalars back and forth.

Figure 20-2. Computing pi with a master and two slave processors

Each slave opens a MainWindow and populates it with a Label widget displaying intermediate results. When a slave finishes, it sends its result to the master.

With true message passing, there's a blocking receive command that reads the message queue and synchronizes the processors. There's nothing like that in Tk, but we can simulate it using tkwait variable, the Tcl way of saying waitVariable, which logically suspends a processor until a variable's value changes. As long as each processor understands the protocol—when and what to send, and when and what variable to wait for—we're okay. Protocol details follow in the next two sections, during the examination of the Tcl/Tk code.

20.2.2. Tcl/Tk Slave Processor Code

wm title . "Pi helper [tk appname]"
wm iconname . "pihelp"

set status ""
label .l -textvariable status -width 80
pack .l

#set numprocs 0
#set proc 0
#set intervals 0
tkwait variable intervals

These three set commands are commented out, because it's up to the master processor to initialize these variables (we need to read them but dare not write them). So we idle, waiting for our master to send the three real set commands. When the set intervals command arrives, it changes the value of intervals, the tkwait completes, and we continue.

set h [expr 1.0 / $intervals]
set helper_sum 0

for {set i [expr $proc + 1]} {$i <= $intervals} {incr i $numprocs} {
    set x [expr $h * ($i - 0.5)]
    set helper_sum [expr $helper_sum +  4.0 / (1.0 + $x*$x)]
    set status "Processor $proc, interval = $i, partial sum = $helper_sum"
    update idletasks
}
set helper_sum [expr $h * $helper_sum]
set status "Processor $proc, final sum = $helper_sum"

This is a straightforward Tcl translation of the Perl--computing code we saw earlier. It only sums "one numprocs-th" of the interval, but that's okay, because the other "numprocs - 1" processors sum the rest. Notice how the status label is updated in real time, via update idletasks, just as in Perl/Tk.

while {1} {
    catch {send pi.tcl "set sums($proc) $helper_sum"}
    after 1000
}

Finally, send the partial sum back to the master, who is expecting to see it appear in its sums associative array, indexed by processor number. A Tcl associative array works the same way as a Perl hash; in fact, Perl used to call its hashes associative arrays too, but we all got lazy and shortened the phrase to simply hash (which is more descriptive anyway).

20.2.3. Tcl/Tk Master Processor Code

proc start_helpers_calculating {} {

    global helper intervals numprocs pids proc sums
    global wishexe

    set proc [expr $numprocs - 1]
    set y 420
    while {$proc > 0} {
        set pids($proc) [exec $wishexe -name pihelp${proc} \
            -geometry +100+${y} < $helper &]
        status "Helper processor $proc started, pid=$pids($proc)."
        incr y 50
        incr proc [expr -1]
    }
    after 2000

    set proc [expr $numprocs - 1]
    while {$proc > 0} {
			send pihelp${proc} "set numprocs $numprocs; \
				set proc $proc; set intervals $intervals"
			incr proc [expr -1]
    }

}; # end start_helpers_calculating

sum_reduce simulates a sum reduction, which is a message-passing operation that reads data from all helper processors and reduces the results to a single value by summing. It waits for each helper, in turn, to store its partial sum in the sums associative array and kills the helper afterward. Finally, it adds its own partial sum and returns the reduced result, .

proc sum_reduce {} {

    # Do a sum reduction.  Fetch all the partial sums computed
    # by the helper processors, and then add them to our partial
    # sum.  The result is an approximation of pi.

    global helper intervals numprocs pids proc sums

    set pi 0
    for {set proc 1} {$proc < $numprocs} {incr proc} {
        tkwait variable sums($proc)
        status "Partial sum from processor $proc = $sums($proc)."
        set pi [expr $pi + $sums($proc)]
        exec kill $pids($proc)
    }
    return [expr $pi + $sums(0)]

}; # end sum_reduce

Figure 20-3. An estimated value of pi, with error