Dealing with Sharing -- Rainer Grimm

By Blog Staff | Jun 1, 2023 02:36 PM | Tags: None

If you don’t share, no data races can happen. Not sharing means that your thread works on local variables. This can be achieved by copying the value, using thread-specific storage, or transferring the result of a thread to its associated future via a protected data channel.

Dealing with Sharing

by Rainer Grimm

From the article:

The patterns in this section are quite obvious, but I will present them with a short explanation for completeness. Let me start with Copied Value. If a thread gets its arguments by copy and not by reference, there is no need to synchronize access to any data. No data races and no lifetime issues are possible.

Data Races with References

The following program creates three threads. One thread gets its argument by copy, the other by reference, and the last by...

Concurrency Patterns -- Rainer Grimm

By Blog Staff | May 30, 2023 11:28 AM | Tags: None

There are many well-established patterns used in the concurrency domain. They deal with synchronization challenges such as sharing and mutation but also with concurrent architectures. Today, I will introduce and dive deeper into them in additional posts.

Concurrency Patterns

by Rainer Grimm

From the article:

The main concern when you deal with concurrency is shared, mutable state or, as Tony Van Eerd put it in his CppCon 2014 talk “Lock-free by Example”: “Forget what you learned in Kindergarten (ie stop Sharing)”. A crucial term for concurrency is a data race. Let me first define this term.

• Data race: A data race is when at least two threads access a shared variable simultaneously. At least one thread tries to modify the variable. If your program has a data race, it has undefined behavior. This means all outcomes are possible, so reasoning about the program makes no sense anymore.

A necessary condition for a data race is a mutable, shared...

Mutating Through a Filter -- Barry Revzin

By Blog Staff | May 26, 2023 02:07 PM | Tags: None

Nico Josuttis gave a talk recently that included an example and I wanted to explain what’s going on in this example, what the issue is, and what (if anything) is broken.

Mutating Through a Filter

by Barry Revzin

From the article:

As with a lot of my explanations, we have to start from the beginning.

The C++ iterator model has a number of iterator categories: input, forward, bidirectional, random access, and (since C++20) contiguous. This post only needs to consider the first two.

An input range (a range whose iterator is an input iterator) is a single-pass range. You can only ever call begin() one time on it. You can’t have multiple different input iterators into the same range - incrementing one immediately invalidates any existing copies.

Modern C++ In-Depth — Is string_view Worth It?

By Jens Maurer | May 25, 2023 06:46 AM | Tags: c++17 basics

An introduction to std::string_view

Modern C++ In-Depth — Is string_view Worth It?

by Michael Kristofik

From the article:

std::string_view makes it easier to write generic code that can accept read-only references to character sequences, regardless of the underlying container that holds that data. ... However, like normal references, there is potential for misuse.

How To Check If A Pointer Is In A Range Of Memory -- Raymond Chen

By Blog Staff | May 24, 2023 08:09 AM | Tags: None

C language was defined to cover a large range of computer architectures, including many which would be considered museum relics today. It therefore takes a very conservative view of what is permitted, so that it remains possible to write C programs for those ancient systems. (Which weren’t quite so ancient at the time.)

How To Check If A Pointer Is In A Range Of Memory

by Raymond Chen

From the article:

Suppose you have a range of memory described by two variables, say,

byte* regionStart;
size_t regionSize;

And suppose you want to check whether a pointers lies within that region. You might be tempted to write

if (p >= regionStart && p < regionStart + regionSize)

but is this actually guaranteed according to the standard?

Why is std::hardware_destructive_interference_size a Compile-time Constant ... -- Raymond Chen

By Blog Staff | May 22, 2023 03:03 PM | Tags: None

C++17 added a new compile time constant std::hardware_destructive_interference_size which tells you (basically) the size of a cache line. The purpose of this is to allow you to lay out your structures in a way that avoids false sharing.

Why is std::hardware_destructive_interference_size a Compile-time Constant Instead of a Run-time Value?

by Raymond Chen

From the article:

C++17 added a new compile time constant std::hardware_destructive_interference_size which tells you (basically) the size of a cache line. The purpose of this is to allow you to lay out your structures in a way that avoids false sharing.¹

But how does the compiler know what the cache line size will be of the CPU the program will eventually be run on? Shouldn’t this be a run-time value instead of a compile-time value?

Well yes, the actual size of the cache line isn’t know until run-time, because it is only then that the program meets a CPU. But really, you want this to be a ...

Reactor -- Rainer Grimm

By Blog Staff | May 19, 2023 02:58 PM | Tags: None

Event-driven applications, such as GUIs or servers, often apply the architecture pattern Reactor. A Reactor can accept multiple requests simultaneously and distribute them to different handlers.

Reactor

by Rainer Grimm

From the article:

The Reactor Pattern is an event-driven framework to concurrently demultiplex and dispatch service requests to various service providers. The requests are processed synchronously.

Problem

A server should

• be extendable to support new or improved services
• be performant, stable, and scalable
• answer several client requests simultaneously

The application should be hidden from multi-threading and synchronization challenges

Solution

• Each supported service is encapsulated in a handler
• The handlers are registered within the Reactor
• The Reactor uses an event demultiplexer to wait synchronously on all incoming events
• When the Reactor is notified, it dispatches the service request to the specific handler

Q&A - C++ Initialization -- Bartlomiej Filipek

By Blog Staff | May 17, 2023 09:43 AM | Tags: None

Last time I showed a couple of questions about initialization. Try them here if you haven’t already. In this article, I’ll show you the answers and add more notes about initialization in C++.

Q&A - C++ Initialization

by Bartlomiej Filipek

From the article:

Will this code work in C++11?

struct User { std::string name = "unknown"; unsigned age { 0 }; };
User u { "John", 101 };

1. Yes, the code compiles in C++11 mode.
2. The code compiles starting with C++14 mode.
3. The code doesn’t compile even in C++20.

The Obvious Final Step -- Andrzej Krzemieński

By Blog Staff | May 15, 2023 12:39 PM | Tags: None

During the construction of an XML file when you write an element, it is obvious that the last thing that you do is to write the closing tag. By obvious we mean: writing it down adds no new information (there is no other possible final instruction for this task), and it would be a bug if this instruction wasn’t there.

The Obvious Final Step

by Andrzej Krzemieński

From the article:

The title may be misleading, as I had to invent a new short term for the pattern that occurs in the code once in a while. Example first:

// write an element of an XML file

xml.begin_element("port");
xml.attribute("name", name);
xml.attribute("location", loc);
xml.end_element("port");  // <-- the obvious final step

Defining Interfaces in C++: Concepts Versus Inheritance -- Daniel Lemire

By Blog Staff | May 12, 2023 02:28 PM | Tags: None

In a previous blog post, Daniel Lemire showed how you could define ‘an interface’ in C++ using concepts and stated that he did not take into account inheritance as a strategy. He does so here.

Defining Interfaces in C++: Concepts Versus Inheritance

by Daniel Lemire

From the article:

In a previous blog post, I showed how you could define ‘an interface’ in C++ using concepts. For example, I can specify that a type should have the methods has_next, next and reset:

template <typename T>
concept is_iterable = requires(T v) {
                        { v.has_next() } -> std::convertible_to<bool>;
                        { v.next() } -> std::same_as<uint32_t>;
                        { v.reset() };
                      };