ModernesCpp | Blog library

After reading your question more carefully, looks like your modernescpp link is making the same mistake that Preshing debunked in https://preshing.com/20131125/acquire-and-release-fences-dont-work-the-way-youd-expect/ - fences are 2-way barriers, otherwise they'd be useless.

A relaxed load followed by an acquire fence is at least as strong as an acquire load. Anything in this thread after the acquire fence happens after the load, thus it can synchronize-with a release store (or a release fence + relaxed store) in another thread.

But will it prevent store/loads before this fence being reordered after itself?

Stores no, it's only an acquire fence.

Loads, yes. In terms of a memory model where there is coherent shared cache/memory, and we're limiting local reordering of access to that, an acquire fence blocks LoadLoad and LoadStore reordering. https://preshing.com/20130922/acquire-and-release-fences/

(This is not the way ISO C++'s formalism defines things. It works in terms of happens-before rules that order things relative to a load that saw a value from a store. In those terms, a relaxed load followed by an acquire fence can create a happens-before relationship with a release-sequence, so later code in this thread sees everything that happened before the store in the other thread.)

Shouldn't max value be const?

Yes. In fact, counting_semaphore::max() is required to be constexpr, meaning that it is not just constant, but a compile-time constant. For a given LeastMaxValue, the max can vary from compilation to compilation, but no more than that.

Perhaps that's the source of your confusion? From the perspective of watching a program run, the max() corresponding to a given LeastMaxValue is constant. From the perspective of making sure code works across multiple compilers and platforms, max() can vary.

When you declare a variable whose type is std::counting_semaphore<5>, you are declaring that the variable's counter will need to go up to 5. This becomes a request to the compiler that the counter be able to hold 5. If it happens that the counter can hold 255, well that's fine. You don't plan to raise the counter that high, so your code will function correctly with that maximum.

Look at the constructor of std::counting_semaphore. This will function correctly as long as the initial value of the counter satisfies 0 <= initial and initial <= max(). The first condition is easy to satisfy, but how do you satisfy the second? You can do this by satisfying a more stringent requirement – make sure initial <= LeastMaxValue. This is more stringent, because the compiler is obligated to ensure that for your choice of LeastMaxValue, the corresponding max() is at least as large; that is, LeastMaxValue <= max(). As long as you specify a high enough value for LeastMaxValue, the constructor will work as intended with your initial value.

There is a similar requirement for release() to function correctly. Correct behavior requires that the counter not exceed max(), which you can ensure by not exceeding LeastMaxValue. You do get correct behavior if the counter ends up between LeastMaxValue and max(), but then you are subject to the whims of your compiler. A different compiler might give you a lower max(). If you want to play in this area, your code needs to adapt to a max() that can change from compiler version to compiler version.

You could think of this as being similar to int_fast8_t in that the 8 specifies the minimum size of the type, but the compiler can give you more. You are guaranteed that the maximum value that can be stored in this type is at least 127 (the minimum max value). You might get more than 8 bits in this type, and hence be able to store higher values, but you might not.

Whether you have set the c++ language standard?

Property -> General -> C++ Language Standard -> /std: c++ latest

I could build successfully in visual studio 2022 preview 17.0.0 preview 2.0.

And I could also build successfully in visual studio 2019.

The C++20 standard does not include module definitions for the C++ standard library. Visual Studio does (unfortunately), and a lot of bad sites out there will act like this is standard. But it's not; it's just a Microsoft thing.

If you want to include the C++ standard library through a module across platforms, you will have to either use import syntax or write your own standard library modules that import the headers and export specific C++ declarations.

You can get rid of your parse implementation and use the inherited function, and use fmt::formatter::format(item, context) inside your format to output each item (godbolt demo):

It's the constructor (7) in the overload set:

Has the Concurrency TS been dropped?

Yes.

P1445 discusses this, SG1 voted to withdraw the TS. Note that atomic smart pointers, latches, and barriers are in C++20.

As far as improving future goes, the direction there is called executors and the design currently being iterated on is P0443, which allows for lazy composition of work in a way that would be much more efficient than future::then. Two of the authors gave a talk on this at CppCon that goes into the issues pretty well.

CRTP is used for static polymorphism.

If you need runtime polymorphism, there are many ways of achieving that. Virtual member functions with classic OOP inheritance is only one way.

From the excellent "Embrace no Paradigm Programming!", we can see other ways we can do it and how they compare to each other:

If you're only using a known number of derived classes, I'd recommend using a variant-like data structure. It has static storage, so no unnecessary heap allocations, and all of the storage is abstracted from you.

If you need to export the func() implementation explicitly, then you'd need to use polymorphic values ("type erasure" on the slides). See the classic Sean Parent talk "Better Code: Runtime Polymorphism". Notice it also uses vtables. To abstract vtables, you'd need to use a more complex struture, like Sy Brand shows in their "Dynamic Polymorphism with Metaclasses and Code Injection" talk.

Also, notice the "OO" performance is not that bad. Virtual member functions aren't that expensive in modern computers, and usually only high-performance/low-latency code cares deeply about this type of optimization.

But what is the formal rule behind this form?

The rule (that you correctly guessed your way into) is described in [temp.param]/4:

A type-constraint Q that designates a concept C can be used to constrain a contextually-determined type or template type parameter pack T with a constraint-expression E defined as follows. If Q is of the form C, then let E′ be C. Otherwise, let E′ be C. If T is not a pack, then E is E′, otherwise E is (E′ && ...). This constraint-expression E is called the immediately-declared constraint of Q for T. The concept designated by a type-constraint shall be a type concept ([temp.concept]).

With examples in the subsequent paragraph:

A type-parameter that starts with a type-constraint introduces the immediately-declared constraint of the type-constraint for the parameter. [ Example: