CppCon 2021

Every other conference talk these days seems to be showing off some code on Compiler Explorer. But what does all that Assembly actually mean?

In this talk you'll learn the very basics of X86 Assembly and the X86_64 calling convention, just enough to understand the full Assembly listing of simple functions on Compiler Explorer. No previous experience with Assembly is necessary, but a basic understanding of C or C++ is useful.

After this talk you will:
- Be able to paste code from your own project into Compiler Explorer, and either understand the Assembly output or know how to simplify it until you do.
- Have a solid understanding of the fundamentals, so you know what to search for and understand it when you need to know more.

(Compiler Explorer is an increasingly popular tool which allows you to see exactly what the compiler does with your code. Check it out at https://godbolt.org/.)

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Martin Fowler once wrote that high-quality software is actually cheaper to produce than low-quality software. We agree with that sentiment, and we warmly welcomed the C++ Core Guidelines when they were introduced in 2015. Research and surveys conducted in the C++ Community consistently demonstrate the popularity of the Clang family of tools, as well as the growing demand for static analysis to be added to code editors.

In this talk, we’ll explore the current capabilities of existing C++ static analyzers and discuss some of the enforcements listed in the C++ Core Guidelines from a toolability aspect. We’ll also look into the recent “Simplify C++” trend in the language’s evolution, and to wrap things up we’ll take a look at how technology-specific analysis (like MISRA and AUTOSAR) is being adopted.

A variety of checks will be discussed, from catching a dangling pointer to conforming to the preferred code style and naming scheme. And I want to share a crazy idea I have about gamifying static analysis. Let’s play!

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Once you decide to start a big project or a company, it eventually comes down to unifying the build infrastructure. However, hundreds and thousands of compilation units are extremely difficult to maintain to achieve the highest possible performance. Contrary to the belief that you should always trust your compiler, recent micro-architectural breakthroughs from merging two arrays with special instructions to JSON parsing through SIMD showed that compilers are far from understanding every single piece of code you write. In this session we will talk about our experience on how to achieve the highest possible performance without much rewriting of your code, which trade-offs C++ compilers have, how to make the most of your micro-architecture, why unrelated changes may decrease the performance and how to debug them. In the end we will show which compiler options gave us the opportunity to gain 5-15% of performance, stabilized the benchmarks and decreased the build size for search engines, databases and high performance computing.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

WebAssembly has become a very popular target platform for C++ developers. Thanks to emscripten, porting native applications to WebAssembly is easy — as long as the application only uses the browser as a display and input device. However, emscripten does not provide type-safe wrappers to the standard JavaScript APIs such as the DOM manipulation API, let alone any other JavaScript API provided by existing web applications.

Our open source tool “typescripten” has been built on top of three powerful technologies to close this gap. It uses TypeScript interface definition files and the TypeScript compiler API to create type-safe C++ wrappers based on emscripten. TypeScript already has interface definition files for over 7000 JavaScript libraries that you can now use safely from C++.

We strive to design our C++ wrappers such that the C++ code using them looks similar to the equivalent TypeScript or JavaScript code. However, the peculiar semantics of prototype-based Javascript and Typescript are often difficult to translate into a type-based language such as C++. I will discuss the challenges we faced and choices we made when designing this framework.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

What to do when a program is slower than what we'd like? Where to start when trying to improve throughput, latency or responsiveness?

In this beginner friendly session we will introduce the two big families of profilers (sampling and instrumentation) and two tools my team uses almost every day when working on games: Optick and vTune.
Through a few concrete cases based on past experience we will study how to troubleshoot a performance problem using a profiler and how the code was improved.

We will illustrate a few classic cases such as inefficient algorithms, unsuitable data structures, I/O waits and bad concurrency.

If time allows we will also see how profilers such as vTune can be used to delve into micro-optimizations by looking at low level metrics such as cache misses and branch prediction.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Visual Studio 2022 is almost here, bringing new and deeper experiences for C++ developers targeting any platform. Since last year we’ve been working hard on implementing C++20 and making the IDE 64-bit, alongside a host of improvements to make your C++ development safer and more productive.

In this talk we’ll demonstrate many of these features, live: showing you how to use our new AddressSanitizer features to find bugs, target WSL 2 in seconds, express your build instructions with CMakePresets.json, consume specific versions of your dependencies with vcpkg, build and test your code with GitHub Actions, and more.

Come along to learn all about the latest in our tooling, and to get a peek into our plans for the future.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

GDB is bigger than you might think, and it's evolving fast. This is a depth-first walk through what's been added in versions 9 and 10. Depth-first meaning that no prior knowledge of these features is assumed, but even if you've used them before there should be plenty new for you. Few slides, lots of live demos. Some brand new things and some neat new additions to existing features. Topics include the new debuginfod facility; user-defined commands; enhancements to super-useful convenience variables such as $_siginfo, $_gdb_setting, $_gdb_setting_str; enhancements to TUI mode; how to add new TUI windows from GDB's Python scripting; advanced querying of types from GDB's Python scripting; and enhanced configuration of backtrace printing. You should learn at least two new tricks that will make improve you debugging effectiveness, and so make you a better programmer.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Code size of embedded application has been a concern for a very long time. While storage becomes cheaper and smaller, developers find creative ways to increase code size by adding features or unnecessary software engineering. Compilers have come a long way in optimizing applications for code size. While most compiler optimization work were focused on application performance, we have seen increase in the code size optimizations in recent years.

In this presentation I'll talk about classical as well as recent compiler optimizations for code size, a few of which I implemented in the LLVM compiler. Some optimizations (hot cold splitting, function entry instrumentation) require collecting data from the field while the application is running. I'll provide an overview of how those compiler techniques help reduce code size. I'll also talk about some tips and techniques (compiler flags to reduce code size, tuning of compiler options like inline threshold), that help reduce binary size. Having knowledge of the code generated by the compiler and the instruction set architecture can help engineers chose appropriate programming abstractions and idioms.

Key takeaways:
- Compiler optimization flags and tunings for code size optimizations
- Selecting code-size friendly data structures and algorithms from the C++ standard library
- Source code level optimization and annotation techniques to reduce binary size
- Compiler instrumentation techniques to get insights into the source code
- Software re-organization techniques to reduce working set during program startup

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Delayed broadcast

Path-sensitive static analysis simulates the runtime behavior of the program code and uses the analysis state to evaluate which branches can be taken. It is an effective tool to find non-trivial bugs in code at compile time. While checks based on such analysis can take longer time to run, they have a sophisticated understanding of the code that helps them uncover semantic issues. First, I will discuss how can you turn these checks on and how to make sense of the warning messages they produce. Furthermore, I will do a deep dive on what makes path-sensitive analysis an effective tool to reason about code and how MSVC is leveraging this power to find bugs. In particular, I will explain how modern tools like constraint solvers can help increase the precision of the analysis. Throughout the talk, I will not only feature already released checks but also give a glimpse of the upcoming ones that we are actively working on. All the checks in the demo will be available for free in the community edition of Visual Studio and as security actions in GitHub.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/