CppCon 2015

By ,

Grant Mercer and I had the opportunity to present our talk, ‘Parallelizing the STL’, at Cppcon 2015. We both consider ourselves lucky for being able to attend the conference. The buzz of the atmosphere and C++ community was truly exciting to witness. Attendees were both from all over the world and performance critical industries ranging from gaming and finance to scientific computing. As Jon Kalb highlighted in his talk, C++ is receiving a resurgence for several performance related reasons: Moore’s Law is coming to end and the subsequent shift to multi-core architectures, increased computational demands from the private sector, and the rise of power constrained mobile architectures. Combined with the interest in the standardization process, C++17 and beyond, there was a palpable excitement.

The buzz was only complemented by the number of great talks. The opening keynote by Bjarne Stroustrup introduced the C++ core guidelines (github.com/isocpp/CppCoreGuidelines) to limit resource leaks, ensure static type safety and provide proscriptive guidelines that teams can follow. The idea is to support open dialogue so that better tools can be used and cleaner code can be written. The guidelines were a theme of the conference. Herb Sutter’s day 2 keynote showed off what the upcoming editions of Microsoft visual studio can catch. Aside from a push to more compatible C++ tools, upcoming language features were shown. Friday’s keynote by Eric Niebler demonstrated the upcoming ranges proposal. He introduced programming with his ranges library that he hopes to be in the future STL2. Using ranges, he created a calendar that had no for loops, used lazy evaluation and had immutable types that can serve to limit bugs.

Grant and I delivered our talk on Tuesday where we introduced how the parallel algorithms are implemented inside of HPX and how the application developer can communicate with the algorithm. We wanted to highlight first that the we can communicate the with algorithms via execution policies and there associated executors and executor parameters and second, that we did this through a generic partitioning scheme. As this being my first talk, I was quite nervous! Luckily, there were other students and certainly, a little bit nerves doesn’t outweigh getting to be a part of the C++ community.

HPX Tutorial Promo Video

As a build up for our Supercomputing tutorial, the STE||AR Group has put together a promotional video to generate interest in HPX. The video gives viewer a high level overview of what HPX is and what will be discussed at the tutorial. The SC15 Tutorials Committee will circulate this and other tutorial videos on its YouTube playlist. We would like to thank our colleague Randy Dannenberg and his students for helping us put this together!

On Tour: HPX Tutorial at SC15!

Howdy! The STE||AR Group welcomes you to participate in a hands on HPX tutorial which will be given this year in Austin, Texas as part of the SC Tutorials program. STE||AR Fellows from Louisiana State University, Friedrich-Alexander Universitat, Lawrence Berkeley National Laboratory, and University of Oregon will present “Massively Parallel Task-Based Programming wih HPX” which will consist of five parts:

  1. HPX: a New Paradigm – A high level overview of the kinds of parallel programming problems C++11/14 and HPX were designed to address. The presentation will focus on use of futures, including waiting for a future, chaining subsequent actions to a future, and composing futures both within and across machines.
  2. An Introduction using Lua – This section of the tutorial will demonstrate HPX concepts by utilizing a Lua wrappers library. Examples of a simple serial Lua code will be converted, step by step to run in parallel on a single machine, and then in a distributed environment. We intend for this part of the tutorial to explain the mindset behind HPX applications without necessarily needing to be intimately familiar with the C++11/14 standard. Interactive code execution will be made available through a web site, as well as through a virtual machine.
  3. Digging into the C++ – This section of the tutorial will start with teaching the basic C++11/14 concurrency mechanisms, then branch out to writing HPX applications using simple serial code examples (similar to the Lua code) which will be transformed into fully parallelized, distributed applications.
  4. GPUs and Xeon Phis – Here we will demonstrate how the HPX concepts introduced in the previous sections can be seamlessly integrated with the use of accelerators and co-processors. We will demonstrate how by simply recompiling the application on the device you can run HPX code on the Xeon Phi. Additionally, we will introduce the HPXCL library which enables users to take advantage of the GPU, the CPU or the Phi by integrating OpenCL kernels into their codes and distributing them across a heterogeneous machine.
  5. Performance Analysis of HPX – Finally, we will introduce the TAU Performance System and the policy engine APEX for instrumentation of the applications and runtime. The hands-on session will include an exercise for performance assessment using these performance evaluation tools.

By the end of this tutorial, we hope that participants will have a clear understanding of the HPX approach to parallelism, as well as some hands on experience writing HPX applications. We plan to target C++ application developers, researchers, and programmers who are interested in application scalability, performance evaluation, and distributed computing. We are very excited to have the opportunity to present HPX in such a visible venue as the SC Tutorial program. Don’t forget to stop by after the tutorial and say hi at the Louisiana State University booth on the showroom floor. See you in November!

HPX and C++ Executors

By: Daniel Bourgeois

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. Continue reading

HPX Mailing List 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 NNTP 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!

Mailing Lists:

GSoC 2015 Participants Announced!

We can now announce the participants in the STE||AR Group’s 2015 Google Summer of Code! We are very proud to announce the names of those 5 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. Continue reading

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. Continue reading

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 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
  • Significantly improved the documentation
  • 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. Continue reading

HPX V0.9.9 Release Candidate 1 Available!

The STE||AR Group is proud to announce the availability of the first HPX V0.9.9 release candidate! Please checkout and test the new version by pulling from the release branch here on GitHub.  If you run into any issues, please let us know by submitting a bug report.  We want this release of HPX to be our most stable release yet!

In this release we have introduced several improvements including:

  • Completing the refactoring of hpx::future to be properly C++11 conforming
  • Overhauled our build system to support newer CMake features
  • Implemented half of the parallel algorithms proposed by C++ Technical Specifications N4104, N4088, and N4107
  • Remodeled our testing infrastructure which will allow us to quickly discover, diagnose, and fix bugs that arise during development

We would like to thank everyone involved with this release especially those who spent countless hours developing, bug fixing, testing, documenting, and listening to the occasional IRC rant.  We couldn’t have done it without you!