Home » Blog » Categories » News

News

CppCon 2022 keynote: Erik Rainey, "Using C++14 in an Embedded 'SuperLoop' Firmware"

By Blog Staff | Jul 28, 2022 05:09 PM | Tags: None

Flying Amazon drones on C++:

Erik Rainey live in person at CppCon 2022

From the announcement:

Using C++14 in an Embedded “SuperLoop” Firmware

This presentation covers what the execution environment of an embedded “superloop” firmware is in order to describe later why certain C++14 language and library features are used and others are not. This environment lacks many basic features and capabilities that traditional C++ programmers may think are common place but is able to be programmed in C++14 (and later) with a specific design paradigms and guidelines. Programmers with deeply embedded C experience will be familiar with some of the limitations of the environment but may find the C++ solutions quite refreshing! The talk will conclude with some comments on C++17 / C++20 features which will be quite valuable to embedded environments of all types.

CppCon 2022 registration is now open so don’t miss out this September 11-16. Register today! Tickets are now available for both online attendees and in-person attendees.

Design and Implementation of Highly Scalable Quantifiable Data Structures - CppCon 2021--Victor Cook

By Adrien Hamelin | Jul 25, 2022 01:44 PM | Tags: None

Registration is now open for CppCon 2022, which starts on September 11 and will again be held both in person and online. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year’s conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2022 to attend in person, online, or both!

Design and Implementation of Highly Scalable Quantifiable Data Structures in C++

by Victor Cook

Summary of the video:

Architectural imperatives due to the slowing of Moore's Law, the broad acceptance of relaxed semantics and the O(n!) worst case verification complexity of generating sequential histories motivate a new approach to concurrent correctness. Quantifiability is proposed as a novel correctness condition that models a system in vector space to launch a new mathematical analysis of concurrency. Analysis is facilitated with linear algebra, better supported and of much more efficient time complexity than traditional combinatorial methods.

In this talk, we present the design and implementation of a lock-free quantifiable stack (QStack) and a lock-free quantifiable queue (QQueue) in the C++ programming language. Our design achieves lock-freedom using compare_exchange_strong from the C++17 Atomic Operations Library. We depict several code snippets that illustrate how quantifiable data structures are highly scalable through use of relaxed semantics, an explicit implementation trade-off permitted by quantifiability. We explain how to reason about the correctness of quantifiable data structures and present a technique and a dynamic analysis tool developed in C++ for efficiently verifying a concurrent history as quantifiably correct, referred to as Vector Space Verification (VSV). We illustrate why it is impractical to use alternative verification techniques that compare concurrent histories to sequential histories for determining correctness for real programs.

We showcase the performance of quantifiable data structures by presenting a live demonstration that runs the QStack and QQueue and plots the results in real time. The QStack is compared with the lock-free Elimination Backoff Stack and the lock-free Treiber stack. The QQueue is compared with the lock-free LCRQ, and the wait-free Fetch-And-Add queue. The live performance demonstration illustrates how the QStack and QQueue achieve substantially higher scalability than the state-of-the-art linearizable counterparts. We also present a live demonstration of our VSV tool to dynamically check a concurrent history for the QStack and QQueue as quantifiably correct in less than O(n^2) time.

C++23’s Deducing this: what it is, why it is, how to use it

By Adrien Hamelin | Jul 25, 2022 01:29 PM | Tags: c++23

Useful new feature!

C++23’s Deducing this: what it is, why it is, how to use it

by Sy Brand

From the article:

Deducing this (P0847) is a C++23 feature which gives a new way of specifying non-static member functions. Usually when we call an object’s member function, the object is implicitly passed to the member function, despite not being present in the parameter list. P0847 allows us to make this parameter explicit, giving it a name and const/reference qualifiers...

Data Orientation For The Win! - Eduardo Madrid - CppCon 2021

By Adrien Hamelin | Jul 22, 2022 01:31 PM | Tags: performance

Registration is now open for CppCon 2022, which starts on September 11 and will again be held both in person and online. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year’s conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2022 to attend in person, online, or both!

Data Orientation For The Win!

by Eduardo Madrid

Summary of the video:

C++ conferences have had presentations showing the important performance benefits of data-oriented design principles; however, the principles seem to require lots of "manual" effort and "code uglification"; these make the principles less practical, and there haven't been clear recommendations about how to deal with runtime-polymorphic types.

In this talk we will recapitulate on data orientation principles and their benefits showing their application through production-strength Generic Programming components made to support them.

Specific examples include:
1. Structures of arrays instead of arrays of complex structures (a.k.a. "scattering")
2. Support for data oriented designs for runtime-polymorphism without inheritance+virtual (the equivalent of using std::variant or std::function, but generalized as allowed by the Zoo type-erasure framework)
----1. Hybrid buffers: the equivalent of the virtual table pointer is scattered out of the objects solving the "Goldilocks problem" of how big the local buffer should be, objects occupy the available space optimally
----2. Easy (de)serialization through very easy relocatability
----3. Voiding the need for pointers in favor of indices into arrays

Pass-by-value vs Pass-by-reference--James Mitchell

By Adrien Hamelin | Jul 22, 2022 01:21 PM | Tags: advanced

Complex world.

Pass-by-value vs Pass-by-reference

by James Mitchell

From the article:

Let’s dig into the age old question, should you pass-by-value or pass-by-reference in C++? (or by pointer in C)

This blog post is mostly a re-post of a reddit comment that I made on r/cpp about pass-by-value and pass-by-reference, with some minor improvements, to make it easier to reference and save.

The answer isn’t as easy as it might seem, it depends on the Application Binary Interface (ABI) and your use-cases, there isn’t a one size fits all answer, this is even more the case for anything which is built to be cross platform.

First it’s probably good to break the problem down into two parts (focusing solely on performance, ignoring readability and maintainability which should often be more important)

  • The language construct costs (copying, moving, etc)
  • Compiler implications (aliasing, pointer provenance, etc)
  • The ABI (the stack, registers, etc)...

Porting my first application from Qt5 to Qt6

By Meeting C++ | Jul 22, 2022 03:00 AM | Tags: qt meetingcpp intermediate c++17 basics

An overview on the issues face when porting my first application to Qt6

Porting my first Application from Qt5 to Qt6

by Jens Weller

From the article:

Just this week I had the opportunity to recompile one of my Qt Applications to build it with Qt6. Here is some of the results.

The application in question manages parts of the conference, and hence is written in Qt for the UI and uses SQLite as datastorage, so Qt also used for this and as I learned for a few other things too...

CppCon 2022 Keynote: Contemporary C++ in Action -- Daniela Engert

By Blog Staff | Jul 21, 2022 03:51 PM | Tags: None

The third CppCon 2022 keynote has been announced! Daniela Engert is the world's top guru on C++ modules who isn't one of the compiler implementers, and will speaking about modules and so much more:

Daniela Engert live in person at CppCon 2022

Daniela Engert will be in Aurora, live in person to deliver a keynote that takes us on a journey through modern C++.

Daniela has been building computers and creating software for over forty years, with thirty years in the field of applied digital signal processing. Her recent focus has been on modules and helping developers best understand them and their application in C++20.

Here is her talk description:

Contemporary C++ in Action

This talk is different from typical conference presentations. Instead of focussing on one particular topic I want to take you with me on a journey where I put various pieces from the C++ landscape together into a small application and show how they fit together beautifully. My goal is to debunk the myth that the committee is looking to please experts and library developers instead of making life easier for the many developers in the trenches. This is not slideware, at the end of our tour the code will compile and run with some entertaining result.

On this journey, I will be visiting modules (using modularized popular libraries and others that constitute the app), do some network programming with coroutines (based on ASIO executors, as there are no C++ standard executors yet), slip in one or two of the flagship C++23 features, like explicit object parameters or some of the new library stuff, and season the stew with items from recent C++ standards. It’s a tiny application using techniques that an average programmer in the embedded or industrial world (like me) might find useful. The code I’ll show also contains very tiny fragments of condensed or simplified sources in active development taken from our in-house codebase – old and trusted, but thrust into the modern age.

Registration is now open so don’t miss out on CppCon 2022 this September 11-16. Register today! Tickets are now available for both online attendees and in-person attendees.