: Standard C++

Home » Blog » Categories »

« Prev Next »

Monitor Object -- Rainer Grimm

By Blog Staff | Jul 20, 2023 02:47 PM | Tags: None

The Monitor Object design pattern synchronizes concurrent member function execution to ensure that only one member function runs within an object at a time. It also allows an object's member functions to schedule their execution sequences cooperatively.

Monitor Object

by Rainer Grimm

From the article:

Problem

If many threads access a shared object concurrently, the following challenges exist.

Due to the concurrent access, the shared object must be protected from non-synchronized read and write operations to avoid data races.

The necessary synchronization should be part of the implementation, not the interface.

When a thread is done with the shared object, a notification should be triggered so the next thread can use the shared object. This mechanism helps avoid and improves the system's overall performance.

After the execution of a member function, the invariants of the shared object must hold.

Solution

A client (thread) can access the Monitor Object's synchronized member functions, and due to the monitor lock, only one synchronized member function can run at any given time. Each Monitor Object has a monitor condition that notifies the waiting clients.

CppCon 2022 The Most Important Optimizations to Apply in Your C++ Programs -- Jan Bielak

By Blog Staff | Jul 19, 2023 11:57 AM | Tags: None

Registration is now open for CppCon 2023! The conference starts on October 1 and will be held in person in Aurora, CO. 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 2023!

The Most Important Optimizations to Apply in Your C++ Programs

by Jan Bielak

Summary of the talk:

Writing efficient programs is hard. This is because it requires a lot of knowledge, experience and strategic thinking. There have been many talks on optimization and often each addresses a single concept. Being able to achieve a bird’s eye view of factors affecting performance often requires many hours of researching the topic. To lessen the mental burden of optimizing programs, I have picked out the techniques, I believe are most important. During the talk, I will present them in an organized manner and provide practical examples of how they can be applied.

I will first discuss what I believe are the main goals efficient programs strive to achieve. Then, I will present the general methods of achieving those goals. Then, for the majority of the talk, we will discuss a few dozen performance opportunities. For each of them, I will explain the underlying mechanism of how the optimisation works. I will avoid bluntly giving guidelines to follow without explanation. Each of the techniques naturally comes with its costs, and those will be discussed as well.

I will additionally discuss various performance pitfalls. These are sometimes called “premature pessimisations” in contrast to the often used term of “premature optimizations”. I will show examples of optimizations which do not incur any cost on program readability or maintainability and as such should be considered performance best practices. Avoiding their use doesn’t improve code in any manner, while making it slower.

This talk is intended for a diverse audience, as after all, probably most of the C++ community is interested in performance. It is appropriate for hobbyists and professionals alike, with varying experience with the language, due to the gradual increase in difficulty of examples. It will be a time productively spent.

Finite State Machine with std::variant -- Bartlomiej Filipek

By Blog Staff | Jul 18, 2023 02:44 PM | Tags: None

In this blog post, I’ll show you how to convert a “regular” enum-style finite state machine into a modern version based on std::variant from C++17. This technique allows you to improve design, work with value types and enhance code quality.

Finite State Machine with std::variant

by Bartlomiej Filipek

From the article:

Let’s start with a basic example:

we want to track a game player’s health status

we’d like to respond to events like “Hit by a monster” or “Healing bonus.”

when the health point goes to 0, then we have to restart the game only if there are some remaining lives available

Here’s a basic diagram with states and transitions:

CppCon 2022 Modernizing SFML in Cpp -- Chris Thrasher

By Blog Staff | Jul 17, 2023 01:53 PM | Tags: None

Lightning Talk: Modernizing SFML in Cpp

by Chris Thrasher

Summary of the talk:

Modernizing SFML, a game development library, from C++03 to C++17.

CppCon 2022 C++20 - A New Way of Meta-Programming? -- Kris Jusiak

By Blog Staff | Jul 13, 2023 02:49 PM | Tags: None

Lightning Talk: C++20 - A New Way of Meta-Programming?

by Kris Jusiak

Summary of the talk:

In this lightning talk we will explore a few template meta programming techniques which C++20 enables.

New C++ Features in GCC13 -- Marek Polacek

By Blog Staff | Jul 13, 2023 02:31 PM | Tags: None

The latest major version of the GNU Compiler Collection (GCC), 13.1, was released in April 2023. Like every major GCC release, this version brings many additions, improvements, bug fixes, and new features.

New C++ features in GCC 13

by Marek Polacek

From the article:

Like the article I wrote about GCC 10 and GCC 12, this article describes only new features implemented in the C++ front end; it does not discuss developments in the C++ language itself. Interesting changes in the standard C++ library that comes with GCC 13 are described in a separate blog post: New C features in GCC 13

CppCon 2022 Const Mayhem in C++ -- Ofek Shilon

By Blog Staff | Jul 11, 2023 01:42 PM | Tags: None

Lightning Talk: Const Mayhem in C++

by Ofek Shilon

Summary of the talk:

Did you know that:
(1) const methods can legally modify members?
(2) A const object cannot be default-initialized? (this makes sense after a minute)
(2)(b) Unless... a default constructor is declared non-inline?
(3) The standard does not properly account for volatile members of const objects?
All this and (probably not much) more, at this lightning talk.

Active Object -- Rainer Grimm

By Blog Staff | Jul 11, 2023 11:16 AM | Tags: None

The active object design pattern decouples method execution from method invocation for objects that each reside in their own thread of control.The goal is to introduce concurrency, by using asynchronous method invocation and a scheduler for handling requests.

Active Object

by Rainer Grimm

From the article:

The Active Object decouples method invocation from method execution. The method invocation is performed on the client thread, but the method execution is on the Active Object. The Active Object has its thread and a list of method request objects (short request) to be executed. The client’s method invocation enqueues the requests on the Active Object’s list. The requests are dispatched to the servant.

When many threads access a shared object synchronized, the following challenges must be solved:

A thread invoking a processing-intensive member function should not block the other threads invoking the same object for too long.

It should be easy to synchronize access to a shared object.

The concurrency characteristics of the executed requests should be adaptable to the concrete hardware and software.

CppCon 2022 An Introduction to Multithreading in C++20 -- Anthony Williams

By Blog Staff | Jul 7, 2023 02:35 PM | Tags: None

An Introduction to Multithreading in C++20

by Anthony Williams

Summary of the talk:

Where do you begin when you are writing your first multithreaded program using C++20? Whether you've got an existing single-threaded application, or you're starting from scratch, C++20 provides the basic tools to help. In this talk we'll look at the C++20 facilities you should reach for first, and how to use them safely.

Solving Undefined Behavior in Factories with constinit from C++20 -- Bartlomiej Filipek

By Blog Staff | Jul 6, 2023 05:07 PM | Tags: None

A few years ago, I showed an interesting implementation for self-registering classes in factories. It works, but one step might be at the edge of Undefined behavior. Fortunately, with C++20, its new constinit keyword, we can update the code and ensure it’s super safe.

Solving Undefined Behavior in Factories with constinit from C++20

by Bartlomiej Filipek

From the article:

Let’s bring back the topic:

Here’s a typical factory function. It creates unique_ptr with ZipCompression or BZCompression based on the passed name/filename:

Here are some issues with this approach:

Each time you write a new class, and you want to include it in the factory, you have to add another if in the Create() method. Easy to forget in a complex system.

All the types must be known to the factory.

In Create(), we arbitrarily used strings to represent types. Such representation is only visible in that single method. What if you’d like to use it somewhere else? Strings might be easily misspelled, especially if you have several places where they are compared.

All in all, we get a strong dependency between the factory and the classes.

But what if classes could register themselves? Would that help?