We can now announce the participants in the STE||AR Group’s 2018 Google Summer of Code! We are very proud to announce the names of those 7 students who this year will be funded by Google to work on projects for our group.
These recipients represent only a handful of the many excellent proposals that we had to choose from. For those unfamiliar with the program, the Google Summer of Code brings together ambitious students from around the world with open source developers by giving each mentoring organization funds to hire a set number of participants. Students then write proposals, which they submit to a mentoring organization, in hopes of having their work funded.
Below are the students who will be working with the STE||AR Group this summer listed with their mentors and their proposal abstracts.
Participant:
Nikunj Gupta; Indian Institute of Technology Roorkee, India
Mentor:
Hartmut Kaiser; Louisiana State University, LA, USA
Thomas Heller, Friedrich-Alexander-Universität Erlangen-Nürnberg, Germany
Project: A C++ Runtime Replacement
Turn HPX into a replacement for the C++ runtime. Currently HPX needs to manually “lift” regular functions to HPX threads in order to have all the information for user-level threading available. This project aims to implement 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.
Participant:
Ahmed Samir; Cairo University, Eqypt
Mentor:
John Biddiscombe; Swiss National Supercomputing Centre, Switzerland
Project: Adding All-to-All Communication to HPX
All-to-All Communications is a very important feature that is supported by HPC libraries to allow many processes on different localities to process data efficiently and easily. Making HPX support this feature will increase the library’s performance and capabilities. It’s not an easy project and it needs researching to get the best algorithms that fit with the library’s architecture.
Already there is a basic implementation of broadcast method in HPX. Many algorithms will be tested to refine the existing implementation. After that different methods (like scatter, gather, etc…) will be supported. Also benchmarks will be provided to test the performance of the algorithms.
Participant:
Gabriel Laberge; Polytechnique Montreal, QC, Canada
Mentor:
Marcin Copik; ETH Zürich, ZH , Schwitzerland
Patrick Diehl; Polytechnique Montreal, QC, Canada
Project: Alternative smart executors
HPX allows users to parallel their for-loops. The user can change values of chunk size and prefetching distance with existing execution policies. Some of these policies use machine learning the optimal chunk size and prefetching distance for a given for-loop. However, these machine learning algorithms are classification algorithms so the number of possible outcome is limited. The idea is to use regression algorithms to allow for as many outcomes as needed.
Participant:
Teng Ma; Tsinghua University, China.
Mentor:
Thomas Heller; Friedrich-Alexander-Universität Erlangen-Nürnberg, Germany
Project: Concurrent Data structure Support
STL containers such as vectors/maps/sets/etc are not thread safe. One cannot safely add or remove elements from one of these containers in one thread, whilst iterating or adding/removing in another thread without potentially catastrophic consequences (usually segmentation faults leading to eventual program failure). Some work has begun on implementing concurrent structures in HPX, a concurrent unordered map with reader/writer lock and a partial implementation of concurrent vector exist, but they have not all been completed, do not have unit tests and need to be unified into an hpx::concurrent namespace. A number of libraries implementing thread safe (sometimes lockfree) containers already exist that can be used for ideas and where code uses a boost compatible license can be integrated into HPX. The aim of the project is to collect as much information and as many implementations of threads safe containers and create or integrate them into the HPX library.
Participant:
Jakub Golinowski; ETH Zürich, Switzerland
Mentor:
Mikael Simberg; ETH Zürich, Switzerland
Patrick Diehl; Polytechnique Montreal, QC, Canada
Project: HPX Backend for OpenCV
The Image processing toolbox OpenCV supports multithreading in multiple ways, i.a. via TBB or OpenMP, but not with the use of HPX. Therefore, OpenCV should be equipped with reliable HPX support for parallelism. In this way both the performance of the OpenCV and the reach of HPX will be increased.
Participant:
Mentor:
Kevin Huck; University of Oregon, OR, US
Kate Isaacs; Univeristy of Arizone, AZ, US
Project: HPX trace visualization tool
Debugging task-based applications is hard and one method that is used to help debug such applications is trace visualization. There is no builtin trace visualizer in HPX which would allow for better understanding of program execution. To tackle this currently, the workaround used is to use the APEX library to generate trace files using the OTF2 library so that these could be loaded into a licensed software called Vampir. Although this works, the need for the license to be able to visualize the traces seems a bit restrictive. Apart from this, a custom simple text profiler is utilized which allows for dumping start and end times which are then loaded in nvprof using python scripts for visualization. But given that HPX can be used to work on a huge number of tasks, nvprof cannot handle large traces. Additionally, separate python scripts are employed for the task of generating plots and histograms depicting useful information. Ravel is another tool that already exists and has a nice GUI but lacks certain features that would be useful for the developers of HPX. This project aims at creating a single tool to address all above-mentioned problems allowing for more productive use of HPX.
Participant:
Andreas Schäfer, Google, Zürich, Schwitzerland
Project: Newtonian Physics Sandbox
Developing a tool for modeling Newtonian physics processes based on the LibGeoDecomp library and using HPX for parallel execution. Tool should be easy for use, it should enable end users the creation of simulations with a minimal amount of code. (user can model scene in Blender, export it in text format and pass as argument to the command). The user uses domain terms, rather than writing a large number of irrelevant code.