Understanding the C++ Memory Model

This chapter is a continuation of the discussion from Chapter 7, where we discussed a few multiprocess and multi-threaded techniques; this chapter will enhance their usage. We will guide you through various techniques while narrowing down to the main focus of the chapter – the C++ memory model. But in order to discuss this, you will start first with a brief examination of memory robustness through the smart pointer and the optional objects. We will use them later to implement lazy initialization and handle shared memory regions safely. An improved memory access analysis of cache-friendly code follows. You will learn when and why using multi-threaded execution could be a trap, even though you did everything right in the software design.

This chapter gives you the opportunity to broaden your understanding of the synchronization primitives. While learning about the condition variables, you will also understand the benefits of the read-write...

Technical requirements

In order to run the code examples, the reader must prepare the following:

• A Linux-based system capable of compiling and executing C++20 (for example, Linux Mint 21)
• The GCC12.2 compiler: https://gcc.gnu.org/git/gcc.git gcc-source
  • With the -std=c++2a, -lpthread, and -lrt flags
• For all the examples, you can alternatively use https://godbolt.org/.
• All code examples in this chapter are available for download from https://github.com/PacktPublishing/C-Programming-for-Linux-Systems/tree/main/Chapter%209.

Getting to know smart pointers and optionals in C++

In Chapter 4, we revisited the C++ fundamentals in order to be on the same page when it comes to the language. One instrument that is also considered a must is smart pointers. Through these, we are able to improve the safety of the program and also manage our resources more effectively. And as discussed in the earlier chapters, this is one of our main goals as system programmers. Remember the RAII principle? Smart pointers are based on this, helping the C++ developer reduce and even eliminate memory leaks. They could also help with shared memory management as you will see later in the chapter.

Memory leaks appear when we allocate memory but fail to free it. This could happen not only because we forgot to call the object’s destructor, but also when we lose the pointer to that memory address. In addition to these, there are also the wild and dangling pointers to consider as well. The first one happens when the pointer is there...

Learning about condition variables, read-write locks, and ranges in C++

Let’s now start our discussion of synchronization primitives, a fundamental one of which is the condition variable. Its purpose is to allow multiple threads to remain blocked until an event occurs (i.e., a condition is satisfied). The implementation of condition variables requires an additional Boolean variable to indicate whether the condition is met or not, a mutex to serialize the access to the Boolean variable, and the condition variable itself.

POSIX provides an interface for multiple use cases. Do you remember the producer-consumer example in Chapter 7, Using Shared Memory? So, pthread_cond_timedwait() is used to block a thread for a given period of time. Or simply wait for a condition through pthread_cond_wait () and signal with pthread_cond_signal() to one thread, or pthread_cond_broadcast() to all threads. Typically, the condition is checked periodically in the scope of a mutex lock:

...
pthread_cond_t...

Discussing multiprocessor systems – cache locality and cache friendliness in C++

You probably recall Chapter 2 at this point, where we discussed multi-thread and multi-core processors. The respective computational units were presented as processors. We also visualized the transport of instructions from the NVM (the disk) to the processors, through which we explained the creation of processes and software threads.

We want our code to be as performant as required. The most important aspect of getting the code to perform well is the choice of appropriate algorithms and data structures. With a bit of thought, you can try to squeeze the most out of every last CPU cycle. One of the most common examples of misusing algorithms is sorting a large, unordered array with bubble sort. So, make sure to learn your algorithms and data structures – together with the knowledge from this section and beyond, it will make you a really powerful developer.

As you already know, the further...

Revisiting shared resources through the C++ memory model via spinlock implementation

We learned about atomic operations back in Chapter 7. In this chapter, you learned that the placement of atomic variables in the cache is crucial as well. Originally, atomics and locks were introduced because of correctness when multiple threads want to enter the same critical section. Now, our investigation will continue a bit deeper. There’s one last piece of the puzzle of atomic operations. Examine the following snippet:

Thread 1: shrd_res++; T1: load value
                      T1: add 1
Thread 2: shrd_res++; T2: load value
                      T2: add 1
                   ...

Summary

In this chapter, we’ve gathered together the entire set of instruments required for optimal code performance with C++. You learned techniques on many different system and software levels, so it’s understandable if you want to take a breather now. It is true that it would be good to spend more time on some of what we covered, for example, branch predictions and cache friendliness, or to implement more algorithms through condition variables and memory order. We strongly encourage you to use this chapter as a step in the direction of system improvements and more efficient work.

The next chapter is dedicated to one more significant improvement in C++’s features – coroutines. You will see that they are much lighter and, for some of the mechanisms discussed here, such as event waiting, they are much more preferable.