C++ Memory Model: from C++11 to C++23 - Alex Dathskovsky - CppCon 2023

cppcon.org/
---
C++ Memory Model: from C++11 to C++23 - Alex Dathskovsky - CppCon 2023
github.com/CppCon/CppCon2023
In the realm of C++ development, threading and memory management play a crucial role in crafting highly parallel and optimized programs. However, the absence of a memory model in C++98 posed challenges. Thankfully, with the advent of C++11, significant changes were introduced, including the introduction of a memory model, which brought forth a plethora of new and exciting tools for developers to leverage. This talk aims to delve into the realm of the C++ memory model, showcasing the arsenal of tools at our disposal. Attendees will gain insights into how CPUs and compilers optimize code and understand the criticality of adhering to the memory model correctly. Practical guidelines on utilizing these tools effectively will also be explored.
Throughout the talk, we will illustrate practical examples and share best practices for utilizing the diverse set of tools now available to us. From atomic operations to memory barriers, we will explore the range of techniques that allow us to develop robust and thread-safe code.
This talk will also illustrate the newer tools from newer C++ standards like JThread and so this talk will show how memory model is used and how it advanced since C++11
---
Alex Dathskovsky
Alex has over 16 years of software development experience, working on systems, low-level generic tools, and high-level applications. Alex has worked as an integration/software developer at Elbit, senior software developer at Rafael, technical leader at Axxana, software manager at Abbott Israel, and now a group manager a technical manager at Speedata.io, an exciting startup that will change big data and analytics as we know them. In his current job, Alex is developing a new CPU/APU system working with C++20, massive metaprogramming, and the development of LLVM to create the next Big Thing for Big Data.
Alex is a C++ expert with a strong experience in template meta-programming. Alex also teaches a course about the new features of modern C++, trying to motivate companies to move to the latest standards.
---
Videos Filmed & Edited by Bash Films: www.BashFilms.com
CZcams Channel Managed by Digital Medium Ltd: events.digital-medium.co.uk
---
Registration for CppCon: cppcon.org/registration/
#cppcon #cppprogramming #cpp

[@kodirovsshik]

2:03 the talk starts here

[@TechTalksWeekly]

This talk has been featured in the last issue of ⭐Tech Talks Weekly newsletter. Congrats Alex! 👏

[@denisfedotov6954]

A couple of comments:
1 Volatile variables have atomic semantics in MSVC on Windows.
2 The slide regarding compiler barriers includes a non-empty asm block with an mfence instruction. This serves as both a compiler and a memory barrier. However, an empty asm block is sufficient to be a compiler barrier (but not a memory barrier). atomic_signal_fence, as far as I know, is a standard way to express a compiler barrier.

[@weiqin8494]

54:39 x86 inc is not atomic without a lock prefix. Code works because it is protected by the spin lock. Still a great usage example of acquire/release. Thanks for the great survey on concurrency support in C++.

[@Roibarkan]

24:26 JF Bastien’s talk from cppcon 2019: czcams.com/video/KJW_DLaVXIY/video.html

[@meneldal]

Only use I have found for volatile was for accessing hardware registers. You need to tell the compiler that every read/write must really happen but you also have to make sure the cpu mmu will have flagged those memory areas as noncachable so it will actually do what you want.

[@Roibarkan]

38:45 Daniel Anderson’s talk from cppcon 2023: czcams.com/video/lNPZV9Iqo3U/video.html

[@Roibarkan]

34:34 note that atomic operations are non-blocking, so in this slide Thread 2 probably needs to check that r1==1 before assigning “r2 = a;”

[@12345bvbfan]

Actually I saw such mistakes in lock-free data structures implementation, it's common mistake.

[@Roibarkan]

38:36 Timur Doumler’s talk from cppcon 2022: czcams.com/video/gTpubZ8N0no/video.html

[@Carewolf]

You need to keep in mind. Volatile before atomic instructions were the ONLY synchronization available in C and C++, therefore it works as such, even though the standard doesnt require it.

[@yk0578]

Re: Pop Quiz
what is the memory model for CPU? if its x86 then its not possible because x86 will not reorder stores after stores. y3 should be visible before y4.

[@vv78.]

Dear Alex & Co! Thank you for sharing on your knowledge. Please, Quora: Is it important to understand how computer memory works?

[@calebxyz]

Yes it is really important

[@ABaumstumpf]

20:48 here it depends on the data-types and how they are accessed. Cause either it is a data-race and thus undefined behaviour, or all variables are atomic and thus not possible, or all variables are atomic and memory_order_relaxed is used on all operations - that is the only legal way for this to happen.
std::atomic is a big mistake in the way it is formulated - and deprecating volatile is also the exact opposite of how it should be done. Volatile has a very specific meaning and it got nothing to do with "don't reorder this" or "don't optimise this" or "i need synchronisation" - and the examples for misuse of a keyword mostly boil down to people not knowing what it actually means, often due to people that know better telling them false things (like you said at 25:28). And for atomic operations it is the same thing: in no way do they mean that those operations can not be re-ordered, or that they can not be removed entirely - the only thing it means is that an operation in that memory must behave as if uninterrupted.
What really would have been needed would have been 2 keywords and 1 functionality:
something for atomicity - "atomic"
something for dataraces - "synchronised"
a simple memory-barrier - a way to specify that this step acts as a specific memory-barrier either for all or just specific memory.
I have needed operations to be atomic, synchronised and volatile but rarely if ever all 3 at once. Most of the time it really was just either volatile or sychronised.

[@kristiannyfjell8097]

What is it with C++ programmers thinking Volatile is used with atomics and threads? Every talk where Volatile is mentioned there is always emphasis on "stop using it with atomics!".
Coming from C, that is wild to me, haha

[@denisfedotov6954]

Prior to C++11 volatiles were MS specific atomics in MSVC++.

[@imrank340]

He did not show header file. Did he include pthread.h file? Since pthread.h file fully supported by Linux OS platform windows has it own mechanism for multi threading.

[@Adowrath]

Where in the talk would this matter since he uses std::thread?

[@mendor0]

No lib pthread here, its C++ standard primitives. All compliers should be able to translate it to proper (for OS/hardware) binaries.

[@Milan_Openfeint]

I guess you could skip the first 15 minutes but after that it goes quite fast.

[@MaxWright7]

Pipelining and von Neumann architecture are two different things.

[@realwermos]

You're right, but what architecture to optimizations like pipelining and superscalar processing apply to, then? 🤔
von Neumann is simply fetch-decode-execute, it doesn't really say how to do it, right?

[@user-go5oe6td3k]

It seems like C++ threads are just painfully trying to evolve pthreads into this century. Every example cited would just be easier, cleaner and more portable if implemented with good old OpenMP. I can't see a compelling argument to use this stuff.

[@soniablanche5672]

the int i{} triggers me, why not just write int i = 0 like a normal person

[@noobmartin]

Narrowing conversion checking - sure, it's not applicable in this particular case, but I've found that it helps. :)

[@Ujjawal_Gupta]

Direct initialisation also helps in avoiding narrowing conversions

[@pneuma1387]

Because c++ coders today like to overcomplicate everything.

[@Mr.Not_Sure]

Because later `int` can be changed to `T` template parameter.

[@kovoneka]

int i{} is one of the reasons i stopped learning this language