This article was accepted into the corpus but its outbound wikilinks were never NER-processed — typical at the deepest BFS hop or when the run's entity cap was reached. No expansion funnel to show.
| HPX | |
|---|---|
| Name | HPX |
| Developer | Blazegraph? No — omit uncertain |
| Initial release | 200? omit |
| Programming language | C++ (primarily) |
| Operating system | Cross-platform |
| License | Various (permissive) |
HPX
HPX is an open-source C++ runtime system for parallel and distributed applications that provides an asynchronous many-task (AMT) programming model. It targets high-performance computing environments and aims to expose concurrency, locality, and latency tolerance through a task-based execution model. HPX integrates concepts from task schedulers, lightweight threads, and global address spaces to support fine-grained parallelism across multicore nodes and distributed clusters.
HPX presents a task-driven execution environment inspired by research in Task Parallelism, Actor model, and Partitioned Global Address Space approaches such as Chapel, UPC and X10. It builds on work from projects at institutions like the Lawrence Livermore National Laboratory, University of Stuttgart, and the Max Planck Society to address scalability challenges encountered on systems from vendors such as Intel, NVIDIA, and AMD. HPX implements abstractions comparable to constructs in OpenMP, MPI, and C++ Standard Library concurrency, while providing additional features for asynchronous continuations and distributed futures.
HPX originated from academic and laboratory efforts to replace bulk-synchronous paradigms exemplified by MPI with fine-grained tasking studied at centers including Argonne National Laboratory and the Oak Ridge National Laboratory. Early prototypes were influenced by runtime research from projects such as ParMETIS, Charm++, and TBB (Threading Building Blocks). Over time, contributors from research groups at the Steinbuch Centre for Computing and universities including the University of Heidelberg participated in design and testing. HPX's roadmap and releases have often aligned with community milestones at conferences like SC (Supercomputing), ISC High Performance, and workshops at the International Conference on Parallel Processing.
The architecture of HPX centers on lightweight user-level threads, an active-message based parcel subsystem, and a global addressing model similar to features in Global Arrays and UPC++. HPX schedules tasks on OS threads using work-stealing algorithms akin to those in Intel TBB and incorporates locality-aware policies adopted in systems from Cray and Hewlett Packard Enterprise. Its design supports distributed synchronization primitives inspired by research in Futures (computer science), Promises, and Continuation Passing Style as used in languages like Haskell. The parcel subsystem allows message-driven computation comparable to the migration semantics in Charm++ and the remote procedure call techniques used by gRPC and ZeroMQ—but targeted to HPC runtimes.
HPX is implemented primarily in modern C++17/C++20 and exposes a standards-compatible API that integrates with the C++ Standard Library concurrency facilities. Key features include lightweight threads (user-level), futures and continuations, dataflow primitives, and distributed components with global identifiers similar to concepts from Boost (C++ Libraries). The runtime provides active-message transport backends that can interoperate with network stacks used by InfiniBand, RoCE, and TCP/IP stacks present on systems from Mellanox Technologies and Broadcom. HPX also offers performance instrumentation comparable to tools like VTune, TAU, and HPCToolkit for profiling and tracing.
HPX targets scalability on systems ranging from many-core workstations to leadership-class clusters such as those populated by Frontera, Summit (supercomputer), and Perlmutter. Performance studies compare HPX implementations with codes based on MPI+OpenMP and demonstrate benefits for irregular task graphs, latency-hideable workloads, and fine-grained synchronization patterns. The work-stealing scheduler and locality-aware placement aim to reduce contention observed in runtimes like Erlang under high concurrency. Scalability analyses are presented at venues including IEEE International Parallel and Distributed Processing Symposium and ACM/IEEE Supercomputing.
HPX has been applied to domains requiring fine-grained parallelism and dynamic load balancing, including computational fluid dynamics problems from groups at Sandia National Laboratories, adaptive mesh refinement used in projects like AMReX, particle simulations related to LAMMPS, and linear algebra kernels similar to PETSc and Trilinos. Other applications include real-time data analysis pipelines used in collaborations with teams at CERN, multiphysics solvers developed in academic consortia including CERFACS, and machine learning workloads where asynchronous parameter updates are relevant, as explored in research by groups at University of California, Berkeley and Stanford University.
HPX development is coordinated by an international community of contributors from universities, national laboratories, and industry partners including teams that collaborate with European Centre for Medium-Range Weather Forecasts style institutes and supercomputing centers like NERSC. Governance typically follows open-source collaboration norms with code review, issue tracking, and releases announced at community events such as C++Now and BoostCon. Academic publications and tutorials from contributors are presented at conferences including SC, ISC, and workshops organized by research networks like the Exascale Computing Project.