I agree that there are no fundamental barriers to such interaction.
The interface currently in the proposal seems to be adequate (in abstract)
for interfacing with resource managers. However, I think an interface
has to be specified with external process managers (which do job scheduling,
and also interface with resource managers).
In particular, the mechanism of delegation of process creation
capabilities to the job scheduler (which can be also a distributed
debugger, or a load balancer).
> In the area of process management, there are probably no big
> problems.
MPI_process_create() creates a process using the Resource that is passed
to it. However, there is no way for say, a distributed debugger, to ask
the process manager to delegate the responsibility of actually creating
the process to it. PVM handles it with a pvm_reg_tasker() call.
This facility is really needed for distributed debugging that does
not alter the source code of the users and MPI.
(Actually, our debugger HPD uses this call with PVM, also TotalView from BBN
uses this call).
>
> The interaction with debuggers is another issue, which we
> haven't considered in the dynamic process management chapter.
> My first impression is that this is outside MPI, and is
> an issue between the debugger and the process manager (as
> defined in chap 5). The debugger presumably has to intervene
> when processes are created. From the point of view of MPI,
> process creation itself is entirely outside MPI. So for instance,
> MPI might know the process creator as a script called
> "create_process". Normally this script might contain "rsh"
> but when debugging is turned on, this script would contain
> "dbx" as well. But MPI wouldn't need to know.
It is not clear how one could tell MPI to use the "create_process"
script for starting the processes. If this issue is really outside
of MPI, it will severely limit portability and heterogeneous operation
of load balancers and distributed debuggers. A clean mechanism
specified in MPI will really be neat and useful.