Ste||ar group

Mentors: Student: Anshuman Agrawal

HPX's existing hierarchical communicator (PR #6834) implements four one-to-all collectives (broadcast, reduce, scatter, gather) with a configurable k-ary tree structure. This project will implement the remaining all-to-all collectives: all_reduce, all_gather, and all_to_all ,using the existing hierarchical communicator, produce rigorous three-way benchmarks (hierarchical HPX vs. flat HPX vs. tuned MPI), and prepare the implementation for integration into an upcoming HPX release.

Mentors: Student: Vansh Dobhal

HPX already has partial Tracy support and stronger integrations with tools like VTune and APEX, but tracing is still fragmented and largely thread-centric. This makes it difficult to understand how tasks actually behave, especially across suspension, resumption, and asynchronous dependencies. This project focuses on strengthening and extending Tracy integration in HPX by building on the existing hpx::tracing abstraction and expanding task-level instrumentation across key runtime paths. The goal is to make task execution easier to follow by improving lifecycle visibility, especially around suspend/resume behavior, and by adding initial causal signals (for example, future fulfillment and other synchronization events) to help explain why tasks resume. The work will also extend tracing to execution paths that currently lack visibility, such as fork_join_executor and continuation execution, and introduce scalable controls like filtering and sampling to keep tracing usable in fine-grained workloads. As a stretch goal, I will explore optional trace-context propagation across parcel paths to enable cross-locality correlation in distributed runs. The expected deliverables include integrated tracing hooks across core runtime components, improved suspend/resume tracing, better coverage of executor and continuation paths, benchmark-validated low-overhead operation, and clear documentation for both maintainers and users.

Mentors: Student: Priyanshi507

HPX currently requires verbose macros like HPX_PLAIN_ACTION and HPX_REGISTER_ACTION to define remote operations across localities. This boilerplate is error-prone and creates a steep learning curve for new users. With C++26 static reflection (P2996), function signatures can be introspected automatically at compile time, eliminating this boilerplate entirely. This project implements reflection-based action definition for HPX, replacing HPX_DEFINE_PLAIN_ACTION with a clean template API that uses scope_builder and fixed_string for compile-time name extraction — building directly on the serialization reflection foundation from PRs #7010 and #7016 already merged into master. A working prototype has been built and tested in the GCC trunk Docker environment prior to the coding period.

Mentors: Student: guptapratykshh

This project completes the architectural transition of the HPX parallel runtime to the C++26 Sender/Receiver (S/R) model. Building upon the recent cleanup of legacy execution code, I will advance HPX from an "adapter-based" architecture to its "Native Architectural Phase." This involves refactoring the core execution boundaries of make_future and keep_future to remove internal implementation dependencies (such as the __loop_ pointer) and porting distributed subsystems like MPI and CUDA to be native, first-class stdexec citizens. My primary objective is to eliminate technical debt and achieve zero-overhead integration with the C++26 execution standard while ensuring full backwards compatibility for all existing HPX applications.

Mentors: Student: Haokun Wu

This project aims to modernize the HPX parallel computing library by introducing C++20 Modules, addressing compilation performance and code organization challenges. I develop a comprehensive conversion strategy using a Python-based tracking system to analyze dependencies, create module interfaces, and ensure backward compatibility. The project will deliver a modularized HPX library with improved build system integration, enhanced symbol visibility, and detailed documentation, ultimately providing developers with a more efficient and maintainable parallel computing framework.