Using HPX on Windows

HPX is a C++ Standard Library for Parallelism and Concurrency. Building and using it on Windows just got much less involved. We have now integrated HPX into the VcPkg VC++ Packaging Tool. This tool is design to help you getting C and C++ libraries built and installed on Windows without hassle. It manages all package dependencies for you, such that — once HPX has been built — no additional settings have to be supplied to your build environment.

HPX V1.0 Released!

The STE||AR Group is proud to announce the release of HPX V1.0. While we call it version one, it is in fact the fifteenth official release of our library. This release has become possible as we now have implemented all the features we set out to put in place for this version.

HPX is the C++ Standard library for parallelism and concurrency.  It implements all of the related facilities as defined by the C++ Standard. As of this writing, HPX provides the only widely available open-source implementation of the new C++17 parallel algorithms. Additionally, in HPX we implement functionalities proposed as part of the ongoing C++ standardization process, such as large parts of the C++ Concurrency TS, task blocks, data-parallel algorithms, executors, index-based parallel for loops, and many more. We also extend the existing C++ Standard APIs to the distributed case (e.g. compute clusters) and for heterogeneous systems (e.g. GPUs).

At its heart, HPX is an asynchronous many-task runtime system for the distributed world. It is portable in code and performance across a wide variety of architectures and operating systems. We have shown that it is usable on almost any machine from a Raspberry Pi to the biggest computers available to us. Applications relying on HPX will scale from small handheld devices up to machines with thousands of compute-nodes and millions of processors. For example, we have just successfully run an HPX application on the full NERSC Cori machine, a cluster with 9640 Intel Knight’s Landing compute nodes (655520 cores).

The new C++ Standard facilities listed fit perfectly with some of our extensions targeting asynchronous operations, such as asynchronous parallel algorithms, asynchronous task blocks, or dataflow constructs. As a result, HPX changes the way we write programs in modern C++. It seamlessly enables a new asynchronous C++ Standard Programming Model which tends to improve the parallel efficiency of our applications and helps reduce complexities usually associated with concurrency. At the same time, HPX’s API is strictly aligned with the C++ standardization process which removes the barriers of adoption.

The code base of HPX is very mature and of very high code quality. Our extensive testing has definitely paid off. Many people have contributed to this release — we would like to thank all of them for their efforts. This release incorporates nearly 1500 commits and has closed almost 300 tickets and pull requests submitted by collaborators from all over the world. We have introduced several important changes:

  • We added various new higher-level parallelization facilities, such as more parallel algorithms, range based parallel algorithms, and channels — all well aligned with various C++ standardization documents.
  • We now support transparently migrating objects across compute-node boundaries, which is a major feature supporting dynamic load balancing in large distributed applications.
  • We have refactored our thread-scheduling subsystem for improved performance and less overheads.
  • We have added a new network transport module enabling direct support for Infiniband networks.
  • We have added a long list of new performance counters exposing different runtime parameters.
  • We have improved the integration with external diagnostic tools, such as APEX and Intel Amplifier or Intel Inspector.

How to Download:

For a complete list of new features and breaking changes please see our release notes. If you have any questions, comments, or exploits to report you can comment below, reach us on IRC (#stellar on Freenode), or email us at We value your input!

Vectorized C++ Parallel Algorithms with HPX

In preparation for my talk at CppCon 2016 last week I decided to have a closer look at the possibility to add vectorization to HPX’s parallel abstractions1The slides for this talk can be downloaded here. The goal was to avoid using compiler specific extensions while enabling vectorization support. At the same time, I wanted to be able to integrate this with the already existing parallel algorithms in HPX, proving again that higher level APIs and best possible performance go hand in hand in HPX.

Notes   [ + ]

1. The slides for this talk can be downloaded here

HPX V0.9.99-rc1 Available

The STE||AR Group is proud to announce the first release candidate of HPX V0.9.99!

In preparation for the next major release of HPX we have put together a first release candidate. Please download one of the tarballs

  • HPX V0.9.99-rc1:
    File MD5 Hash
    zip (5.5M) 3f70d33f0ca737dc55e15e106abef259
    gz (3.7M) 10a0ad210ac33b5a91e25a9a375ce585
    bz2 (3.2M) d78657bce8435c0998648f09b280acee
    7z (2.8M) b109408218d5aa1320efd9fc7a0671d6

or check out the tag ‘0.9.99-rc1’ from the repository here and verify whether your code builds and runs fine when using this version.

Please see for a list of new features and fixed problems in this release here.

Please report any problems you might encounter through our ticket system.
We plan to do the final release of HPX V0.9.99 on July 15th, 2016.


GSoC 2016 Participants Announced!

We can now announce the participants in the STE||AR Group’s 2016 Google Summer of Code! We are very proud to announce the names of those 6 students who this year will be funded by Google to work on projects for our group.

These recipients represent only a handful 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.

HPX and Index-based C++ Parallel Loops

In Jacksonville at the winter 2016 C++ standardization meeting, Intel presented the second revision of their standardization proposal targeting index-based parallel for-loops (the latest document at the time of this writing is P0075R1). This document describes a couple of basic parallel for-loop constructs which complement the existing parallel algorithms which we have already implemented for quite some time in HPX. The following is taken from this document:

HPX and C++17

During the Jacksonville meeting of the C++ standards committee last week the so called Parallelism TS was accepted into the next official International Standard, also known as C++17. We can now expect for all major vendors of C++ compilers to implement the very same parallelism facilities as HPX has exposed for almost 2 years already!

A while back, we wrote about how HPX implements parallel algorithms. At the time of that writing, these parallel algorithms were freshly published as a WG21 Technical Specification with the goal of moving them into the main C++ International Standard at some point in the future. Since then, we have continued to work hard on implementing HPX versions of the proposed algorithms. In addition, we have added extensions in our implementation such as the “task” policy which enables asynchronous execution of the algorithm. We have also spent a lot of time tuning our implementation to make it as performant as possible. For instance, we have shown that it is possible for the relatively higher-level parallelization abstractions in HPX to match or to even outperform the performance of equivalent applications based on well-known and well-honed technologies like OpenMP.

The STE||AR Group is proud of the fact that our implementation in HPX has provided implementation, usage experience, and early feedback to the C++ committee. These contributions have helped to get this specification into the new standard. We hope to continue to be a flexible and valuable testbed for all future standardization proposals relating to parallelism and concurrency.

C++ and the Heterogeneous Challenge

As HPC shifts its long range focus from peta- to exascale, the need for programmers to be able to efficiently utilize the entirety of a machine’s compute resources has become more paramount. This has grown increasingly difficult as most of the Top500 machines utilize, in some capacity, hardware accelerators like GPUs and coprocessors which often require special languages and APIs to take advantage of them. In C++ the concept of executors, as currently discussed by the C++ standardization committee, has created a possibility for a flexible, and dynamic choice of the execution platform for various types of parallelism in C++, including the execution of user code on heterogeneous resources like accelerators and GPUs in a portable way. This will also allow to develop a solution that seamlessly integrates iterative execution (parallel algorithms) with other types of parallelism, such as task-based parallelism, asynchronous execution flows, continuation style computation, and explicit fork-join control flow of independent and non-homogeneous code paths.

HPX V0.9.11 Available!

The STE||AR Group is proud to announce the release of HPX v0.9.11! In this release our team has focused on developing higher level C++ programming interfaces which simplify the use of HPX in applications and ensure their portability in terms of code and performance. We paid particular attention to align all of these changes with the existing C++ Standards or with the ongoing standardization work. Other major features include the introduction of executors and various policies which enable to customize the ‘where’ and ‘when’ of task and data placement.

HPX and C++ Futures

There has been a lot of attention to Futures in C++ lately. One of the main related events (even if it was not widely mentioned anywhere) was the final call for positions and comments for the preliminary draft technical specification for C++ Extensions for Concurrency (PDTS), see N4538. This call closed on July 7th, 2015. At this point, the document is out for the national bodies to vote on whether it should be accepted as a final TS (the balloting period ends on July 22nd, 2015). Personally, I expect for this document to be accepted unanimously, which means that we soon will have a second TS related to parallelism and concurrency ready. Compiler vendors will have a field day implementing all of this functionality over the next months (and years).