C++ Weekly Episode 70: C++ IIFE in quick-bench.com—Jason Turner

By Jason Turner | Jul 3, 2017 10:18 AM | Tags: performance efficiency c++11 basics

Episode 70 of C++ Weekly.

C++ IIFE in quick-bench.com

by Jason Turner

About the show:

We are commonly taught to const everything that we can in C++. One way to accomplish this goal in the post-C++11 world is to use a immediately invoked lambda (equivalent to an IIFE in the JavaScript world) that generates a value for us, which we assign to a const value. But what impact does this design decision have on the quality of code generated and the performance? In this episode of C++ Weekly we use the new website quick-bench to test the various options available.

CppCon 2016: Deploying C++ modules to 100s of millions of lines of code--Manuel Klimek

By Adrien Hamelin | Jun 30, 2017 02:57 PM | Tags: performance experimental community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Deploying C++ modules to 100s of millions of lines of code

by Manuel Klimek

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Compile times are a pain point for C++ programmers all over the world. Google is no exception.. We have a single unified codebase with hundreds of millions of lines of C++ code, all of it built from source. As the size of the codebase and the depth of interrelated interfaces exposed through textually included headers grew, the scaling of compiles became a critical issue.

Years ago we started working to build technology in the Clang compiler that could help scale builds more effectively than textual inclusion. This is the core of C++ Modules: moving away from the model of textual inclusion. We also started preparing our codebase to migrate to this technology en masse, and through a highly automated process. It's been a long time and a tremendous effort, but we'd like to share where we are as well as what comes next.

In this talk, we will outline the core C++ Modules technology in Clang. This is just raw technology at this stage, not an integrated part of the C++ programming language. That part is being worked on by a large group of people in the ISO C++ standards committee. But we want to share how Google is using this raw technology internally to make today's C++ compiles faster, what it took to get there, and how you too can take advantage of these features. We will cover everything from the details of migrating a codebase of this size to use a novel compilation model to the ramifications for both local and distributed build systems. We hope to give insight into the kinds of benefits that technology like C++ Modules can bring to a large scale C++ development environment.

CppCon 2016: AAAARGH!? Adopting Almost Always Auto Reinforces Good Habits!?--Andy Bond

By Adrien Hamelin | Jun 28, 2017 08:56 AM | Tags: performance c++11

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

AAAARGH!? Adopting Almost Always Auto Reinforces Good Habits!?

by Andy Bond

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Prominent members of the C++ community are advocating the "almost-always-auto" idiom, but there are understandable concerns from many about its implications. This case study will demonstrate how it may be applied in different situations, suggest ways to avoid performance penalties, introduce algorithms to minimize the "almost" part, and discuss the overall impact.

CppCon 2016: The strange details of std::string at Facebook--Nicholas Ormrod

By Adrien Hamelin | Jun 21, 2017 08:00 AM | Tags: performance community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

The strange details of std::string at Facebook

by Nicholas Ormrod

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Standard strings are slowing you down. Strings are everywhere. Changing the performance of std::string has a measurable impact on the speed of real-world C++ programs. But how can you make strings better? In this talk, we'll explore how Facebook optimizes strings, especially with our open-source std::string replacement, fbstring. We'll dive into implementation tradeoffs, especially the storage of data in the struct; examine which standard rules can and cannot be flouted, such as copy-on-write semantics; and share some of the things we've learned along the way, like how hard it is to abolish the null-terminator. War stories will be provided.

CppCon 2016: Bringing Clang and C++ to GPUs: An Open-Source, CUDA-Compatible GPU C++ Compiler--Lebar

By Adrien Hamelin | Jun 16, 2017 12:04 PM | Tags: performance community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Bringing Clang and C++ to GPUs: An Open-Source, CUDA-Compatible GPU C++ Compiler

by Justin Lebar

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

GPU computing has gone mainstream. It is a dominant part of the performance landscape, providing the initial 10x performance lift to a wide variety of applications. However, programing for GPUs can be extremely challenging. C++ is rarely available in an unmodified form, and there are few portable and open source approaches available. One of the most popular platforms, CUDA, has no production quality open source implementation. As a consequence, its C++ support has lagged behind and it has been a less appealing area for researchers and others that weren’t comfortable relying on NVIDIA’s tooling.

However, today things are different. Clang is now a fully functional open-source GPU compiler. It provides a CUDA-compatible programming model and can compile most of the awesome CUDA libraries out there ranging from Thrust (the CUDA-enabled parallel algorithms library that gave rise to the new parallelism technical specification) to Eigen and TensorFlow.

In this talk we will give an overview of how LLVM and Clang support targeting C++ to GPUs, how they work to be compatible with existing CUDA code, and how you can build your code today to run on GPUs with this open source compiler.

High-Performance and Low-Latency C++ with Herb Sutter

By DavidF | Jun 13, 2017 01:16 PM | Tags: performance c++17 c++14

Join us for a 3-day training event with Herb Sutter in London, October 9-11, 2017

High-Performance and Low-Latency C++

About the training:

Welcome to a unique training with Mr Herb Sutter focusing on Efficiency, Concurrency, Parallelism, Modern Hardware, and Modern C++11/14/17. Participants of this intensive 3-day training will be given the knowledge and skills required to write high-performance and low-latency code using modern C++ on today´s systems.

Mr Sutter is the chair of the ISO C++ committee and best-selling author of four books and hundreds of technical papers and articles, including the essay “The Free Lunch Is Over”.

Intermediate to advanced C++ programming experience is required. Some experience with concurrency, parallelism, and/or multiprocessing in e.g. Java, C, C++ or similar language is recommended, but not required.

Don’t miss out on the opportunity to attend this three day course, to be held in London on the 9th – 11th October, 2017. Please notice there are a limited number of seats.

CppCon 2016: Practical Performance Practices--Jason Turner

By Adrien Hamelin | Jun 12, 2017 02:09 PM | Tags: performance community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Practical Performance Practices

by Jason Turner

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

In the past 6 years ChaiScript's performance has been improved by nearly 100x. This was not accomplished by adding a virtual machine or performing dynamic recompilation. Instead, these increases have been accomplished by moving to more simple, cleaner, idiomatic C++ and by following some simple rules. We will outline these concepts with examples for how they both simplified code while improving performance.

There Is A New Future -- Felix Petriconi

By Felix Petriconi | Jun 10, 2017 01:11 PM | Tags: performance efficiency concurrency c++14

Version 1.0 of a new C++ future and channel library has been released.

There Is A New Future

by Sean Parent, Foster Brereton and Felix Petriconi

About the library:

This library provides high level abstractions for implementing algorithms that eases the use of multiple CPU cores while minimizing the contention.

The future implementaton differs in several aspects compared to the C++11/14/17 standard futures: It provides continuations and joins, which were just added in a C++17 TS. But more important this futures propagate values through the graph and not futures. This allows an easy way of creating splits. That means a single future can have multiple continuations into different directions. An other important difference is that the futures support cancellation. So if one is not anymore interested in the result of a future, then one can destroy the future without the need to wait until the future is fullfilled, as it is the case with std::future (and boost::future). An already started future will run until its end, but will not trigger any continuation. So in all these cases, all chained continuations will never be triggered. Additionally the future interface is designed in a way, that one can use build in or custom build executors.

Since one can create with futures only graphs for single use, this library provides as well channels. With these channels one can build graphs, that can be used for multiple invocations.

CppCon 2016: Game engine using STD C++ 11--Jason Jurecka

By Adrien Hamelin | May 31, 2017 12:45 PM | Tags: performance c++11

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Game engine using STD C++ 11

by Jason Jurecka

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This session is going to give an account of the process and features used to create a game engine focusing on using std C++11 features and concurrency. We will go through the architecture of the engine design and the specifics of the C++11 features being used. We will also go through optimization choices and design mentalities that are being used to keep the code base simple, but powerful in game usage. The engine architecture we will be going through will be using parallelism as a way to distribute work and get performance out of the available hardware that can scale into the future.

While completing a full engine with cutting edge graphics techniques and a game to push the engine to its limits will take a while this session will go over the current state of the project and lessons learned. The ultimate goal of the project is to show the validity of using C++11 (and beyond) features in game engines to simplify code and improve stability while maintaining the performance and memory usage games demand.

CppCon 2016: Rich Code for Tiny Computers: A Simple Commodore 64 Game in C++17--Jason Turner

By Adrien Hamelin | May 26, 2017 01:06 PM | Tags: performance efficiency

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Rich Code for Tiny Computers: A Simple Commodore 64 Game in C++17

by Jason Turner

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

The Commodore 64 was released in 1982 and is the best selling computer model of all time. At 34 years old, even the most simple embedded processor today outperforms it. Join me on an exploration of how C++17 techniques can be utilized to write expressive, high performance, high level code for simple computers. Together we will create a game for this aging system.

You'll leave the talk with a better understanding of what your compiler is capable of and be able to apply these ideas to create better code on modern systems.