Hartmut Kaiser and Vinay Amatya: HPX: A C++ Runtime System For Parallel And Distributed Computing
Channel: CppNow
Date: 2013-06-13

Multi-core, Multi-threading is the new modality of computation, whether its in scientific field or non-scientific field, if we are to gain continued scalability of computations as we scale the systems, inter-node as well as intranode. With the degree of complexity and size increasing in new hardware architectures, the bottlenecks in computation namely starvation, latency, overheads, and waiting for contention resolution (SLOW) that have been present even in single core machines would be thickly visible. This significantly increases cost in terms of less resource utilization, when we scale systems to exaflop level. Meanwhile, despite the scaling systems, certain classs of applications are not able to to scale using conventional computation models.

HPX is a new runtime system that is based on a new model of computation -- ParalleX, that addresses above challenges. HPX is implemented in C++ and is conformant with latest C++ standards as well as Boost Libraries. HPX can be viewd as an easy to understand amalgam of various proven software techniques and algorithms as well as some new ideas. HPX API provides an interface for seamless integration of multi-core multi-threaded heterogeneous architectures and user level software applications that is easy to learn.

Leveraging asynchrony between computation and communication, overlapping one over the other, is one of the requirements for new computation models that intend to support the new multi-core heterogeneous architectures. Asynchrony of tasks (local funtions or remote functions in the form of Actions) is one of the principal design features of HPX. HPX not only supports latest C++ standard for local
asynchronous functions but also has implemented a remote asynchronous function: Actions. In additino to this, there are some other data constructs such as Futures and Dataflow that inherently supports this required asynchrony, during task executions.

Inspite of a giant leap in the field of system architecture into the multi-core domain, there are still challanges that limit the scalability of cores beyond a few dozens of cores. Hence, for High Performance Systems, we still rely on multiple node beowulf type clusters. In such systems, the role of asynchrony plays even a greater role, as the latency in communication is significantly increased. In addition to this, for an application to scale beyond tens of thousands of cores, a new addressing system is required, that not only allows temporary suspension of a remote thread objects of an active application but also allows tasks to be migrated to different resources as per need (system failure, system busy). This active addressing scheme is implemented in HPX as Active Global Address Space (AGAS). This addressing scheme also enables HPX to support Resource Managers to actively manage resources in a fine alignment with the applications need.
---

*--*

---