Compiler Projects – Summer of Code


There are many remaining components that need to be updated to use thread-safe algorithms before Julia's threading will be stable for general usage. Some basic data-structures (such as the TypeMap) are missing correct RCU and memory barriers to ensure race-free answers. The realloc operation for arrays (i.e. resize!) may be more reliable if it was implemented using RCU malloc (delaying the free until a gc-safepoint has been reached on all threads).

Expected Results: Demonstrate that a program that fails at the beginning of the summer can now run to completion, or show what remains to be fixed to get it working. Start a test framework to help find bugs and race conditions in the current implementation, and to detect future regressions in multi-threading behavior.

Recommended Skills: Experience with thread-safety in C.

Mentors: Jameson Nash

Data Structure Algorithm Improvements

Julia is distributed with well-validated implementations of the standard suite of data-structures. However, there are a range of projects that could be done to improve the quality, performance, or usability of these builtin structures. Some ideas include:

But this is just a sample list, and is far more than one summer of work. So what do you want to work on?

Recommended Skills: Ability to write type-stable Julia code. Ability to find performance issues. Knowledge about data structures and related algorithms. Interest in a particular problem above (or propose your own).

Contact: Jameson Nash

Calling Julia from Python

Julia is a great replacement for C in Python projects, where it can be used to speed up bottlenecks without sacrificing ease of use. However, while the basic functionality for communicating with Julia exists in PyCall.jl and pyjulia, it could be better separated out and maintained as a real Python package.

Expected Results: An easy-to-use Python package which allows Julia functions to be imported and called, with transparent conversion of data.

Recommended skills: Familiarity with both Python and Julia, especially C interop.

Mentors: Steven Johnson

Calling Julia shared libraries from Python

Similar to the above, but involving PackageCompiler to remove JIT overhead. The successful candidate will start off from the prototype and will make sure that linking a shared Julia library to Python works on all platforms. If there is still time after this, the project can be extended to make the interaction between Python and Julia work smoothly. We will need to make sure that all functions can be called with rich python data types, and that conversions to common Julia data types happens automatically. If the conversion can't happen automatically, we need to make sure that there are easy ways to convert a Python object to the correct Julia object.

Recommended skills: This project will require strong knowledge about compiling and linking binaries. Expected Results: An easy way to call into static julia libraries without JIT overhead and with automatic type conversions.

Mentors: Simon Danisch

Compiler projects

I have a number of other compiler projects I'm currently working on. Please contact me for additional details and let me know what specifically interests you about this area of contribution:

Mentors: Jameson Nash