Sessions

Note: Click the title of any session to visit its start time in the conference schedule.

A Complete Overview on Boost.Jam and Boost.Build

Speaker: Boris Schaeling
Format: lecture

The Boost libraries come with their own build tool Boost.Build. While Boost.Build was developed for the Boost libraries, it can be used for any C++ project. Many developers struggle though to setup Boost.Build for C++ their projects due to the lack of documentation.

This session will provide a complete overview on Boost.Jam and Boost.Build. It will explain the difference of Boost.Jam and Boost.Build and how configuration files – so-called Jamfiles – are used to setup projects. It will introduce Boost.Jam language constructs and Boost.Build concepts like targets and features. It will also explain how Boost.Build decides what to build how and how generators are used to extend the build tool. The presentation will be given from a user’s point of view and will provide all the information developers need to easily setup Boost.Build for their own projects.

Are You Ready for IPv6?

Speaker: Christopher Kohlhoff
Format: lecture
Track: Track II 2011

It has been all over the news: the IPv4 address space is officially exhausted. The solution is a new Internet Protocol, IPv6. IPv6 has been around for a long time, but unless you develop code for a government department that has mandated its use, chances are you’ve never had to worry about it until now.

This isn’t going to be an overnight change. IPv4 is going to stick around fora few years yet, and networked applications are going to have to support both protocols.

This presentation covers the basics of IPv6 that a network developer needs to know. We’ll take a tour of Boost.Asio’s support for IPv6, and discuss different design strategies for making Boost.Asio-based networked applications protocol independent and IPv6 ready.

AST Construction with the Universal Tree

Speaker: Bryce Lelbach
Format: tutorial
Track: Track I 2011

utree, a recent addition to the Boost.Spirit codebase, is a generic data structure designed to represent abstract syntax trees. Bindings to Qi and Karma make utree a powerful tool for parser and generator development with Boost.Spirit. This presentation would demonstrate the usage of utree and Spirit to build and manipulate an abstract syntax tree for four parsing/generating use cases: XML, symbolic expressions, JSON, and C-like source code. The details of utree’s integration with Spirit and their implications for writing utree-centric Spirit parsers and generators would be discussed. Additionally, design patterns for compiling a utree AST to other internal representations (DOM tree for XML, function tree for a Scheme-like language for symbolic expressions, associative arrays for JSON objects, a simple VM bytecode for mini-C source code) would be covered.

Automatic Hybrid MPI+OpenMP Code Generation

Speakers: Joel Falcou, Khaled Hamidouche
Format: lecture
Track: Track II 2011

The emergence in the market of multi-core processors is radically changing the architecture of massively parallel computers. High-Performance Computing platforms with many thousands of cores are being deployed. In this context, using a hybrid MPI+OpenMP approach is regarded as a suitable programming model for such architecture. But, if some work exhibit performance improvement, some does not. Factors affecting a hybrid MPI and OpenMP application’s performance are numerous, complex and interrelated:

MPI communications efficiency: applications related problems such as MPI routine types (point to point, collective), message size and network related problems such as network connection and bandwidth.

OpenMP parallelization efficiency: using critical section primitives, OpenMP threads management overhead and false sharing can reduce the performances.

MPI and OpenMP interaction: problems of load balancing and idle thread inside the MPI communication part reduce the parallel efficiency.

Writing both code may require higher level of expertise than for regular HPC applications.

Therefore, the efficient use of these new systems is an important challenge, and the scientists and engineers responsible for these applications, in general, are seldom experts in HPC, and usually do not want either to introduce new changes in their codes or to learn new programming paradigms. They need solutions in terms of effective automatic parallelization tools and libraries.

In this presentation, we will try to solve these problem on two different yet interrelated level.

First, we’ll quickly introduce the Bulk Synchronous Parallelism paradigm and show when and why it can be seen as a suitable programming model for hybrid systems.

Then, we’ll present BSP++, a Boost enabled C++ library allowing quick and easy design of parallel applications based on the BSP model. We’ll describe BSP++ API, its interaction with commonly used Boost libraries including lambda, phoenix or MPI, some implementation details and present some examples.

Finally, we’ll present BSPGen which is a parallel programming framework built on top of BSP++, Boost.Spirit and the Clang/LLVM suit. BSPGen is able to take a small applications descriptions written in XML, a set of sequential C or C++ functions and generate a complete hybrid parallel application based on the a priori evaluation of the application runtime cost and a small exploration of a configuration space to find the near-optimal balance between OpenMP and MPI sections. Implementations details and examples will be provided.

BoostCon 2012 Kickoff Meeting

Speakers: Dave Abrahams, Hartmut Kaiser
Format: panel

To ensure a successful BoostCon’12, we’ll need to start planning now. Be a part of the process!

Boost.Generic: Concepts without Concepts

Speaker: Matt Calabrese
Format: tutorial
Track: Track I 2011

Concepts were perhaps one of the most desired features of C++0x. With them, programmers were promised direct language support for generic programming including, notably, support for specifying concepts directly in code rather than comments, concept-based overloads, and improved template error messages. With their removal from the working paper in 2009, many programmers were left greatly disappointed as it would likely be quite a few years before they would make a return in a future C++ standard.

However, for well over a decade, C++ programmers have managed to create very powerful generic libraries, including the Boost Graph Library, without direct language support. The Boost Concept Check Library has made the process of verifying concept requirements feasible, but with C++0x, even with concepts removed, it is possible to take things a step further. With effort, a library can and does provide even simpler, more specific compile-time assertions, more powerful ways to express and check concept requirements, facilities for user-specified automatic and explicit concept maps, and ways for users to write concept-based function template overloads, all with usability that comes surprisingly close to what one might expect from full-on language features.

This talk is an introduction to Boost.Generic (pending review) — a C++0x library for creating concepts, concept maps, and concept-based function template overloads, intended as a potential replacement or compliment to the Boost Concept Check Library. The presentation will first briefly cover the basics of generic programming for those unfamiliar with the paradigm, followed by a history of the library and an introduction to the few, fundamental underlying tricks that make the library possible. The audience will then be shown basic usage of Boost.Generic, such as how to specify compile-time asserts for checking requirements of concepts already provided by the library, how to create simple concept maps to those concepts, and how to write concept-based overloads for their own algorithms. Finally, the audience will be walked through the implementation of standard concepts with Boost.Generic including side-by-side comparisons with their specification in the standard.

"Boost.Generic: Concepts without Concepts" is intended both for library developers and for users. It should be accessible to programmers with any reasonable amount of experience in C++. Familiarity with generic programming is highly recommended, though the fundamental ideas will be covered during the first few minutes of the talk.

Boost Infrastructure Workshop (Mon)

Speaker: Dave Abrahams
Format: workshop
Track: Track I 2011

Boost’s code and community have been, and continue to be, a great success. Operationally, though, we haven’t evolved at the same rate as our codebase. Testing could be faster, installation could be easier, generating documentation could be smarter, reviews could garner more participation, and maintaining libraries could be more fun. For years we’ve talked about ways to address these issues, but we have neither generated the consensus nor the momentum to actually make the changes. This workshop is a chance to do something on these fronts, together.

Each day of the conference, we’ll meet for 90 minutes to develop policy, create tools, and set up web services that can support Boost’s evolution through the next decade. The specific goal is to prototype and implement useful improvements in how-Boost-works that gain consensus among conference participants and in the wider community, and will be adopted soon after BoostCon. We only have a week, so to maximize productivity we’ll work in small groups on individual topics of interest. To ensure we are headed in directions that Boost can accept, we’ll conduct several short votes and solicit feedback on the Boost mailing list throughout the week.

Enough Boost moderators and release managers plan to be present at BoostCon that we can hope to move well-received ideas forward in the months following the conference.

Boost Infrastructure Workshop (Thu)

Speaker: Dave Abrahams
Format: workshop
Track: Track II 2011

Boost’s code and community have been, and continue to be, a great success. Operationally, though, we haven’t evolved at the same rate as our codebase. Testing could be faster, installation could be easier, generating documentation could be smarter, reviews could garner more participation, and maintaining libraries could be more fun. For years we’ve talked about ways to address these issues, but we have neither generated the consensus nor the momentum to actually make the changes. This workshop is a chance to do something on these fronts, together.

Each day of the conference, we’ll meet for 90 minutes to develop policy, create tools, and set up web services that can support Boost’s evolution through the next decade. The specific goal is to prototype and implement useful improvements in how-Boost-works that gain consensus among conference participants and in the wider community, and will be adopted soon after BoostCon. We only have a week, so to maximize productivity we’ll work in small groups on individual topics of interest. To ensure we are headed in directions that Boost can accept, we’ll conduct several short votes and solicit feedback on the Boost mailing list throughout the week.

Enough Boost moderators and release managers plan to be present at BoostCon that we can hope to move well-received ideas forward in the months following the conference.

Boost Infrastructure Workshop (Tue)

Speaker: Dave Abrahams
Format: workshop
Track: Track II 2011

Boost’s code and community have been, and continue to be, a great success. Operationally, though, we haven’t evolved at the same rate as our codebase. Testing could be faster, installation could be easier, generating documentation could be smarter, reviews could garner more participation, and maintaining libraries could be more fun. For years we’ve talked about ways to address these issues, but we have neither generated the consensus nor the momentum to actually make the changes. This workshop is a chance to do something on these fronts, together.

Each day of the conference, we’ll meet for 90 minutes to develop policy, create tools, and set up web services that can support Boost’s evolution through the next decade. The specific goal is to prototype and implement useful improvements in how-Boost-works that gain consensus among conference participants and in the wider community, and will be adopted soon after BoostCon. We only have a week, so to maximize productivity we’ll work in small groups on individual topics of interest. To ensure we are headed in directions that Boost can accept, we’ll conduct several short votes and solicit feedback on the Boost mailing list throughout the week.

Enough Boost moderators and release managers plan to be present at BoostCon that we can hope to move well-received ideas forward in the months following the conference.

Boost Infrastructure Workshop (Wed)

Speaker: Dave Abrahams
Format: workshop
Track: Track II 2011

Boost’s code and community have been, and continue to be, a great success. Operationally, though, we haven’t evolved at the same rate as our codebase. Testing could be faster, installation could be easier, generating documentation could be smarter, reviews could garner more participation, and maintaining libraries could be more fun. For years we’ve talked about ways to address these issues, but we have neither generated the consensus nor the momentum to actually make the changes. This workshop is a chance to do something on these fronts, together.

Each day of the conference, we’ll meet for 90 minutes to develop policy, create tools, and set up web services that can support Boost’s evolution through the next decade. The specific goal is to prototype and implement useful improvements in how-Boost-works that gain consensus among conference participants and in the wider community, and will be adopted soon after BoostCon. We only have a week, so to maximize productivity we’ll work in small groups on individual topics of interest. To ensure we are headed in directions that Boost can accept, we’ll conduct several short votes and solicit feedback on the Boost mailing list throughout the week.

Enough Boost moderators and release managers plan to be present at BoostCon that we can hope to move well-received ideas forward in the months following the conference.

Boost Library in a Week — The Bleeding Edge (Kickoff)

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

Boost is all about creating the next thing in C++ libraries. As a result there’s a persistent froth of new libraries being proposed, developed, and introduced. Currently 16 libraries in the review queue alone — many more in the sandbox and vault. Thus, this year’s Library in a Week will depart a bit from its library building roots and shift more toward learning, reviewing, and jumpstarting Boosters on up and coming Boost libraries.

The group will divide into teams and select up and coming Boost libraries of interest to present and discuss in the morning sessions. The goals will be to get Boosters familiar with upcoming libraries and their potential, as well as provide feedback to library authors. As a basic starting point we will use the current review queue libraries (Join, Pimpl, Endian, Conversion, Sorting , AutoBuffer, Containers , Lockfree, Fiber, Quaternions- Vectors-Matrices, Stopwatches, Variadic Macro Data, Type Traits Introspection, Block Pointer, Heaps, Assign v2), but it will be up to participants which libraries they would like to bring forward for discussion. We will also attempt to apply cutting edge review technologies as part of the session to see if it would be a useful addition to the review process.

Boost Library in a Week — TBA (Tue)

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

Boost Library in a Week — TBA (Tue)

Boost Library in a Week — TBA (Wed)

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

Boost Library in a Week — TBA (Wed)

Boost Library in a Week — TBA (Thu)

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

Boost Library in a Week — TBA (Thu)

Boost Library in a Week — TBA (Fri)

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

Boost Library in a Week — TBA (Fri)

Boost.Process: Process management in C++

Speaker: Boris Schaeling
Format: brainstorming
Track: Track II 2011

Boost.Process is a library under construction to manage system processes. It should be used to run shell commands, create child processes, setup environment variables and standard streams for child processes, communicate with child processes both synchronously and asynchronously and wait for child processes to terminate – or kill them.

A first version of the library was created five years ago. Since then the library went through a lot of changes: Many ideas have been tried and were rejected. In this session we want to look at those ideas, understand why they didn’t work out and what we learnt and discuss new ideas for Boost.Process.

Boost.Units

Speaker: Steven Watanabe
Format: tutorial
Track: Track II 2011

Boost.Units is a flexible library for compile time dimensional analysis and unit conversions. It is designed to reduce programming errors by allowing users to declare exactly what a value is supposed to repesent, forbidding operations that don’t make sense, and applying conversions where necessary.

C++0x Progress and Status

Speaker: Michael Wong
Format: lecture
Track: Track I 2011

As we close in on ratification of C++0x this year, this 1.5 hour talk will review what are the controversial issues of the last year (2010- present) since the previous update in BoostCon 2010, describe the ratification progress so far, as well as give details of various new features that have been designed since the previous update, the controversies that have arisen, and the problem they were meant to resolve. This talks from a long-standing IBM and Canadian C++ Standard Committee member is aimed at an intermediate level of C++ expertise but is accessible to all.

Conference registration and Sign-In '11

Format: social event

Conference registration and Sign-In

Creating Boost.Asio extensions

Speaker: Boris Schaeling
Format: tutorial
Track: Track I 2011

Boost.Asio is best known as the portable network library of the Boost C++ libraries. The library hasn’t been called Boost.Net though for a reason. The real strength of Boost.Asio is the framework it provides to implement asynchronous operations. Network functions are just very good examples of asynchronous operations.

This tutorial explains how Boost.Asio can be extended and new asynchronous operations can be implemented. We’ll have a look at existing extensions like a directory monitor to watch files and directories. We’ll also have a look at asynchronous operations which don’t fit into the framework and show the limits of Boost.Asio.

Design Journeys with Skoot, a Peer Oriented Generic Networking Library

Speaker: Cliff Green
Format: tutorial
Track: Track I 2011

The road to an effective, elegant, and generic C++ library always involves wrong turns, dark alleyways, and squeeks of frustration as the virtual GPS malfunctions. The journey can also be exhilarating and immensely satisfying as the API solidifies and the functionality proves itself everywhere it is used. This presentation discusses many of the design tradeoffs and Boost libraries involved with the Skoot library.

Skoot is a generic C++ networking library, useful in distributed, peer-oriented processing environments. It simplifies and abstracts many common communication patterns and usages in TCP and UDP programming. It uses many Boost libraries, including Asio, Function, Bind, Shared (and Weak) Pointer, and Optional.

Many C++ developers only see the end result of the many hours that go into a generic library, and don’t see the decisions that were made along the way. When does it make sense to templatize a class, versus using some form of type erasure? Why are template functions and function objects so powerful, while many C++ developers only appreciate template classes? How do I keep my references alive to an object that might be destructed at any time? What is this magic Boost library named Bind and why is it better than a glittering vampire in a forest of fir trees? What do you do when you need virtual template methods in C++? Should Chris
Kohlhoff, Asio author, receive a Nobel prize, or merely a lesser but still important award?

Most of these questions were addressed while developing Skoot, and explaining them to developers that have not quite reached Boost guru levels can be enlightening. The audience for this presentation is experienced C++ developers that are still learning generic, template based design techniques, as well as those interested in how Function and Bind (and other Boost libraries) were used as fundamental building blocks. Library use cases, API design and refinement, and creating good unit tests will also be discussed.

(Bio: Cliff is a long-time C++ developer currently working for Boeing in the Seattle area. Most of his software career has involved networking and highly available distributed processing in multiple computer languages, and he still has a soft spot for Prolog. Cliff has worked in multiple startup companies, all now dot-gones or dot-bought-outs, and appreciates a steady paycheck, even while occasionally missing the now worthless stock options.)

Distributed parametric optimization with the Geneva library

Speaker: Ruediger Berlich
Format: tutorial
Track: Track I 2011

This presentation introduces Geneva, an Open Source library of distributed optimization algorithms that is heavily based on the Boost library collection. Geneva currently covers gradient descents, evolutionary- and swarm algorithms, and will soon also include simulated annealing. All algorithms act on the same data structures, so that candidate solutions can move freely between optimization algorithms. Geneva allows the solution of large-scale parametric optimization problems on multi-core systems and clusters, as well as in Grid- and Cloud-environments. The library has been tested with several hundred clients, simultaneously working on optimization problems. Among the libraries used are: Boost.Serialization, Threads, Conversion, Date/Time, Function, Bind, and many more. The presentation discusses the Geneva library itself, as well as the experiences made with Boost, from a user’s perspective.

Fast numerical computation in C++: Expression Templates and Beyond to Lazy Code Generation (LzCG)

Speaker: Bojan Nikolic
Format: tutorial
Track: Track I 2011

Expression templates are an important feature of C++ that enables very significant optimisation of numerical calculations. They are used in Boost’s uBLAS library as well as other well-known numerical C++ libraries (e.g., the pioneering Blitz++, Armadillo). Yet, none of the "gold standard" numerical libraries (e.g., ATLAS and FFTW) are written in C++. Why not? In the first part of the talk I will review the challenge of optimising numerical computations, how expression templates are used to do this and the fundamental factors which limit what expression templates can achieve in practice.

In the second part of the talk I will present how some often-used numerical computation frameworks are able to achieve performance beyond that which is typically achieved by C++-only libraries. The critical features of these libraries are: complex code generation, adapting to the precise hardware they are run on, and ability to benchmark a sizable number of different implementations before selecting the one to be run.

Finally, I will discuss how one can improve C++ performance beyond that offered by expression templates on their own. I will present a new, prototype, framework demonstrating how this is done in practice.

Funding Boost development through national and international research programs and funds

Speaker: Ruediger Berlich
Format: panel
Track: Track II 2011

This presentation wants to start a discussion about possible ways of leveraging national and international research programs and funds to support Boost development.

The goals are threefold:

  1. To start and organize a joint effort in many countries to leverage national and international research funding schemes (e.g. NSF, European Union, …) for the benefit of Boost development
  2. To make Boost a standard topic in the curricula of computer science education at universities and polytechnicals around the world
  3. To involve new protagonists from the science community in Boost development

Future of Boost Panel '11

Speakers: Dave Abrahams, Beman Dawes, Jeff Garland, Eric Niebler
Format: panel

Boost has a small group of moderators that keep the mailing list running including approving posts and moderation to keep the mailing list on-topic, respectful, and useful. In addition, they administer internals of the website, source repository and other administrative machinery. And last, but not least, the moderators also act as an informal executive overseeing committee to promote all things Boost.

In this session, each moderator will be given 5 minutes to say something about their vision of the future of Boost, but the majority of the session will be devoted to questions and proposals from the audience. This is your chance to ask or propose absolutely anything about the direction of the Boost community. For example, why we don’t adopt a particular policy, tool, or idea.

General Conference Welcome '11

Format: social event

General Conference Welcome, Introduction, Organizational Announcements

Generic Conversion and Segmentation for Ranges: a Solution for Unicode

Speaker: Mathias Gaunard
Format: tutorial
Track: Track II 2011

There has always been much demand for a solution in Boost to deal with Unicode, the industry standard to consistently represent and manipulate text across most of the world’s writing systems. In this talk, we present our solution which was initially started during the Google Summer of Code 2009. Based on the concept of Range, it is lightweight, non-intrusive, flexible and generic, and potentially lazy too.

To make the algorithms generic, they were all rewritten, and as such the library does not depend on any existing Unicode solution. The library requires some external data, but albeit the library embeds its own database, there is a clear and stable ABI that can be used to link the library with another database.

The need for a Unicode library has led to another library as a spin-off: Convert, a library that allows to easily convert ranges using N to M transformations or to segment them; be it eagerly or lazily as the ranges are iterated. It also provides facilities to help in the development of SIMD-accelerated transformations. While that library was initially made for Unicode, we show it can be used for a variety of things unrelated to character encoding conversion.

Getting Jiggy with Proto — Hands-on Tutorial on C++ EDSL Design

Speaker: Joel Falcou
Format: tutorial
Track: Track II 2011

Embedded Domain Specific Languages are actually rising as a design of choice to handle small to middle sized problem in a declarative and efficient way. Among others, C++ is actually a pretty interesting choice for a host languages of such development thanks to libraries like Boost.Proto.

This tutorial aims at giving a quick start on using Proto in realistic situation and to demonstrate that Proto-enabled code is both elegant, compact and efficient.

The tutorial will be structured as:

  • a short presentation of the basic block of the library
  • a guided exercise that will go from a simple calculator code to a prototype for a analytical function derivation system with an extensible core. This exercise will demonstrate the various steps of building an EDSL with Proto and uncover some Proto specific idioms.

Participants should be intermediate or advanced C++ users with some background in template meta-programming. Watching last year Eric Niebler’s talk on Proto could be a benefit.

The files for the tutorial are here:

https://github.com/MetaScale/boost-con-2011/tree/master/proto

This github repository contains the needed file for walking down the tutorial. It can be fetched either via git clone or by the Download button on the github page. Solution for each step live in the solution/ folder if you ever get caught stuck.

All files were tested using g++ and boost 1.46.1 and trunk from 05/10.

Haskell – The Pseudocode Language for C++ Template Metaprogramming

Speaker: Bartosz Milewski
Format: tutorial
Track: Track I 2011

C++ template metaprogramming is hard to use, analyze, or debug. The main reason is that compile-time C++ is a functional language with abominable syntax. The key to successful metaprogramming is to become familiar with functional programming and develop a language to describe C++ metaprograms in pseudocode. Such a pseudo-code language already exists and is called Haskell. I will introduce Haskell in parallel with equivalent C++ meta-code. I will show how to read and write complex metaprograms in C++ using Haskell. Finally, I will show what a monad is and how to use it to explain "runnable templates" in C++.

Informal Gathering at Meadows Bar '11

Format: social event

Get to know your fellow Boosters and catch up with old friends. Bring your families and companions.

Intel's C++ Software Transactional Memory Compiler and the Draft Specification of Transactional Language Constructs for C++

Speaker: Justin Gottschlich
Format: tutorial
Track: Track I 2011

Transactional memory (TM) promises to simplify parallel programming by moving the complexity of shared memory management away from the programmer’s view. In this talk, we present the latest version of the Draft Specification of Transactional Language Constructs for C++ and its practical implementation within Intel’s C++ software transactional memory (STM) compiler.

Boost library writers aim to write highly optimized and type-safe software. Because of this, in this talk we make a special effort to demonstrate how transactions in the Intel C++ STM compiler achieve rigid type-safety and optimization. In particular, we show how transactions can be used for complex operations, such as template declarations, member initialization lists, and failure atomic expressions (known as transaction expressions), as well as basic operations, such as function and class declarations. We also introduce relaxed transactions and demonstrate how irrevocable actions (e.g., actions which cannot be undone, like I/O) are used inside of them. We close with a roadmap for the Draft Specification of Transactional Language Constructs for C++ and an open, audience-driven discussion for proposed extensions to the specification. 

Introducing MPL.Graph

Speaker: Gordon Woodhull
Format: tutorial
Track: Track I 2011

The wild-eyed child of MPL metaprogramming and BGL graph concepts, MPL.Graph is a proposed Boost library for creating and traversing metadata graphs at compile time. Graph data structures and algorithms are applicable at compile time for a variety of purposes. Class hierarchies, expression template trees, state machines, and grammars are fully compile-time graphs. The graphiness of call graphs, ownership of objects, and pointers between objects is partly compile-time and partly run-time. All can be adapted to a standard graph interface in order to run graph algorithms on them, or produced from computed graphs. Specification and analysis using compile-time graphs avoids wasting runtime cycles on abstractions, and improves conceptual clarity and abstraction (once the "meta" barrier is hurdled).

So far, MPL.Graph provides compile-time versions of BGL’s incidence_list and adjacency_list, and the algorithms breadth_first_search and depth_first_search. It is being used in Boost.MSM, where it is currently a sub-library, for identifying regions (connected components) and unreachable states. The talk will present new uses of MPL.Graph (e.g. grammars, heterogeneous graph data structures a.k.a. Fusion graphs), and end with a glimpse at my eventual goal: metagraphs, where compile-time graphs describe runtime "graphs of graphs."

Lockfree Programming Part 2: Data Structures

Speaker: Tony Van Eerd
Format: tutorial
Track: Track I 2011

A brief summary of last year’s Intro talk, then continuing where we left off, with more Lockfree programming "FCD" – Fear, Certainty, and a healthy dose of Doubt. We’ll look mostly at data structures – starting with a simple lock-free stack and its ABA problems, then move on to various lockfree queues, etc.

Mastering the Cell Broadband Engine architecture through a Boost based parallel communication library

Speakers: Joel Falcou, Lionel Lacassagne, Sebastian Schaetz
Format: tutorial
Track: Track II 2011

The Cell Broadband Engine (CBE) is an embedded system that combines a PowerPC processor and up to 8 vector co-processing elements connected via an internal ring bus. It is a suitable platform for multimedia-, signal processing and high performance computing applications.

Current Cell processors (PowerXCell 8i) are specified with a maximum single precision performance of 204.8 GFlops/s and double precision performance of 102.4 GFlops/s. In light of this immense computational power and the architecture’s power efficiency (0.87 double precision GFlops/s per Watt for the IBM BladeCenter QS22), the Cell processor was a relevant alternative to the modern x86 multi-core architecture and general-purpose computation on graphics processing units (GPGPU). Despite these advantages, adoption of the Cell processor has been slower than expected. We attribute this to the novel nature of the architecture and the lack of convenient tools that abstract its intricacies.

In this talk we will present our efforts of creating a library that simplifies the development of efficient applications for the Cell architecture. We will show how we utilize modern C++ concepts and a number of Boost libraries (MPL, PP, Function, Spirit) to create a straight forward interface with underlying high-performance algorithms. We will discuss the challenges that accompany the Cell architecture and how we mastered them.

An integral part of our library is based on message passing – a programming model that lends itself well to the CBE’s system design. Our implementation is based on the Boost.MPI interface and includes asynchronous communication and performance optimized collective operations.

We will also present an implementation of distributed containers and segmented iterators that support asynchronous data transfer and multi-buffering. In addition we will demonstrate a lightweight unit testing module designed after Boost.Test that is especially suited for systems with limited resources.

Finally, we’ll assess the viability of such a software ecosystem for such architecture and how Boost inspired design can leverage performances out of such systems and maybe open discussion on the future of Boost on such specific embedded hardware.

Object-relational mapping with ODB and Boost

Speaker: Boris Kolpackov
Format: lecture
Track: Track II 2011

ODB is an open-source, cross-platform and cross-database object-relational mapping (ORM) system for C++. Unlike other libraries offering a similar functionality, ODB automatically generates the code that performs the conversion between persistent classes and their database representation from C++ class declarations. ODB is also highly customizable. Components such as basic types, smart pointers, and containers from popular frameworks and libraries such as Boost and Qt can be used seamlessly in persistent classes along with the standard versions.

The first half of the talk introduces the basic concepts and workflow of the ODB system. The second half focuses on the ODB profile for Boost, a library that provides support for persisting Boost value types (e.g., boost::gregorian::date), smart pointers (e.g., boost::shared_ptr), and containers (e.g., boost::optional, boost::unordered_set).

Note to the program committee: I am proposing another talk (Parsing C++ with GCC plugins). If both talks are accepted, I would prefer if that talk was scheduled earlier in the week than this presentation. While there is no strict dependency between the two, ODB is a GCC plugin implementation and some of the attendees of the GCC plugin talk may be interested in also attending this talk to learn what can actually be achieved.

Parsing C++ with GCC plugins

Speaker: Boris Kolpackov
Format: tutorial
Track: Track I 2011

GNU Compiler Collection (GCC) is an open-source, cross-platform compiler suite with a mature and widely-used C++ compiler implementation. GCC version 4.5.0 has added a new dynamic plugin architecture which allows the customization of the compilation process as well as the compiler components reuse. The goal of this presentation is to show how to parse C++ using a GCC plugin.

The talk begins with a high-level overview of the GCC plugin architecture as well as the internal representation of a parsed translation unit. It then presents a simple plugin implementation that prints information about C++ declarations being compiled. The talk continues by covering a number of more advanced techniques, including injection of extra C++ code before or after the main translation unit, programmatic template instantiation, and handling of application-specific pragmas and attributes.

The presentation will be incomplete without a brief comparison of the GCC plugin architecture with Clang, another C++ compiler implementation that has recently achieved full C++-98 support. The talk concludes with a quick brainstorming session on possible interesting applications, both in the context of Boost and more broadly, that can be implemented using a GCC plugin.

Phoenix V3 – An Overview

Speakers: Thomas Heller, Hartmut Kaiser
Format: tutorial
Track: Track II 2011

Phoenix will be the next generation of creating unnamed, inlined polymorphic function objects. With V3 we combine the functionality of Boost.Bind and Boost.Lambda, and arranges it into a new library. By writing this new library, we were able to fix some limitations of the aforementioned libraries without breaking backwardscompatibility. The purpose of the talk will be to outline the importance and elegance of functional programming (FP) in C++. The first part of the talk will give an introduction into the Domain Specific Embedded Language (DSEL) we defined with Phoenix. A DSEL is built with the help of regular C++ function and operator overloads. For Phoenix we defined such a language that emulates C++, to give potential users a low entry into the world of FP. While a lot of existing C++ code relies on higher order functions (better known as function objects), e.g. the C++ standard library use them as a way to let users customize operations in certain algorithms. We focus the second part of the talk on examples on how to use Phoenix instead of writing regular function objects and how to enable your legacy code to be used inside Phoenix expressions. However, Phoenix is more. Phoenix is equipped with a unique (in C++) mechanism to handle the expressions discussed in the previous sections as data. This allows us to handle Phoenix not in the C++ standard way but in any way you like. An overview of these mechanisms will be given in the last part of the talk to give potential users an insight on possible future applications that might evolve around Phoenix.

Picnic'11

Format: social event

A picnic on the Aspen Center for Physics campus.

Practical SIMD acceleration with Boost.SIMD

Speakers: Joel Falcou, Mathias Gaunard
Format: tutorial
Track: Track I 2011

SIMD machines — machines capable of evaluating the same instruction on several elements of data in parallel — are nowadays commonplace and diverse, be it in supercomputers, desktop computers or even mobile ones. Numerous tools and libraries can make use of that technology to speed up their computations, yet it could be argued that there is no library that provides a satisfying minimalistic, high-level and platform-agnostic interface for the C++ developer.

In this talk, we shall present the upcoming Boost.SIMD library that is pending review, while explaining the challenges of the technology and how to adapt a series of common or not-so-common example problems to use it. In doing do, we aim to demonstrate the effectiveness of our library at easily speeding-up all kinds of algorithms, and at appropriately abstracting SIMD hardware so as not to exhibit any penalty.

The design of Boost.SIMD is made so as to be as lightweight as possible; as a component of the larger numerical computation library NT2 — which uses it, along with SMP, MPI and GPGPU technologies, to build tables and matrices –, it is dedicated to only deal with SIMD. Therefore its main abstraction is that of the SIMD register, i.e. the base unit the SIMD processing unit manipulates; and albeit it provides a platform-agnostic and high-level interface, it is designed so that low-level issues can remain a primary concern to the user.

Boost.SIMD also relies on the Boost.Proto DSEL framework so as to detect certain code patterns and map them to the most efficient solution. This is for example used for the fused multiplication/addition instructions, available on Altivec and on future generations of x86, but also for other things such as detection of values that are necessarily in a given range.

Furthermore, the library embeds a powerful external dispatching mechanism which allows to fairly easily specialize a primitive for a given architecture or to create new targets or functions.

Spirit.Qi in the Real World

Speaker: Robert Stewart
Format: tutorial
Track: Track I 2011

Past sessions on Spirit have focused on introducing Spirit or showing extracts of real use, intermingled with tutorial highlights. Upon writing real Spirit.Qi parsers, however, one quickly discovers that "the devil is in the details." There are special cases, tricks, and idioms that one must discover by trial and error or, perhaps, by following the Spirit mailing list, all of which take time and may not be convenient. In this session, we’ll walk through the development of a Spirit.Qi parser for printf()-style format strings. The result will be a replacement for printf() that is typesafe and efficient.

Sweep-Line Algorithm for Voronoi Diagrams of Points, Line Segments and Medial Axis of Polygons in the Plane

Speakers: Lucanus Simonson, Andrii Sydorchuk
Format: tutorial
Track: Track II 2011

We present an algorithm for computing the Voronoi diagram of input data sets of points and non-intersecting segments in the plane. Building upon the plane sweep algorithm by Fortune that computes the Voronoi diagram of points we extend the algorithm to line segments while maintaining optimal O(n log n) time complexity. The Voronoi diagram of line segments can trivially produce the medial axis of polygons and has many applications in VSLI CAD, and manufacturing CAM. Approaches to ensuring numerical robustness without sacrificing efficiency will be discussed. We will show that the algorithm provides reliably correct results for integer coordinate inputs by using robust predicates that rely on lazy-exact arithmetic.

The Proposed Boost B-tree Library

Speaker: Beman Dawes
Format: tutorial
Track: Track II 2011

B-trees are the ubiquitous data structures behind databases, file systems, and other disk-resident associate containers.

This session introduces B-trees and a proposed library that supplies disk-resident B-tree map, multimap, set, and multiset containers. Topics will include a brief introduction to B-trees, then dive into how the proposed library containers relate to C++ standard library associative containers, the actual interface, gotchas, variable length data, performance, and the current state of the proposed library’s implementation. There will be time for feedback and discussion.

By the end of the session, participants will be ready to use the proposed library in their own applications, and render further feedback to help prepare the library for formal acceptance into Boost.

Thinking Asynchronously: Designing Applications with Boost.Asio

Speaker: Christopher Kohlhoff
Format: lecture
Track: Track II 2011

From its inception, Boost.Asio has been designed with a toolkit, rather than framework, approach in mind. The library focuses on providing a set of fundamental, portable building blocks. There is usually more than one right way to approach a task, and the library does not dictate a particular design.

In this presentation, we will consider how an asynchronous mindset can be applied to design problems. We’ll look at alternative designs, common traps and pitfalls, and how to attack complexity with composed operations. The talk will also cover optimisation and the tools Boost.Asio provides for managing performance and scalability.

This talk assumes that attendees have some basic level of familiarity with Boost.Asio.

Threads and Shared Variables in C++0x

Speaker: Hans Boehm
Format: keynote

The C++0x draft standard introduces threads into the language, and carefully defines the meaning of variables shared between threads. The design is based on the idea that meaningful multithreaded programs should, by default, guarantee semantics based on simple interleaved execution of the threads, i.e. sequential consistency. This allows efficient execution only because we view data races, i.e. most kinds of unprotected concurrent access to ordinary shared variables, as erroneous and meaningless. The draft instead supports an extensive collection of atomic operations that allow such accesses on specially identified objects.

We present a brief overview of thread support in C++0x, and then focus on the memory model that defines shared variable semantics, and its interaction with the atomics library. Although we tried to be as consistent with past practice as possible, we encountered more than our share of difficulties and surprises. We’ll mention some of the past mistakes we tried not to copy.

This describes joint work with Sarita Adve, Lawrence Crowl, Paul McKenney, Clark Nelson, Herb Sutter, and many others.

Toward Native XML Processing Using Multi-paradigm Design in C++

Speakers: Aniruddha Gokhale, Sumant Tambe
Format: tutorial
Track: Track I 2011

XML programming has emerged as a powerful data processing paradigm with its own rules for abstracting, partitioning, programming styles, and idioms. Seasoned XML programmers expect, and their productivity depends on the availability of languages and tools that allow usage of the patterns and practices native to the domain of XML programming. The object-oriented community, however, prefers XML data binding tools over dedicated XML languages because these tools automatically generate a statically-typed, vocabulary-specific object model from a given XML schema. Unfortunately, these tools often sidestep the expectations of seasoned XML programmers because of the difficulties in synthesizing abstractions of XML programming using purely object-oriented principles. This talk demonstrates how this prevailing gap can be significantly narrowed by a novel application of multi-paradigm programming capabilities of C++. In particular, how generic programming, meta-programming, generative programming, strategic programming, and operator overloading supported by C++ together enable native and typed XML programming.

Why C++0x is the Awesomest Language for Network Programming

Speaker: Christopher Kohlhoff
Format: tutorial
Track: Track II 2011

Warning: This is not a talk for the faint-hearted. There will be bleeding-edge language features. There will be hackery. There will be language abuse. It just might all end in chair throwing.

For the thrill-seeking geek, it should be a fun ride. We’ll see how some of the new C++0x language and library features, and some old ones as well, can be combined with Boost.Asio to create network programs that are terse, expressive and efficient.

Comments are closed.