Understanding Allocator Impact on Runtime Performance in C++ - Parsa Amini - CppCon 2022
https://github.com/CppCon/CppCon2022
Typical users rely on existing tools to understand the performance of their code. However, no tool is perfectly suited for all applications, hardware, or analysis. Moreover, constructing a strong case that explains the impact of a design choice on runtime performance occasionally requires abstracting the results of a performance comparison into easy-to-interpret performance metrics while eliding or minimizing unrelated factors.
This talk recounts the challenges encountered while attempting to analyze and delineate the performance impact of employing local memory allocators. Challenges included 1) choosing the correct tool, 2) working around the resolution and precision constraints of the instrumentation and profiling tools, and 3) designing effective presentation and visualization material.
---
Parsa Amini
Parsa Amini is interested in high-performance computing applications and high-productivity parallel C++ codes. He has been involved in developing the HPX runtime system and HPX applications. Parsa received his Ph.D. degree in Computer Science from Louisiana State University and has been investigating the costs of using assumptions in C++ programs since.
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Going Beyond Build Distribution: Using Incredibuild to Accelerate Static Code Analysis and Builds - Jonathan "Beau" Peck - CppCon 2022
https://github.com/CppCon/CppCon2022
Even though C++ compilation times seem to be trending downward, the introduction of modules in C++20 means that long compile times might remain a stress factor for developers. This is before accounting for the time it takes to complete tasks like static code analysis which adds more time to the C++ CI pipeline.
This session will demonstrate how to better manage your CI pipeline to achieve faster and more frequent iterations, improve developer velocity and software quality while adding static code analysis to your dev cycle. We will see how to connect your CI pipeline to Github Actions to achieve automatic triggered CI processes and how to distribute those to on-prem machines or to the cloud with Incredibuild.
---
Jonathan "Beau" Peck
Beau's first computer command was LOAD "*",8,1 on a blue screen which at that time was something you wanted to see. But he really discovered technology while working as a flight control officer when he realized running aircraft operations was in many ways like running ones and zeros (if you're curious feel free to ask him). Thanks to Linux, his natural curiosity about breaking things apart to understand how they worked and then learning and discovering new ways to put things together led him into a career spanning 20++ (I see what you did there) years across systems administration, systems engineering, database and architecture.
His passion is helping customers align, create, architect and operate technical solutions that solve business and technical needs. Currently he is a solutions architect with Incredibuild focused on helping developers accelerate build and test times with distributed computing processing and process virtualization.
__
Avi Lachmish
Avi is an expert in Web and networking technologies, operating systems, and software development methodologies. Avi has extensive experience in C++, object-oriented analysis, design and distributed architectures.
---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
Help! My Codebase has 5 JSON Libraries - How Generic Programming Rescued Me - Christopher McArthur - CppCon 2022
https://github.com/CppCon/CppCon2022
In 2019 working on a RESTful cloud oriented C++ application, everything was JSON. Inbound communication was handled with an ASIO based web server, RESTinio, and used RapidJSON to handle the API payload. Outbound was handled by CPPRESTSDK which had its own JSON implementation. To handle authorization, we picked the best C++ JSON Web Token (JWT) library but that was written on top of PicoJSON, a small minimalistic unmainted library. We then had 3 different JSON libraries to work with and mix together.
How do we make this work together? “Why don’t you template out the logic and metaprogram a traits implementation?” Geeze, Thanks Gareth! So that’s what I did.
Generic cppcon.digital-medium.co.uk/tag/programming/">programming is writing algorithms in such a way that the type can be specified later. Using templates the algorithm can operate on different types if they satisfy certain traits (or implement a certain concept). JSON Web Tokens should follow the same algorithm regardless of the JSON implementation - this seemed like a useful case for applying generic cppcon.digital-medium.co.uk/tag/programming/">programming.
Six months and a lot of learning later, I had opened a pull request against the JWT-CPP library.
Using templates, SFINAE, and static assertions I was able to abstract the “JSON” out of the JSON Web Token (JWT) logic. I am able to answer questions like: How can the compiler know…
What is the signature of a function? Does it match a known signature? Is it close enough?
If a type has a member function? What is the return type of the method? Can it differentiate between static and member functions?
Yes. The compiler is really that well informed and the tools and techniques exist to programmatically answer them at compile time.
Templating the JSON “value and types” played in favor with the existing design of a C++ single file header only library. Being an Open-source project it was important to maintain the existing compiler requirements, this bound the implementation to C++11 however there are C++17 features (i.e. `std::void_t`) and experimental features (i.e. `std::experimental::is_detected`) which are back-ported.
A JSON Traits needs to declare a generic value type, and concert basic types which match the JWT’s family of RFC defined claims (which are JSON keys) such as object, string, or double. All the types were substituted into templates to check for concepts, for instance, `object_type` needs to be iterable, so a `constexpr` value is set if begin and end methods are present. Some traits are optional and substitution failure is not an error.
With several of the most popular JSON libraries like Niel Lohamn’s and Boost’s supported, this approach can work for any project looking to decouple the application logic from a library specific container. There are some drawbacks, such as complexity and mind melting error messages. Recent compilers with support for Concepts makes future possibilities very exciting.
---
Christopher McArthur
Chris has been giving back to the open source community with exploit database containers, C++/ CMake build system maintenance, and other OSS projects for nearly ten years. He began his career as a C++ developer and has since then added other languages including Golang and Typescript to his skill set. Prior to joining the Conan team at JFrog, Chris previously worked in the video broadcast and mobile advertising industries on a variety of projects. His diverse experiences include Blockchain, low-level hardware networking, distributed systems security, and cloud-native DevOps. As a developer advocate for JFrog, Chris deals with Conan, Chris shares his deep to the knowledge of DevOps and Package Management to the C++ Community globally.
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Back to Basics: C++ Value Semantics - Klaus Iglberger - CppCon 2022
https://github.com/CppCon/CppCon2022
Modern C++ is more than new standards or an assortment of new features. Modern C++ is about a philosophy on how to use the language. An integral part of this philosophy is value semantics: preferring values and value-like types instead of pointers and references.
This talk explains the rational of this philosophy. It demonstrates the benefits of several value types from the standard library, such as std::optional, std::function and std::variant, and the drawbacks of several reference types, such as std::string_view and std::span. It also goes into detail about the most common questions about value semantics, as for instance how to properly use reference types and whether we should stop using reference parameters.
---
Klaus Iglberger
Klaus Iglberger is a freelance C++ trainer and consultant. He has finished his PhD in Computer Science in 2010 and since then is focused on large-scale C++ software design. He shares his expertise in popular advanced C++ courses around the world (mainly in Germany, but also in the rest of the EU and the US). Additionally, he is the initiator and lead designer of the Blaze C++ math library (https://bitbucket.org/blaze-lib/blaze/), one of the organizers of the Munich C++ user group (https://www.meetup.com/MUCplusplus/), and the organizer of the Back-to-Basics track at CppCon.
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
HPX - A C++ Library for Parallelism and Concurrency - Hartmut Kaiser - CppCon 2022
https://github.com/CppCon/CppCon2022
With the advent of modern computer architectures characterized by -- amongst other things -- many-core nodes, deep and complex memory hierarchies, heterogeneous subsystems, and power-aware components, it is becoming increasingly difficult to achieve best possible application scalability and satisfactory parallel efficiency. The community is experimenting with new programming models that rely on finer-grain parallelism, and flexible and lightweight synchronization, combined with work-queue-based, message-driven computation. The recently growing interest in the C++ programming language in industry and in the wider community increases the demand for libraries implementing those programming models for the language.
In this talk, we present HPX -- A C++ Standards Library for Parallelism and Concurrency that is built around lightweight tasks and mechanisms to orchestrate massively parallel (and -- if needed -- distributed) execution. We also implement a full set of standard parallel algorithms and related asynchronous extensions to those. The library enables an asynchronous execution model that uses the concept of (Standard C++) futures to make data dependencies explicit, employs explicit and implicit asynchrony to hide latencies and to improve utilization, and manages finer-grain parallelism with a work-stealing scheduling system enabling automatic load balancing of tasks. Lately we have been experimenting with the new sender/receiver model that is currently being discussed as part of the C++ standardization process.
HPX is a C++ library exposing a higher-level parallelism API that is fully conforming to the existing C++11/14/17/20 standards and is aligned with the ongoing standardization work. This API and programming model has shown to enable writing highly efficient parallel applications for heterogeneous resources with excellent performance and scaling characteristics. This talk will highlight the implemented extensions to the C++ standard parallel algorithms and shows recent performance results.
---
Hartmut Kaiser
Hartmut is a research professor at Louisiana State Universities Center for Computation and Technology (CCT). He is probably best known for his involvement in open-source software projects, such as being the author of several C++ libraries he has contributed to Boost, which are in use by thousands of developers worldwide. His current research is focused on leading the STE||AR group at CCT working on the practical design and implementation of future execution models and programming methods. His research interests are focused on the complex interaction of compiler technologies, runtime systems, active libraries, and modern system's architectures. His goal is to enable the creation of a new generation of scientific applications in powerful, though complex environments, such as high-performance computing, distributed and grid computing, spatial information systems, and compiler technologies.
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
import CMake, CMake and C++20 Modules - Bill Hoffman - CppCon 2022
https://github.com/CppCon/CppCon2022
Originally developed as part of the National Institutes of Health (NIH) open source medical segmentation and registration toolkit ITK in 1999, CMake has grown to take on a vital role in the C++ ecosystem. Bill Hoffman, a founder of Kitware (www.kitware.com), and the creator of CMake will talk about where CMake is in 2022. The talk will start with a brief history of CMake and how it fits into the world of C++. It will then talk about recent developments to support C++20 modules.
For most of CMake's history, CMake has played catch up and implemented new features as compilers and IDEs have been released. With C++ modules, CMake developers have engaged the standards committee and compiler vendors to help craft the standard in such a way that CMake and other build systems can more seamlessly implement C++ modules. CMake has worked with Fortran modules for many years and has updated the ninja build tool to be able to dynamically update dependency information as it is discovered. To do this CMake requires a Fortran parser built into CMake. For obvious reasons CMake does not want to get into having its own C++ parser. This is the main driving force for pushing this work into the compilers. This talk will go over the road map for CMake C++ module support.
In addition to the history of CMake, C++ module support, this talk will include material covering important CMake features supporting the seamless building, testing and deployment of C++ across most computing platforms. In summary, listeners will learn about CMake origins, the roadmap of C++ module support in CMake and get an overview of the current set of features in CMake.
---
Bill Hoffman
Mr. Hoffman is a founder of Kitware and currently serves as Chairman of the Board, Vice President, and Chief Technical Officer (CTO). He is the original author and a lead architect of CMake, an open source, cross-platform build and configuration tool that is used by hundreds of projects around the world, and he is the co-author of the accompanying text, Mastering CMake. Using his 20+ years of experience with large software systems development, Mr. Hoffman is also a major technical contributor to Kitware’s Visualization Toolkit, Insight Toolkit, and ParaView projects
Mr. Hoffman received a B.S. in Computer Science from the University of Central Florida and an M.S. in Computer Science from Rensselear Polytechnic Institute (RPI). Prior to the formation of Kitware, he spent nine years at the General Electric Corporate Research and Development center, working in the Computer Vision Group. He has planned and taught several graduate-level courses at RPI as well as a course in object-oriented programming at New York University.
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Back to Basics: C++ Move Semantics - Andreas Fertig - CppCon 2022
https://github.com/CppCon/CppCon2022
Move semantics is a topic that feels hard to understand. This talk will give you a good understanding, demystifying some myths out there using a new and unique way of talking about moving.
For example, you've heard those move operations should be noexcept. In this talk, you will learn the why while we write things like an efficient move constructor and a move assignment operator.
During this talk, we will look at rules for when to use std::move and when to use std::forward.
There is one topic we have to discuss as well, what is a moved-from object, and what can you do with such an object?
You're eager to squeeze out the last drop of performance? Then we should talk about the ref-qualifiers. Why waste performance?
At the end of this talk, you have a solid understanding of move semantics, enabling you to write competitive performant code.
---
Andreas Fertig
Andreas Fertig, CEO of Unique Code GmbH, is an experienced trainer and lecturer for C++ for standards 11 to 20.
Andreas is involved in the C++ standardization committee, in which the new standards are developed. At international conferences, he presents how code can be written better. He publishes specialist articles, e.g., for iX magazine, and has published several textbooks on C++.
With C++ Insights (https://cppinsights.io), Andreas has created an internationally recognized tool that enables users to look behind the scenes of C++ and thus to understand constructs even better.
Before working as a trainer and consultant, he worked for Philips Medizin Systeme GmbH for ten years as a C++ software developer and architect focusing on embedded systems.
You can find Andreas online at
andreasfertig.com
__
Videos Streamed, Edited, and YouTube Channel Managed by Digital Medium: http://online.digital-medium.co.uk
C++ Performance Portability - Decade of Challenges Developing Kokkos - Christian Trott - CppCon 2022
https://github.com/CppCon/CppCon2022
Over the last decade, scientific computing had to deal with a diversifying hardware and programming model environment. Today’s scientific software engineers have to account for at least four vendor provided eco-systems: CUDA (NVIDIA), HIP (AMD), SYCL (Intel - OneAPI) and OpenMP. Performance Portability solutions attempt to relieve domain experts from the need to become experts in all of these, by providing an interface which enables developers to write their code once, and then execute it efficiently on any HPC platform.
This talk will discuss lessons learned from the last 10 years of developing and deploying Kokkos, a C++ based Performance Portability EcoSystem which is arguably the most widely used non-vendor solution for writing single source performance portable scientific applications. We will dive into some of the key challenges for designing performance portable software, and how to address them through appropriate API design. The talk will also show how some of the fundamental concepts for performance portability are getting introduced into the ISO C++ standard through upcoming features.
---
Christian Trott
Christian Trott is a high performance computing expert working at the Sandia National Laboratories. He leads the multi-institutional Kokkos C++ Performance Portability Programming Model development team and is member of the ISO C++ Standards Committee focusing on future C++ capabilities for parallel and heterogeneous computing. Christian is currently focused on making sure that Kokkos is ready for the exa-scale era high performance computing architectures. He also leads the mdspan proposal for the C++23 standard, which will provide multidimensional array views with configurable data layouts and data access functions.
His prior scientific work focused on computational material research using ab-initio calculations, molecular dynamic simulations and monte carlo methods for investigations of ion-conducting glass materials.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Taking a Byte Out of C++ - Avoiding Punning by Starting Lifetimes - Robert Leahy - CppCon 2022
https://github.com/CppCon/CppCon2022
Marshaling raw bytes into objects is a perennial problem in C++. Bytes may exist in memory, we may know they’re of the correct form to back a C++ object, but the abstract virtual machine says none of the desired objects exist at that location. The temptation to type pun and hope that happens to work, and continues to do so, runs strong.
What if we had start_lifetime_as? We could synthesize objects backed directly by bytes without superfluous calls to memcpy/memmove and prayers to the optimizer. What would that world look like? What sort of patterns could we use to work efficiently and correctly in that world?
This talk answers such questions against the backdrop of a database engine which makes use of this proposed functionality. Analysis will move from raw bytes, to C++ objects, to heterogeneous streams of such objects with discussion of the sharp edges at each level. End to end zero copy will be shown to be both possible and correct.
---
Robert Leahy
Robert is a graduate of the University of Victoria where he specialized in graphics, gaming, and digital geometry processing. After spending 4.5 years in full stack web development he pivoted to financial infrastructure in early 2016 and now works on next generation market data storage and retrieval mechanisms. In 2019 he became involved in the ISO C++ committee with a particular focus on library evolution.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
C++ Dependencies Don’t Have To Be Painful - Why You Should Use a Package Manager - Augustin Popa - CppCon 2022
https://github.com/CppCon/CppCon2022
According to recent surveys from the Standard C++ Foundation, a majority of C++ developers are manually managing their library dependencies. Curiously, one of the top pain points cited in these surveys was also “managing libraries”. I believe these two points are correlated.
In this talk, I will discuss how different types of package managers address these pain points, from system package managers like apt and Homebrew to build system centric package managers like NuGet and language package managers like vcpkg and Conan. There are pros and cons to every solution, and some package managers are more effective in some workflows than others. Managing libraries doesn’t have to be painful. If you configure your workflow right, you will save time not having to maintain additional git submodules, source code, or reading build instructions on GitHub.
I’ll also talk about a few scenarios related to dependency management: acquiring open-source libraries vs. private libraries, automatically building libraries from source, using libraries locally and in CI, using libraries with different build systems and operating systems, and acquiring developer tools from a package manager. You will come out of this talk with an understanding of how a package manager can rid you of your dependency woes.
---
Augustin Popa
Augustin is a Product Manager on the C++ team at Microsoft, working on vcpkg and Visual Studio setup. In the past he has worked on the Visual Studio productivity and getting started experiences.
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
