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 2020, start here:

Libraries and Applications

Iterator Library

Description

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 performance comparisons.

Expected Results

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 implementing parallel iterators. The stretch goal is to document and propose design solutions to constraints in Chapel iterators.

Skills Required

  • Will need to know or learn Chapel programming language

  • Experience with another language that supports iterators

Difficulty

1/7

Mentor(s)

Ben Albrecht, Krishna Kumar Dey, Engin Kayraklioglu, Paul Cassella (backup)

Utility Modules

Description

Develop some utility modules missing from Chapel’s standard library:

  1. Environment variable interface module

  • Implement an interface for reading, writing, and searching environment variables.

  • Chapel’s environment variable interface should be locale-aware.

  • There is some discussion in the Env module issue.

  1. Shell lexer module

  • Implement a simple lexer that support shell-style quoting, commenting, and escaping.

  • There is some discussion in the Shlex module issue.

Expected Results

An Env module and Shlex module contributed to the Chapel repository, including design review.

Skills Required

  • Will need to know or learn Chapel programming language

Difficulty

1/7

Mentor(s)

Krishna Kumar Dey, Ben Albrecht, Paul Cassella (backup)

Sequential Data Structures

Description

Chapel Language currently supports a lot of data structures as standard modules and packages such as List, Set, Map LinkedList, Bag, Stack, Queue, and Deque. This project aims to add more data structures to this list.

Expected Result

Implement several sequential data structures, including:

  • Unrolled Linked List

  • Search Tree

  • Skip List

  • Interval/Range Tree

  • Vector-based List storing elements in contiguous memory

  • Heap

  • Treap

Publish these data structures as mason packages

Skills Required

Good grasp over data structures, proficient in some programming language and able to learn Chapel.

Difficulty

2/7

Mentor(s)

Krishna Kumar Dey, Engin Kayraklioglu, Paul Cassella (backup)

I/O Performance

Description

Investigate performance of I/O routines in Chapel, and make improvements. The Chapel language includes an I/O system in its standard library. While this I/O system is flexible and capable, to date, little work has been done to analyze its performance and recommend usage. In addition, it is missing some features that would work well with Chapel’s support for parallel computing - in particular a way to read all of the lines in a file in parallel (see the parallel file.lines() issue).

Expected Results

This project will begin by studying I/O performance in Chapel. Work will involve writing test programs to measure performance and comparing performance to other languages (such as C and Python).

A second phase of the project will add to and improve the implementation of the I/O routines with performance in mind. This will include implementing the parallel file.lines() feature described above and also address shortcomings identified in the first phase.

The final phase of the project will be to write a user-facing guide to writing performant I/O code in Chapel.

Skills Required

  • Proficient in C or C++

  • Experience with I/O operations such as fread, read, and mmap in C

  • Will need to know or learn Chapel programming language

Difficulty

3/7

Mentor(s)

Michael Ferguson, Lydia Duncan (backup), Paul Cassella (backup), Przemek Leśniak (backup)

String Performance

Description

Study and improve the performance of string and bytes types’ operations in Chapel. As with some other modern languages, the string type is used to store textual encoded in UTF8 and the bytes type store arbitrary byte sequences. These types support common operations such as searching, replacing and splitting, which can benefit from a thorough performance analysis and improvements. These improvements can be made by tuning the implementation details and/or by implementing algorithms that have lower complexity.

Expected Results

Better understanding of performance via structured performance testing, analysis and implementation of better search algorithms, and special-casing strings with all ASCII characters are expected results of this project. Other directions that should be explored are: comparison between string and bytes performances, study of Computer Language Benchmarks Game performance of Chapel as compared to other competing languages and improvement of its performance, and potential improvements in the regular expressions module.

Skills required

  • Familiarity with string operations in any programming language

  • Familiarity with algorithmic complexity concepts and benchmarking

  • Will need to know or learn Chapel programming language

Difficulty

3/7

Mentors: Engin Kayraklioglu, Michael Ferguson (backup)

Improve Linear Algebra Module

Description

The Chapel programming language’s Linear Algebra library includes native Chapel implementations and wrapper implementations around a subset of LAPACK and BLAS. Currently, these wrapped implementations only support shared-memory matrix and vector operations. This project aims to make the linear algebra module more feature complete by extending the set of wrapped third party library routines. In addition to extending LAPACK and BLAS coverage, this project will explore wrapping distributed libraries such as ScaLAPACK, GPU libraries such as CuBLAS, and other libraries such as the the GSL linear algebra routines.

Expected Results

Contribution of wrapped linear algebra routines to the Linear Algebra module. An initial goal is to reach parity with other modern linear algebra libraries, such as Python’s scipy.linalg. From there, we choose our next direction between distributed, GPU-accelerated, or sparse linear algebra routines.

Skills required

  • Will need to know or learn Chapel programming language

  • Strong linear algebra background

  • Familiarity with any of the backend linear algebra libraries is a plus

  • Experience with GPU and/or distributed programming is also helpful

Difficulty: 4/7

Mentor(s): Ben Albrecht Engin Kayraklioglu (backup), Nikhil Padmanabhan (backup)

Libraries for Web Services

Description

Since many modern applications involve web services, we would like to be able to write some web services in Chapel. Therefore this project is to create a library to support writing web services in Chapel. This will allow Chapel to fit into more use cases and also enable tools such as a web-based execution monitor. While the focus of this project will be on building a library that allows Chapel programs implement web services, it will also involve creating libraries to create a web server in Chapel and libraries to support socket programming in Chapel.

Expected Results

An implementation of a library enabling REST web services to be written in Chapel and that supports communication with JavaScript programs using WebSockets. Since programs using WebSockets have the ability to communicate any data in a streaming manner, the WebSockets support will involve creating a sockets support library. The sockets support library should be designed in a manner that allows for concurrency and parallelism. Logging, authentication, https support, and error handling are additional features to consider.

Skills Required

  • Familiarity with a few web services libraries in other languages

  • Experience using web services and WebSockets from JavaScript

  • Experience with sockets in some language

  • Will need to know or learn Chapel programming language

Difficulty

5/7

Mentor(s)

Michael Ferguson , Krishna Kumar Dey (backup), Paul Cassella (backup)

Physics Simulation/MD Engine in Chapel

Description

While there are a few Molecular Dynamics engines that are scalable (such as LAMMPS), they tend to be written in C++ and make use of scaling technologies like MPI. This increases the barrier to entry to contributing to computational physics/biophysics code/methods. Alternatively, an engine written in Chapel would massively reduce the overhead required to scale, allowing large scale (or an ensemble of) simulations written in code that is easier to understand and modify. In addition, the use of Chapel’s distributed data structures would allow for running simulations at scales heretofore unheard of.

Expected Results

A Chapel program that is able to take a system of point particles and apply an energy function to calculate how the system moves in time. This would be solid foundational work, and a stretch goal would be writing the code necessary to run a system too large to fit on one compute node.

Skills Required

  • Strong foundation in Newtonian physics and mathematics at the calculus level.

  • Desire to learn how numerical simulations are performed.

  • Will need to know or learn Chapel programming language

Difficulty

5/7

Mentor(s)

Audrey Pratt, Ben Albrecht (backup)

Native Distribute Linear Algebra Implementations

Description

The Chapel programming language’s Linear Algebra library primarily relies on LAPACK and BLAS, which adds an additional dependency and only works on shared-memory matrices and vectors. This project aims to provide a native shared-memory and distributed Chapel implementation for the Linear Algebra operations available in the LinearAlgebra package. The effort will include both sparse and dense versions of core linear algebra operations.

Expected Results

Contribution of shared-memory and distributed linear algebra operations. A naive implementation of dense linear algebra is the minimum required, with optimizations to avoid redundant and unnecessary communications as a target goal, along with benchmarks to measure the performance of said implementation.

Skills required

  • Strong linear algebra background (to lead discussion)

  • Will need to know or learn Chapel programming language

Difficulty

7/7

Mentor(s)

Garvit Dewan, Louis Jenkins (backup), Engin Kayraklioglu (backup)

Parser

A Better Parser

Description

Implement an improved parser for the Chapel language. An improved parser can:

  • Provide better error messages instead of “syntax error”

  • Provide parse trees to tools besides the Chapel compiler

  • Support parsing in more interactive settings such as code completion in editor or in an interpreter

Note that the Chapel compiler currently has a lex/bison parser with included actions that are relevant only to the current Chapel compiler. See also the Language Server, Linter, and lint flag issues as well as antlr.org.

Expected Results

A new parser for the Chapel programming language written in ANTLR or another agreed-upon parsing strategy. Work on the parser will be done incrementally by developing rules to parse more and more complex example programs. By the end of the project, the parser should be able to parse all of the Chapel test suite source code that compiles today. A stretch goal would be to use the parser to create a linter or code completion tool for Chapel.

Skills Required

  • Experience with compilers, in particular knowledge of context-free grammars.

  • Proficient in C++

  • Will need to know or learn Chapel programming language

Difficulty

5/7

Mentor(s)

Michael Ferguson, Lydia Duncan (backup), Przemek Leśniak (backup)

Language Interoperability

Protocol Buffers Integration

Description

Google Protocol Buffers is a language-neutral serialization library. However Chapel support for Protocol Buffers has not been investigated. Nonetheless, there are a number of interoperability scenarios that would benefit from having such a feature. This feature is something that many other projects can build on - including calling Python from Chapel or creating a Chapel distributed in-memory key-value storage service.

The protocol buffers compiler supports a few languages directly but also includes a plugin mechanism to generate code for other languages. These plugins can be written in the target language.

Expected Results

Create a Chapel library that works with basic Protocol Buffers functions. Implement a Chapel plugin for the protocol buffers compiler. Demonstrate this tool in an example integration using protocol buffers.

Skills Required

  • Will need to know or learn Chapel programming language

  • Desire to learn about protocol buffers

  • Knowledge of C++ is a plus (since the protocol buffer compiler is written in C++)

Difficulty

5/7

Mentor(s)

Audrey Pratt, Lydia Duncan (backup)

C++ Interoperation

Description

Chapel already has support for interoperation between Chapel and C, Python, and Fortran. This project will investigate interoperation between Chapel and C++.

Interoperation between Chapel and C++ will build upon existing work for interoperation between Chapel and C. This work enables extern blocks - in which C code can be embedded within a Chapel program - and makes use of the clang compiler.

Expected Results

The student will need to develop solutions to interoperability challenges with C++. Here is a list of C++ features that will require specific attention:

  • name mangling

  • method calls

  • RAII / local variable destruction

  • function overloading

  • function templates

The expected result is that C++ functions and methods will be callable on C++ types that are available within Chapel, and that the destructor for local variables of C++ type will be called at the appropriate time. Supporting C++ templates over Chapel types and operator overloading are stretch goals.

Skills Required

  • Experience with clang internals and implementation

  • In-depth knowledge C++

  • Will need to know or learn Chapel programming language

Difficulty

7/7

Mentor(s)

Michael Ferguson, Lydia Duncan (backup), Przemek Leśniak (backup)