The C++11 standard library introducedstd::asyncas a convenient means of asynchronously executing a function on a new thread and returning an instance of astd::futurerepresenting the eventual result produced by that function. In HPX, thehpx::asyncAPI is one of the most basic parallelization facilities exposed to the user. Here is a simple example of how it can be used:
HPX
HPX and C++ Task Blocks
The quest for finding efficient, convenient, and widely usable higher level parallelization constructs in C++ is continuing. With the standardization document N4411, a group of authors from Intel and Microsoft propose thetask_blockfacility which formalizes fork-join parallelism. From the paper (slightly edited):
HPX and C++ Executors
The STE||AR Group has implemented executors in HPX which, as proposed by the C++ standardization proposal called ‘Parallel Algorithms Need Executors’ (document number N4406), are objects that choose where and how a function call is completed. This is a step in the right direction for HPX and parallelism because executors give more flexibility on how and where task based work should be accomplished and gives the programmer a means to compose executors nicely with execution policies inside of algorithm implementations.
HPX Archives Now on Gmane
In order to make searching and accessing the HPX mailing lists easier, we have made the hpx-users and hpx-devel archives available via Gmane. This service allows users to browse posts through the use of several formats including two web interfaces, an NINTP newsreader, and a RSS feed. These interfaces will help get questions, answers, and other detailed information about HPX out to the public in an easily consumable format. Try it out!
C++Now 2015 Trip Report: HPX is in the Air
This year’s C++Now was a great experience and an exciting time for HPX! After a bumpy travel to Aspen for most of the attendees, the conference started with a great keynote by Andrew Sutton on C++ Concepts (lite) on Tuesday last week. The 3 attendees from the STE||AR Group were still busy preparing their talks: “Back to the Future” (for Wednesday) and “Parallelizing the STL” (for Friday). So the day went by with other interesting talks and discussions.
HPX and the C++ Standard
While developing HPX, it has always been a goal to create an API which is as easy to learn and use as possible. We quickly realized that almost all of our functionality can be exposed through the interfaces which are already standardized as part of the C++11 standard library or which are being proposed for standardization over the next years. So we made it our goal to conform to the C++ standard documents and proposals as closely as possible. This decision has fundamental impact on almost all aspects of our work on HPX.
HPX V0.9.10 Available!
The STE||AR Group is proud to announce the release of HPX v0.9.10! In this release our team has focused on making large scale runs simple and reliable. With these changes we have currently shown the ability to run HPX applications on up to 24,000 cores! Other major features include new parcel-port (network-layer) implementations, variadic template support, more parallel algorithms, and the first distributed data structure, hpx::vector.
STE||AR Group Accepted as a GSoC 2015 Mentor Organization
The STE||AR Group is proud to announce that it has been accepted as a mentoring organization in the Google Summer of Code 2015 (GSoC) program! This program pays students to work on open source projects for three months over the summer. While the timeline is short, the experience can leave a lasting impression. In fact, some of us met professionally through past GSoC programs. The next step in the process is for students who wish to participate to write proposals for the work that they would like to do over the summer. To get some ideas of what STE||AR projects are available, please checkout our GSoC Project Ideas page here. We encourage all interested students to contact us with their questions and project ideas at hpx-users@stellar.cct.lsu.edu. We are looking forward to a great summer of code!
HPX: A tool for building a Scalable Future
As HPX has grown from a small experiment to an international project with much promise, many of us have begun to stop and make comparisons of HPX to other runtime systems and established threading libraries. After submitting papers, we get uncomfortable when reviewers point out some of the improvements that need to be made in HPX. While it is good to listen and react to criticism, I believe we should never let implementation problems in HPX get under our skin. At the end of the day, HPX is just a tool for getting us where we want to be. What we are really working toward is far grander.
One of the reasons I believe the STE||AR Group has been successful so far is that we strive to create a new era in computing. Our vision of this future is based on two fundamental beliefs. We believe that the challenges we have in the face of exascale computing can be tackled by properly by abstracting the principles of the ParalleX model and that the C++ concurrency model is the API that can provide us that abstraction. By extending the C++ model to become aware of the distributed nature of today’s compute resources, we believe that application developers will have the tools to seamlessly write scalable, sustainable, and fault-tolerant code. I believe it is this vision that draws new people to HPX, not the code base itself. Many of our collaborators that we work with now, joined the team not because HPX was the perfect tool for them, but because the potential that HPX offered. This potential, combined with the vibrant and growing community around HPX, is our most valuable asset.
HPX is not yet perfect. We have a long way to go to make it ready for the future. It is quite probable that, in order to implement this grand vision we will have to scrap large swaths of code, include great ideas born in other projects, and at times replace the work that we have put our blood sweat and tears into. However, I believe this commitment to the vision and not to the product is what makes our work so successful. We see the future and we are on our way!
HPX V0.9.9 Available!
The STE||AR Group is proud to announce the availability of HPX V0.9.9! You can download the release version or checkout the latest version from Github. With 200 bug fixes and 1,500 commits, V0.9.9 introduces several improvements including:
- Completing the refactoring of hpx::future to be properly C++11 standards conforming
- Overhauling our build system to support newer CMake features to make it more robust and more portable
- Implementing a large part of the parallel algorithms proposed by C++ Technical Specifications N4104, N4088, and N4107
- Adding examples such as the 1D Stencil and the Matrix Transpose series
- Remodeling our testing infrastructure which will allow us to quickly discover, diagnose, and fix bugs that arise during development
For more details about these changes please see the release notes here.
This is an exciting time of growth for the STE||AR Group. As HPX has become more robust we have begun to build higher level abstractions both in HPX and on top of it. These abstractions such as our work in parallel algorithms and libraries like LibGeoDecomp allow the strong scaling benefits of techniques like futurization to be even more user friendly and accessible. In addition to new ways of expressing parallelism, our group has also made impressive improvements in integrating different architectures into a single simulation. Libraries like HPXCL are exploring new ways of distributing work to GPUs and other accelerators. You can view our technology live at the LSU booth at the Supercomputing Conference 2014. See you there!
More and more people are beginning to recognize the potential of managing concurrency with C++. If exploring new ways to exploit parallelism interests you, check us out! Now has never been a better time to download HPX and become a pioneer of scalability. 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 hpx-users@stellar.cct.lsu.edu.