CppCon Program Highlights, 4 of N: C++ and Modern Concurrency

The CppCon 2014 conference program has been posted for the upcoming September conference. We've received requests that the program continue to be posted in "bite-sized" posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.


CppCon would be incomplete without strong coverage of concurrency-related techniques. But this year's material isn't about just any old concurrency techniques -- it's about stitching high-update-rate data structures and highly responsive algorithms into high performance scalable code. As always, these talks are by the right people -- Those Who Know and Those Who Do in some of the leading efforts in our industry, from *nix to Windows and from IBM to Microsoft to BlackBerry.

In this post:

  • C++ Memory Model Meets High-Update-Rate Data Structures
  • Lock-Free Programming (or, Juggling Razor Blades)
  • Lock-Free by Example
  • Async Sequences and Algorithms to Compose Them


C++ Memory Model Meets High-Update-Rate Data Structures

Highly performant and scalable techniques such as RCU and hazard pointers have been quite successful in read-mostly situations. However, there do come times when updates are necessary. It would be convenient if there was some general update-side counterpart to these techniques, but sadly there is not yet any such thing. Nevertheless, there are a number of specialized update-side techniques whose performance and scalability rival those of RCU and hazard pointers. This talk will discuss several of them, one of which is a solution to a challenge to the speaker at the 2014 Issaquah C++ standards committee meeting. This talk will also provide an outlook into the future of low-overhead scalable updates.

Speaker: Paul E. McKenney, Distinguished Engineer, IBM Linux Technology Center. Paul E. McKenney has been coding for almost four decades, more than half of that on parallel hardware, where his work has earned him a reputation among some as a flaming heretic. Over the past decade, Paul has been an IBM Distinguished Engineer at the IBM Linux Technology Center. Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present highly entertaining performance, scalability, real-time response, and energy-efficiency challenges. He is also the editor of "Is Parallel Programming Hard, And, If So, What Can You Do About It?" Prior to that, he worked on the DYNIX/ptx kernel at Sequent, and prior to that on packet-radio and Internet protocols (but long before it was polite to mention Internet at cocktail parties), system administration, business applications, and real-time systems. His hobbies include what passes for running at his age along with the usual house-wife-and-kids habit. Website: http://www.rdrop.com/users/paulmck


Lock-Free Programming (or, Juggling Razor Blades)

Example-driven talk on how to design and write lock-free algorithms and data structures using C++ atomic -- something that can look deceptively simple, but contains very deep topics. (Important note: This is not the same as my "atomic Weapons" talk; that talk was about the "what they are and why" of the C++ memory model and atomics, and did not cover how to actually use atomics to implement highly concurrent algorithms and data structures.)

Speaker: Herb Sutter, Microsoft. Author, chair of the ISO C++ committee, software architect at Microsoft.


Lock-Free by Example

Dive into and follow along making a lock-free queue. In particular, a multi-producer, multi-consumer, growing, shrinking, mostly contiguous, lock-free circular queue. With this single (complicated!) example, we will come across, and attempt to solve, many of the typical problems found in lockfree programming, and delve into the pros and cons of various solutions to those problems.

Speaker: Tony Van Eerd, C++ Guy, BlackBerry. Tony Van Eerd has been coding for well over 25 years, and hopefully coding well for at least some of that. Most of that time has been in the graphics/video/film/broadcast industry (at Inscriber/Adobe), writing low level pixel++, high level UI, as well as threading and everything else in between. He now works at BlackBerry, watching over the BlackBerry APIs. He is also the company-wide "C++ guy" writing half of his code in emails and wiki pages.


Async Sequences and Algorithms to Compose Them

All have heard and some have wept over all the many ways to express sequences (eg. iterator, range, container) and the algorithms to compose them (eg. filter, transform, merge, zip) in C++. I will describe one more sequence that must have a representation and an algorithm library - A sequence of values that will arrive over time.

Speaker: Kirk Shoop, Developer, Microsoft Open Technologies, Inc. Hi! I have a family. I like food. I need sun (My need for sun must be why I live in Seattle). I like C++. I don't like threads (My aversion to using threads must be why I spend all my free time working on a library that composes sequences on many threads). I work at Microsoft Open Technologies, Inc.Website: http://kirkshoop.blogspot.com/Twitter handle: @kirkshoop


Add a Comment

Comments are closed.

Comments (0)

There are currently no comments on this entry.