Parallella Community

Is anyone working on (or interested in) julia for parallella? "Julia is a fast, simple, and dynamic programming language
for high-performance technical computing ... marrying the performance of low-level languages like C/C++ with a
simple and easy-to-understand syntax ... integrating best-of-breed C and Fortran libraries for statistics, linear algebra,
signal processing, and random number generation ... designed out of the box for parallel computing, meaning it's easy
to scale computation across multiple processers in (and out of) the cloud." Perhaps the "full monty" for some within
the emerging parallella community?
http://forio.com/julia/julia
http://julialang.org/

So far the limitation of 32K per core is posing much difficulty on any high level language. So far the most promising I can think of is FORTH.

for forth, there is green arrays(h/w). polyforth(color forth , Chuck Moore)
http://www.greenarraychips.com/

Forth on the Epiphany, very cool!

Great to see that an interpreter can fit into the modest local memory.
At some point, could you post the code for others to learn from? Any conclusions so far from writing Epiphany assembly? Easy, hard, things that could be improved?

Andreas

btw. A nice conversation and blog post about Julia can be found here:(just tweeted by Tim O'Reilly)

http://www.johnmyleswhite.com/notebook/ ... -love-you/

Yes, I would like to see a Julia-move on Parallella; perhaps something more "straight-forward" for starters? SIMD, say, where one has Julia on the ARM processor exercising data-parallel features across the Epiphany set via something like "xectors" (similar to CmLisp on Thinking Machines' Connection Machines)? Julia, in this mode, lets developers leverage the SIMD abstraction by defining new "xector operations" all of which execute concurrently, with significant/useful gains in processing "power"?

@timpart
Forth for Epiphany?

Nice, I was just looking at gForth (which has a Mips implementation and cross/meta compiler) when I stumbled on your post.
Perhaps you would share some info on your efforts?

What about keeping 'julia' on the host processor, but running array processing operations on e-cores,
from C++ I am interested in the approach of writing high-order functions that encapsulate dataflow (e.g. map, reduce,convolution, etc), and passing in lambdas that say 'what to do to the data'. I think Julia has good lambda support (including syntax sugar for trailing lambdas?), and it's also aimed at mathematical code (array operations? inbuilt multidimensional arrays?) .. perhaps it would suit this kind of approach aswell?

(there are an awful lot of details to figure out before I can even use C++ this way, but wth Julia being built on LLVM perhaps there would be overlap?)

Is there a brainstorming wiki ?