The Case of the Two Billion Characters Long String -- Giovanni Dicanio

By Giovanni Dicanio | Jun 7, 2023 11:24 AM | Tags: None

Several times you need to pass data (including text) from cross-platform C++ code to platform-specific C++ code. If you don't pay enough attention, weird bugs can happen at the boundary.

The Case of the Two Billion Characters Long String

by Giovanni Dicanio

From the article:

What is going on here? What is the origin of this bug? Why is the string reported as being more than 2 billion characters long?

Let's try to solve this mystery, with a sprinkle of assembly language, too!

Storage duration and Non-local Objects in C++ -- Bartlomiej Filipek

By Blog Staff | Jun 6, 2023 01:26 PM | Tags: None

C++ allows us to declare various forms of non-local objects: they usually live throughout the execution of the whole program. In this article, we’ll look at global variables, dynamic, and thread-local objects. We’ll also consider new features for safe initialization C++20.

Storage duration and Non-local Objects in C++

by Bartlomiej Filipek

From the article:

To start, we need to understand two key properties of an object in C++: storage and linkage. Let’s begin with the definition of storage, from [basic.stc#general]:

"The storage duration is the property of an object that defines the minimum potential lifetime of the storage containing the object. The storage duration is determined by the construct used to create the object."

An object in C++ has one of the following storage duration options:

Bitwise Binary Search: Elegant and Fast -- Orson Peters

By Blog Staff | Jun 2, 2023 01:18 PM | Tags: None

I recently read the article Beautiful Branchless Binary Search by Malte Skarupke. In it they discuss the merits of the following snippet of C++ code implementing a binary search.

Bitwise Binary Search: Elegant and Fast

by Orson Peters

From the article:

In this article I will provide an alternative implementation based on similar ideas but with a very different interpretation that is (in my opinion) incredibly elegant and clear to understand, at least as far as binary searches go. The resulting implementation also saves a comparison in almost every case and ends up quite a bit smaller.

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