llvm dev - Jan 2004 - [LLVMdev] 9 Ideas To Better Support Source Language Developers

On Wed, 7 Jan 2004, Valery A.Khamenya wrote:
> Hello Reid and LLVMers,
> 10. Basic support for distributed computations.
What kind of support?  What do you think should be included in LLVM
directly, as opposed to being built on top of it?

-Chris

-- 
http://llvm.cs.uiuc.edu/
http://www.nondot.org/~sabre/Projects/

Hello Chris,
>> 10. Basic support for distributed computations.
CL> What kind of support?  What do you think should be included in LLVM
CL> directly, as opposed to being built on top of it?

nice question :)

(don't sue me, I am far from being expert like you are!)

just imagine, that we have Linux cluster, and we have two functions in
one module (`f' and `g'). If they are about to be executed at one host,
then one is allowed to do very aggressive interprocedural
optimizations between these `f' and `g'. However if `g' should be
"outsourced to" (i.e. "executed at") other host then
`f', then one is
prohibited to do almost any optimizations between `f' and `g'.

Am I right up to here? if `yes' then:

One is hardly able to make support for distributed calculations on top
of LLVM. Because, in order to make legal optimizations LLVM should
_know_ where the code is really executed. 

Right?..

(Should I reformulate the tings above?)

-- 
Best regards,
Valery A.Khamenya                       mailto:khamenya at mail.ru
Local Time: 20:51

On Wed, 7 Jan 2004, Valery A.Khamenya wrote:
> just imagine, that we have Linux cluster, and we have two functions in
> one module (`f' and `g'). If they are about to be executed at one
host,
> then one is allowed to do very aggressive interprocedural
> optimizations between these `f' and `g'. However if `g' should
be
> "outsourced to" (i.e. "executed at") other host then
`f', then one is
> prohibited to do almost any optimizations between `f' and `g'.
Typically distributed computing like this is performed at a much higher
level than things like LLVM.  Mechanisms like RPC (remote procedure calls)
are used to do things like this, which makes the low-level code look a lot
different than a standard call.
> Am I right up to here? if `yes' then:
> One is hardly able to make support for distributed calculations on top
> of LLVM. Because, in order to make legal optimizations LLVM should
> _know_ where the code is really executed.
The RPC calls would automatically make the LLVM transformations safe: even
the interprocedural optimizations are conservatively correct in the face
of partial and incomplete programs (if they can't figure out what a piece
of code is doing, they won't break it).

LLVM should support distributed computing as well as, say, C does... not
that C supports is particularly well... :)

-Chris

-- 
http://llvm.cs.uiuc.edu/
http://www.nondot.org/~sabre/Projects/