GSoC 2013 Project Ideas

Welcome to the HPX home page for Google Summer of Code (GSoC). This page provides information about student projects, proposal submission templates, advice on writing good proposals, and links to information on getting started writing with HPX. This page is also used to collect project ideas for the Google Summer of Code 2013. The STE||AR Group will apply as an organization and our goal is to get at least two students funded.

We are looking to fund work on a number of different kinds of proposals (for more details about concrete project ideas, see below):

• extensions to existing library features,
• new distributed data structures and algorithms, and
• multiple competing proposals for the same project.

Requirements

Students must submit a proposal. A template for the proposal can be found here. Hints for writing a good proposal can be found here.

We strongly suggest that students interested in developing a proposal for HPX discuss their ideas on the mailing list in order to help refine the requirements and goals. Students who actively discuss projects on the mailing list are also ranked before those that do not.

If the descriptions of these projects seem a little vague... Well, that's intentional. We are looking for students to develop requirements for their proposals by doing initial background research on the topic, and interacting with the community on the HPX mailing list ([email protected]) to help identify expectations.

Project Ideas

• Create a backend for the Intel ISPC (SPMD) compiler. ISPC is a compiler for a variant of the C programming language, with extensions for "single program, multiple data" (SPMD) programming. It provides an API allowing to tie in arbitrary tasking implementations. Using HPX for this looks like a promising target. Moreover, we'd be interested in utilizing HPX's capabilities for distributed applications.
• Create a backend for the Thrust parallel algorithms library. Thrust is a library resembling the C++ Standard Template Library (STL). It provides an abstraction of C++ containers and parallel algorithms over different backend implementations (such as CUDA, OpenMP, and CPU). HPX sorely misses a parallel and distrbuted container and algorithm module. This project should use Thrust to implement such a module on top of HPX.
• Build a Map/Reduce application framework on top of HPX. MapReduce is a programming model for processing large data sets. Many applications would benefit from direct support in HPX. This might include adding Hypertable or similar libraries to the mix to handle the large data sets Map/Reduce is usually used with.
• Revise the thread scheduling subsytem of HPX such that it is more pluggable and allows for more fine grain control over what scheduler to use for the execution of a particular section of the user code. The proposal to the C++ Standards committee proposing work executors (see N3378) seems to provide a good starting point for a possible interface. Also, some initial work has been done on the executors branch.
• Design and implement Python bindings for HPX exposing all or parts of the HPX functionality with a 'Pythonic' API. This should be possible as Python has a much more dynamic type system than C++. Using Boost.Python seems to be a good choice for this.
• Design and implement efficient all-to-all communication LCOs. While MPI provides mechanisms for broadcasting, scattering and gathering with all MPI processes inside a communicator, HPX currently misses this feature. It should be possible to explit the Active Global Address Space to mimic global all-to-all communications without the need to actually communicate with every participating locality. Different strategies should be implemented and tested.
• Implement a EDSL to specify the placement policies for components. This could be done similar to [Chapels Domain Maps] (http://chapel.cray.com/tutorials/SC12/SC12-6-DomainMaps.pdf). In Addition, allocators can be built on top of those domain maps to use with C++ standard library containers.
• Turn HPX into a replacement for the C++ runtime. We currently need to manually "lift" regular functions to HPX threads in order to have all the information for user-level threading available. This project should research the steps that need to be taken to implement a HPX C++ runtime replacement and provide a first proof of concept implementation for a platform of choice.

In addition to that, there are several active tickets listed in our issue tracker which are worth tackling as a separate project. Feel free to talk to us if you find something which is interesting to you.