Re: [Swarm-Modelling] Large scale ABM Simulation on the GPU

[Marcus G. Daniels]

Miles Parker wrote:
> some interesting bits there..
>   
It looks like it would usable for some common ABM idioms.  In their 
language, the `step' method would be a `kernel', and simulation state 
would be copied in and out of the processing elements.  (This would have 
to happen behind-the-scenes in smaller chunks for some architectures.).  
"Step all agents on a space" should be trivial. 
> 1. Includes Cell as well. Does this make it more attractive to you or  
> would you generally like to deal w/ Cell directly?
>   
So long as a problem fits well with queued operations on kernels, then 
it ought to work fine on many kinds of hardware.   But what if agents 
probabilistically step or probabilistically chose their peers on a 
network?   Sure you can push the operations through the command queue, 
but will that make good use of the hardware resource?   It could even go 
slower with all of the copying.  
> 2. Key is that they say they want to play for all GPUs, and NVidia  
> *is* mentioned as partner. Hedging their bets, I guess, but again, if  
> Apple is onboard, does NVidia really want to lose a smallish but  
> lucrative and growing customer?
>   
Well, by comparison an OpenGL driver from ATI or NVidia for their latest 
cards is a completely different user experience to having the rendering 
done in software.   Those OpenCL examples could be implemented by 
invoking a shell to invoke gcc targeting host CPU and link up a shared 
object and then dlopen it.  That would actually work for the Cell, just 
change the compiler for the kernel from "gcc" to "spu-gcc".  OpenCL 
seems a packaging of a compiler technology into an API more than a 
technology itself. 

With Snow Leopard, I would imagine that clCreateProgramWithSource and 
clBuildProgram would invoke a proprietary LLVM JIT and never hit disk.  
Incidentally, there's a non-proprietary Cell SPU backend to LLVM.  Or 
with CUDA, they'd have some similar runtime module that could JIT for 
NVidia's instruction set(s) behind the same API.  I suppose a hope is 
that some higher level tools/libraries will emerge (and new programmer 
habits), and that then the vendors can focus on tuning accepted, 
narrowly-defined benchmarks instead of each individually pursing an 
expensive, difficult, fragile, and poorly-understood path of advanced 
vendor-specific language extensions.

Marcus