[Overflow] BL thoughts

[Jean-Marc V. <jea...@he...>]

Hi,

I've been thinking about how to integrate the BL with the PL and here are my
thoughts on that for now.

I'm assuming the BL will be split in a "master" process, running where the UI is
running, and a bunch of "slave" processes on remote (and local) machines. I
think the master could easiliy be linked with the DL, so communications would be
easy (function calls). 

As for the "slaves", I see them linking with Overflow. That way, the BL slave
would call getOutput() on the PL sub-network, get the result and send that to
another BL process. Since the BL would link with the overflow (PL) libraries,
communications would be made by functions/callbacks. For instance, the first
node of a distributed section would call a function in the BL and ask for its
incoming data. In the same way, for probes and viewers, we would have a node
that would call a BL function (either directly or through a method from a new
iostream). Here's with an example how I see the whole thing.

We have the following processing:
A->B->C->D   (each letter is a Node performing a certain operation)
Suppose the user (or the system) decides to break-up the processing in three
parts:
A -> (B->C) -> D

The BL will spawn 3 processes (we don't care where they run for now). Now, let's
consider the second process doing B->C, the BL will construct an Overflow
network:

N->B->C , where N is a special BL communication node.
When the second BL is asked to compute its result (remember that we're going
backwards, using a pull), it will call getOutput() on node C. In order to
perform its calculation, node C will call getOutput() on node B, which will
getOutput() on node N. Node N will then call a BL function that will ask for its
input. The BL function will ask (CORBA/IPC/socket/...) the first BL and return
the answer it got. Node N will then return the result to node B, which will
calculate something and return to node C, and at the end, the second BL will
have the answer. It will send that answer to the third BL in the same way that
the first BL sent it to the second. (is it clear or have I lost everybody?). If
we suppose that each of the "slave" BL was running on a different machine, we
have that each machine only needs one process (or thread) running. The only
inter-process communication will happen between different BL parts, so both the
PL and DL will not have to care about that. Does that make sense? 

Now let's say that in our precious example node C was a viewer. When C gets the
result from B, it will tell (with a function call) its BL to display some data.
Its BL slave will send that to its BL "master", which will send it (function
call) to the DL, which will know what to do with it: either send it to the GUI
or log it in a file for a batch processing (or even discard it when the user
doesn't want to see it).

What do you think of that?

	Jean-Marc

-- 
Jean-Marc Valin
Universite de Sherbrooke - Genie Electrique
va...@ge...