rDrop | Programmatic interface to Dropbox | Content Management System library

The C++ standard doesn't specify the code generated by any particular construct; only correct combinations of thread communication tools product a guaranteed result.

You don't get guarantees from the CPU in C++ because C++ is not a kind of (macro) assembly, not even a "high level assembly", at least not when not all objects have a volatile type.

Atomic objects are communication tools to exchange data between threads. The correct use, for correct visibility of memory operations, is either a store operation with (at least) release followed by a load with acquire, the same with RMW in between, either the store (resp. the load) replaced by RMW with (at least) a release (resp. acquire), on any variant with a relaxed operation and a separate fence.

In all cases:

• the thread "publishing" the "done" flag must use a memory ordering at least release (that is: release, release+acquire or sequential consistency),
• and the "subscribing" thread, the one acting on the flag must use at least acquire (that is: acquire, release+acquire or sequential consistency).

In practice with separately compiled code other modes might work, depending on the CPU.

The pdf that you posted is different from the screenshot in your question, so I am presuming the old version was incorrect (or at least not precise enough).

Chapter 4.3. actually starts with the following remark:

Let us suppose that CPUs queue invalidation requests, but respond to them immediately. This approach minimizes the cache-invalidation latency seen by CPUs doing stores, but can defeat memory barriers, as seen in the following example.

The sequence is also a bit different than what you posted:

1. CPU 0 executes a=1. The corresponding cache line is read-only in CPU 0’s cache, so CPU 0 places the new value of "a" in its store buffer and transmits an "invalidate" message in order to flush the corresponding cache line from CPU 1's cache.

2. CPU 1 executes while (b==0) continue;, but the cache line containing "b" is not in its cache. It therefore transmits a "read" message.

3. CPU 1 receives CPU 0's "invalidate" message, queues it, and immediately responds to it.

4. CPU 0 receives the response from CPU 1, and is therefore free to proceed past the smp_mb() on line 4 above, moving the value of "a" from its store buffer to its cache line.

I believe this is a hypothetical scenario, but when you take this into account, the obviously problematic part is CPU 1 acknowledging an "invalidate" message before actually invalidating its cache, which makes CPU 0 think it can proceed.

The answer is use GPGME. The GPGME library encapsulates most, if not all, commonly used GnuPG functions. With just a few configuration lines everything GnuPG related "just works." This posting is a good guide: https://sanctum.geek.nz/arabesque/gnu-linux-crypto-email/

In the end my setup now looks like:

Leaving lines 6-9 out of CPU 0 would definitely prevent the assert() from firing. Then again, so would removing all the code other than the assert, given that e is initialized to zero. However, both modifications are unhelpful. Instead, the key point of the assertion is the question "Is it possible for CPU 2 to see the state e==1&&a==0 at the end of its execution?" Looking at it this way should force you to think in terms of what values propagate where in what order.

But the main thing you overlooked is that this paper is extremely old, and there has been a huge amount of progress in understanding and formalizing memory ordering since then. I am in the process of adding a new memory-ordering chapter to Is Parallel Programming Hard, And, If So, What Can You Do About It? In the meantime, the pair of LWN articles here and here may be helpful.

Or if you want to see the current state of the book, git clone git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/perfbook.git.

You can use the rDrop2 package to upload ANY file into Dropbox - it's just an API wrapper for the Dropbox service.

Below is some pseudocode which should work once you authenticate on your own machine using the package: