ANN: ParallelAccelerator.jl v0.1 released

[Lindsey Kuper]

The High Performance Scripting team at Intel Labs is pleased to announce the release of version 0.1 of ParallelAccelerator.jl, a package for high-performance parallel computing in Julia.

ParallelAccelerator provides an @acc (short for "accelerate") macro for annotating Julia functions.  Together with a system C compiler (ICC or GCC), it compiles @acc-annotated functions to optimized native code.

Under the hood, ParallelAccelerator is essentially a domain-specific compiler written in Julia. It performs additional analysis and optimization on top of the Julia compiler. ParallelAccelerator discovers and exploits the implicit parallelism in source programs that use parallel programming patterns such as map, reduce, comprehension, and stencil. For example, Julia array operators such as .+, .-, .*, ./ are translated by ParallelAccelerator internally into data-parallel map operations over all elements of input arrays. For the most part, these patterns are already present in standard Julia, so programmers can use ParallelAccelerator to run the same Julia program without (significantly) modifying the source code.

Version 0.1 should be considered an alpha release, suitable for early adopters and Julia enthusiasts.  Please file bugs at https://travis-ci.org/IntelLabs/ParallelAccelerator.jl/issues .

ParallelAccelerator requires Julia v0.4.0.  See our GitHub repository at https://github.com/IntelLabs/ParallelAccelerator.jl for a complete list of prerequisites, supported platforms, example programs, and documentation.

Thanks to our colleagues at Intel and Intel Labs, the Julia team, and the broader Julia community for their support of our efforts!

Best regards,
The High Performance Scripting team
(Programming Systems Lab, Intel Labs)

[Eric Forgy]

Hi Lindsey,

That sounds awesome! Thanks for sharing.

A couple of naive questions come to mind...

Could this be used for generating standalone executables, e.g. for distributing to users who do not have Julia installed, even for non-parallel code?

Could this be used in conjunction with something like emscripten (or the like) to compile Julia to JavaScript?

All the best,

Eric

PS: It is very encouraging to see Intel Labs working on Julia! :)

[Lindsey Kuper]

...and somehow I bungled the URL of our issue tracker, which is, of course, https://github.com/IntelLabs/ParallelAccelerator.jl/issues .  https://travis-ci.org/IntelLabs/ParallelAccelerator.jl is our Travis page, and https://travis-ci.org/IntelLabs/ParallelAccelerator.jl/issues isn't anything. :)

Best,
Lindsey

[Valentin Churavy]

This looks great :) The only thing I am wondering about is the license. Is the license compatible with MIT? And if I want to contribute do I have to fill out a Contributor License Agreement? I would much prefer if the license would be one of the standard open-source ones, but I understand if you are not able to change that. (There was some code licensed under the Intel license for the threading work, but that could re-licensed under MIT recently)

[Lindsey Kuper]

Hi Eric,

On Tue, Oct 20, 2015 at 6:13 PM, Eric Forgy <eric....@gmail.com> wrote:

Hi Lindsey,

That sounds awesome! Thanks for sharing.

A couple of naive questions come to mind...

Could this be used for generating standalone executables, e.g. for distributing to users who do not have Julia installed, even for non-parallel code?

This isn't something we have investigated, at least not yet.  When using ParallelAccelerator, you are still running Julia and relying on the Julia runtime; the difference is that some of your code has been compiled to a native library that Julia calls into.  There's more information in our README: https://github.com/IntelLabs/ParallelAccelerator.jl#how-it-works

Could this be used in conjunction with something like emscripten (or the like) to compile Julia to JavaScript?

Emscripten compiles LLVM to JavaScript, and Julia already compiles to LLVM, so I don't think ParallelAccelerator (which compiles to C) would really come into play here.  In fact, there seems to already be a Julia issue open about compiling to JS via Emscripten (https://github.com/JuliaLang/julia/issues/9430).  That said, targeting LLVM IR with ParallelAccelerator is something we might pursue in the future.

Best,

Lindsey

[Ehsan Totoni]

Hi Eric,

These two use cases are not currently targeted but they are interesting. They seem possible to implement in ParallelAccelerator.jl. You are more than welcome to give them a try if you are interested :)

Bests,

-Ehsan

[Tony Kelman]

The license looks like a totally standard BSD 2 to me, which is as permissive as things get and essentially equivalent to MIT.

Nice work to the Intel Labs team, it's great that this has been publicly released. I hope to see the subset of the language that it can handle grow over time. Leveraging the forthcoming built in Julia threading infrastructure and embedded in-memory clang support should lead to interesting possibilities for this as an analysis and auto parallelization back end.

[Jonathan Malmaud]

This is fantastic work! Thanks and congratulations to the team at Intel.  

[Steven Sagaert]

Great news!

Apart from the focus on parallelism, the architecture seems similar to numba. 

Good to finally have shared memory parallelism in Julia (not counting the shared memory array under Linux via shm).

I wonder how this is going to interact with the upcoming multithreading in julia in the future. Will they play nice together or fight each other?

Sincerely,

Steven Sagaert

[Ehsan Totoni]

Hi Steven,

We are working closely with the authors of the threading support in Julia. Our plan is to support it as soon as it is ready.

Best,

-Ehsan

[Raj Barik]

Agreed.

[Raj Barik]

After Julia's multithreading is ready for release, we will have a native path to interface with it. This will hopefully enable multiple shm execution paths for users to experiment with.