GSoC 2024 Contributors Announced!

We are very proud to announce the names of the 5 contributors this year who will be funded by Google to work on projects for our group through Google’s Summer of Code 2024!

These contributors represent the very best 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 contributors who will be working with the STE||AR Group this summer listed with their mentors and their proposal abstracts.

Project Title: Conflict (Range-Based) Locks

Contributor: Hari Hara Naveen S, Indian Institute of Technology, Madras

Mentors: Panos Syskakis, Mikael Simberg, John Biddiscombe

In some multi-threaded algorithms, resources need to be protected using locks, but the locking mechanism may need to operate on ranges rather than individual items. For instance, imagine a scenario with a large array of N items where one task requires a small continguous subset of items to be locked while another task requires a different continguous subset. In such cases, a range-based locking mechanism is required. We need a templated range-based lock that can be applied to arrays of various types and dimensions. A successful implementation should support locking and unlocking operations on specified ranges of items and can be extended to handle multi-dimensional arrays (2D/3D, etc.) with templates that allow flexibility over dimensions and data types.

Project Title: Rustize HPX

Contributor: Dikshant Gurudutt, International Institute of Information Technology, Hyderabad

Mentors: Hartmut Kaiser, Shreyas Atre

Providing performant HPX functionality written in C++ with Rust APIs to facilitate safety as well as ease of learning HPX. Designing and implementing Rust bindings for HPX, exposing all or parts of the HPX functionality with a Rust API. Implementing rust’s ffi along with libraries like, bindgen to intrope hpx functions to rust.

Project Title: Adapting the Parallel Algorithms in HPX for Usage with Senders and Receivers

Contributor: Tobias Wukovitsch, University of Vienna

Mentors: Hartmut Kaiser, Isidoros Tsaousis-Seiras

HPX supports the C++ senders and receivers facilities, which were, inter alia, specified in the standard proposal P2300. However, not all of HPX’s parallel algorithms can currently be used as sender adapters. This project aims to address this issue by completing the remaining S/R implementations of HPX’s algorithms.

Project Title: Standardize and Visualize HPX Benchmarks

Contributor: Vedant Ramesh Nimje, Veermata Jijabai Technological Institute, Mumbai

Mentors: Giannis Gonidelis, Shreyas Atre

HPX, as a framework designed for high performance computing, has various benchmarks for measuring the performance of its various components, which includes parallel algorithms, its runtime system, etc. But these benchmarks (performance tests) lack a standardized format and a visualization tool that can help in analyzing performance trends over time, in different operating environments. Hence, the goal of this project is to standardize the benchmarks’ output formats within HPX, and to also add integration with an external benchmarking framework, i.e., nanobench. Additionally, a visualization tool will also be developed, which will leverage the standardized formats to display the results of the benchmarks in an intuitive manner. Expected results: (1) A unified format for HPX benchmarking using chosen benchmarking framework. (2) Automating the installation of the chosen benchmarking framework in the HPX build system. (3) A visualization tool, developed using python and matplotlib, to display the results. (4) Integration of this plotting tool with CI/CD pipelines, to track and display performance reductions or improvements

Project Title: Implement hpx::contains and hpx::contains_subrange (std::contains and std::contains_subrange).

Contributor: Zakaria Abdi, University of Bath

Mentors: Panos Syskakis, Isidoros Tsaousis-Seiras

A parallel and sequential implementation of std::contains and std::contains_subrange for hpx. To implement this, I will create a customisation point object, which will take in the parameters of the function and depending on whether or not an execution policy is passed, the CPO will dispatch a call to either the parallel or the sequential implementation of hpx::contains or hpx::contains_subrange which will be implemented within a struct called contains or contains_subrange. Both of these structs will inherit from a base class called algorithm which will take in contains or contains_subrange and a bool as template parameters. Inheriting from algorithm will give access to the call member function which will make a call to either parallel or sequential function via CRTP and type based dispatching.