I found C++ Concurrency in Action to be pretty helpful. Also if you're able to run TSan it'll really shine a light on your code and will help you sleep more easily. (https://github.com/google/sanitizers/wiki/ThreadSanitizerCpp..., currently built into clang I believe)

C++ STL Cookbook, C++ 17 in Detail, C++ Notes for Professionals (free very detailed cheatsheet) https://books.goalkicker.com/CPlusPlusBook/, C++ Concurrency in Action, Second Edition, Functional Programming in C++

I've read C++ Concurrency in Action and found it very helpful in understanding these concepts: http://www.manning.com/williams/

The books i had mentioned are old pre-C++11(hence you can easily get cheap used copies) but which give you insight into "how to think and program in C++". They are still relevant, though might not see usage currently, because the language/libraries have evolved.

I am ambivalent on "Modern C++"(they have made it more complicated and invented a new language) and still ramping up on its features and nuances. Haven't really found any insightful book so far (except for "C++ Concurrency in Action" by Anthony Williams which of course is specialized).

However i recently found "Modern C++ Programming Cookbook" by Marius Bancila which seems like a very nice catalog of all the C++11/14/17 features. This seems to go well together with Stroustrup's book.

> instructions that were cheap become expensive

Agree.

At which point, C gives you a huge advantage. Sure, you can hand write assembly, but I bet the libc implementation you're linking against has optimized to death with intimate knowledge of timing sequences and inner state of the processor from the processor vendor. I would expect a company like Intel to contribute patches to glibc (GNU libc) based on running functions from the standard library on a very very expensive FPGA (or just expensive-software simulation of hardware).

Memory ordering operations are an advanced topic; I have a copy of C++ Concurrency in Action, currently sitting on my bookshelf, that has a chapter explaining the concepts. Should be a fascinating read!

Interesting. I bought C++ Concurrency in Action today and am learning all these details of the memory model.

You mention of caches makes me realize that a single-reader single-writer queue can probably also be optimized by putting the head pointer and the tail pointer on different cache lines. The reader and writer can cache the other's value on their own page, and only reload it when the queue otherwise looks full or empty, respectively. This should allow the reader and writer to act without needing to synchronize cache lines for many operations.

Some good C++98 books :

- Accelerated C++: Practical Programming. A good quick tour of C++98

- Effective C++, More Effective C++,Exceptional C++, C++ Coding Standard

Many patterns to follow or be aware of. More generally, any book by Herb Sutter.

Good recent books (msut have !!):

- Effective Modern C++ (same as previous, but more focused on C++11 and 14)

- Programming: Principles and Practice Using C++ (A general introduction book by Stroustrup on programming using C++)

- C++ Primer (The spiriual son of Accelerated C++, the best introduction book about C++ I know)

The textbook and more specific books :

- The C++ Programming Language (the ultimate C++ textbook)

- C++ Template the complete Guide (focused on templates)

- C++ Concurrency in Action (focused on threading)

In a second time, have also a look at some libraries like boost (many specific purpose components), Qt (huge framework for making GUI), Poco.

- Website
https://isocpp.org/ (the official website for the language).

- Have a look at usenet (comp.lang.c++ and comp.lang.c++.moderated), CppCon's videos, Meeting C++ videos and Channel 9

Further, a lot of shared data structures in super high perf C++ end up with "Free Lists" to allow multiple threads to perform atomic delete operations on the data structure. Point being that memory is no longer freed deterministically.

"If there's other threads working here, atomic compare and swap this pointer to the free list, otherwise last one out clean up."

Take a look at some of the code from Chapter 7 from Anthony Williams "C++ Concurrency in Action" [0].

[0] https://manning-content.s3.amazonaws.com/download/0/78f6c43-...

Last year I went through Anthony William's C++ Concurrency in Action to better understand the "new" threading library. No complaints. Actually, I've been using it in several components that are "pure C++" (i.e., no Qt, only STL).

My point of view is that, where I'm using Qt anyway, I might as well use its threading library for the very nice support it provides for other things such as signal-slot connections across threads.

Well, getting 1.7x speedup on a dual core box isn't so bad and makes some sense. Showing at least the context switching isn't crippling, if you can cope with the memory overhead.

Anthony William's book "C++ Concurrency in Action" gave me the impression that implementations of std::async would stop spawning new threads at some implementation defined limit based on harware concurrency levels. Instead, delay execution or switch to serial for extra tasks.