Project Ideas List ¶

This is the project idea list for Google Summer of Code with Chapel.

The project ideas in this list have been compiled by Chapel contributors. Students may submit proposals based on existing ideas here or new ideas altogether.

Note

If you are interested in applying for Chapel’s Google Summer of Code 2019, start here:

How to Apply

Contents

Project Ideas List

Libraries and Applications ¶

Your favorite library or application in Chapel ¶

Expected results:
Description:	Build any application in Chapel that might show off its productivity, performance, and/or elegance. This could be anything from a port of an email client library to a standalone molecular dynamics engine. The world is your oyster, and we’re excited to mentor you along the way to building your application in Chapel.
	Expectations will be tuned specifically to the project. In a general sense, the application or library should reach a state that is ready for public use.
Skills required:
	Proficient in some programming language and able to learn Chapel.
Difficulty:	Variable
Mentor(s):	All mentors are available for this project depending on the topic.

Unit Test Framework ¶

Expected results:
Description:	Design and develop a unit test framework for Chapel. Today, writing tests for your Chapel program means either using an output-based non-user-facing tool called start_test, or a minimal exit-code-based tool that is built into the Mason package manager. Both approaches are very limited and not intended to be the long-term solution for Chapel developers to write tests for their programs. This project will design and build the unit test framework intended for Chapel users.
	A test framework for Chapel with the following core functionality: Minimal overhead to writing unit tests A toolset of simple assertions to make about code with clear failure messages Once core functionality exists, there are several directions this project can explore: Integration with Mason, Chapel’s package manager Integration with chpldoc, Chapel’s documentation generator Performance testing Configuration-specific testing
Skills required:
	Experience with testing frameworks, proficient in some programming language and able to learn Chapel.
Optional knowledge:
	C++ experience (for compiler modifications)
Difficulty:	4/7
Mentor(s):	Ben Albrecht, Michael Ferguson, Lydia Duncan, Sam Partee

Memory Pools ¶

Expected results:
Description:	Create a memory pools library for Chapel. Memory pooling can allow improved performance by reducing the number of calls to the allocator and by freeing memory all at once. Additionally, it can reduce stack space required by certain programming patterns (as with issue #10819). The Apache Portable Runtime memory pool library as well as the Rust arena are interesting prior work.
	Language/API design for memory pooling, example programs, and module code implementing a simplified interface. Stretch goal: complete implementation
Skills required:
	Proficient in some programming language and able to learn Chapel. Implementation will involve writing Chapel code and possibly C++ compiler code.
Difficulty:	5/7
Mentor(s):	Michael Ferguson, Louis Jenkins

Iterator Library ¶

Expected results:
Description:	Build a library of iterator tools. The Chapel language supports both serial and parallel iterators. It would be useful to provide a toolkit of common serial and parallel iterators to users through a library. Python’s itertools library would make a good reference for target functionality as well as early performance comparisons.
	An iterator library that implements some subset of Python’s itertools library in Chapel. This project could take a breadth-first approach or depth-first approach, where depth would involve optimizing performance and pursuing parallel iterators.
Skills required:
	Proficient in some programming language and able to learn Chapel. Experience with another language that supports iterators
Difficulty:	3/7
Mentor(s):	Ben Albrecht

Implementing and Optimizing Distributed Benchmarks ¶

Expected results:
Description:	This project aims at writing and improving implementations of the NAS Parallel Benchmarks (NPB) and Parallel Research Kernels (PRK) distributed memory benchmarks. While some of these benchmarks are already implemented in Chapel, many of the existing implementations are not yet optimized or are only partially implemented. There are also several benchmarks with no implementation yet. See these issues for current status: Improve PRKs (#6162) Improve NPBs (#8355). This is a great opportunity for students to write multilocale scientific kernels in Chapel, explore the impact of optimizations on those kernels, and see how fast they can get the benchmarks to go.
	A reasonable subset of the benchmarks have multilocale implementations ideally with different levels of optimizations to assess the performance of different language constructs.
Skills required:
	Parallel programming. Proficient in some programming language and able to learn Chapel.
Optional knowledge:
	Experience with distributed memory programming (e.g. with Chapel, MPI, UPC etc) and understanding of the importance of data locality is a big plus.
Difficulty:	5/7
Mentor(s):	Engin Kayraklioglu, Ben Albrecht

Distributed Sparse Linear Algebra Library in Chapel ¶

Expected results:
Description:	Many machine learning methods and simulations of physical systems depend on the solution of large sparse linear algebra systems, with even the sparse matrices often exceeding the size of the memory on a single compute node for interesting problems. The Chapel programing language has support for sparse arrays, and a simple-to-use library for distributed sparse linear algebra would build on this capability to make Chapel a natural choice for performing of large-scale ML training or physical simulations.
	A Chapel package that is designed after common sparse linear algebra tools such as PetSC, Sparse extensions on BLAS that support: certain basic operations (linear operations such as scaling and translating sparse matrices, Sparse Matrix-Vector multiplication) Linear solvers, including a Cholesky solver for symmetric matrices and a basic general iterative solver.
Skills required:
	Some understanding of benchmarking, profiling and performance analysis principles is a plus. Proficient in some programming language and able to learn Chapel.
Difficulty:	4/7
Mentor(s):	Engin Kayraklioglu, Ben Albrecht

Bulk Operations for Sparse Arrays ¶

Expected results:
Description:	Chapel supports many bulk operations on dense arrays. However, such support in sparse arrays are limited, at best. This project aims at improving creating and manipulating sparse arrays, including faster initialization and base implementation for sparse array slicing. This project is especially interesting and challenging for distributed sparse arrays.
	Improvements to the implementation of sparse array that better support bulk operations such as assignment (#9344) and slicing (#9813). Stretch goals would include improving the bulk operations for distributed sparse arrays; improving bulk transfer for distributed arrays; and evaluating and resolving performance problems for common sparse array idioms.
Skills required:
	Knowledge of sparse array formats (CSR, COO), proficient in some programming language and able to learn Chapel.
Difficulty:	4/7
Mentor(s):	Engin Kayraklioglu

Infrastructure and Tooling ¶

Launchers Rework ¶

Expected results:
Description:	Implement a hackable Python-based launcher framework for Chapel programs. The launcher is a program that the Chapel compiler produces that runs a multilocale program using a job scheduler (e.g. SLURM, PBS, etc). Besides interacting with the job scheduler, the launcher is responsible for performing argument parsing verification. The launcher is one of the things that most frequently needs customization for different computing sites but the current implementation strategy makes it hard for those unfamiliar with it to update it.
	Python-based launcher for at least one Chapel multi-locale configuration
Skills required:
	Mostly Python, some C. Proficient in some programming language and able to learn Chapel.
Difficulty:	3/7
Mentor(s):	Michael Ferguson

Chapel Linter ¶

Expected results:
Description:	Create a linter that is capable of highlighting errors in various text editors. Preferably design a linter that is general enough to be imported into many different text editors, but at the very least just for a single one. There are many possible directions that this project could take. The proof of concept in issue #9003 shows one approach.
	Chapel Linter for at least one text editor (Atom, Sublime Text, Visual Studio, Vim, Emacs, etc.)
Skills required:
	Experience with compilers, in particular knowledge of context-free grammars and with yacc or bison. Proficient in some programming language and able to learn Chapel.
Difficulty:	4/7
Mentor(s):	Louis Jenkins, Lydia Duncan

Compiler ¶

Concurrent-Safe Memory Reclamation Systems ¶

Expected results:
Description:	Currently Chapel has support for ‘shared’ lifetime-managed objects, which is implemented using reference-counting. Unfortunately reference counting has associated with it very large overheads that are remedied by other types of memory reclamation. Epoch-Based Reclamation, Quiescent-State Based Reclamation, Hazard Pointers, and the newer Interval-Based Reclamation all have trade-offs that have yet to be explored in a distributed setting. This project focuses on exploration of these techniques, first via their implementation in shared-memory in a way that allows them to be direct contributions to the language, and then via adaptations and synthesizing possibly newer memory reclamation algorithms from the above mentioned or even from newer, novel ideas.
	Implementation of at least 2 of the algorithms mentioned above and at least some exploration of their applications in how well they perform in distributed memory. Stretch Goals: Detailed analysis of trade-offs of all 4 techniques, technical report, paper, or survey on findings.
Skills required:
	Knowledge of memory reclamation techniques, strong knowledge of non-blocking algorithms. Proficient in some programming language and able to learn Chapel.
Difficulty:	6/7
Mentor(s):	Louis Jenkins

Improvements to Chapel LLVM Backend ¶

Expected results:
Description:	The Chapel compiler optionally can produce LLVM IR and use LLVM optimizations with –llvm. Going forward, Chapel will use LLVM more and more because the compiler can effectively communicate more important details to the optimization passes. This task is to improve the quality of the LLVM IR, the testing of Chapel with LLVM, and the performance of the Chapel compiler in –llvm mode.
	Improvements to LLVM IR quality, testing, or Chapel compiler performance.
Skills required:
	Familiarity with LLVM and C++. Python programming will be needed to improve LLVM testing. Proficient in some programming language and able to learn Chapel.
Difficulty:	4/7
Mentor(s):	Michael Ferguson