How to protect a non-atomic variable from modification by both interrupt and application code without blocking

Question

I want to be able to modify a non-atomic variable in interrupt context or application context without ever blocking. To prevent the ISR from blocking, I use an atomic flag to guard the non-atomic data.

#include <atomic>
#include <cstdint>

using CountLock = std::atomic<bool>;
static_assert(CountLock::is_always_lock_free, "count lock must be lock free");

#define TARGET_COUNT (1000)
CountLock count_locked{false};
uint64_t  count{0}; // non-atomic on 32-bit system

// In interrupt
void MyISR()
{
    // Don't modify count if locked
    if (count_locked)
        return;

    ++count; // non-atomic

    if (count == TARGET_COUNT)
        // Do something
}

// Application code (not in interrupt)
void setCount(uint64_t newCount)
{
    // lock count while we are setting it
    count_locked = true;
    count = newCount;
    count_locked = false;
}

1. Does this correctly guard the data?
2. Is the compiler allowed to compile out the count_locked variable or reorder instructions such that the data is outside the lock?
3. Am I correct in thinking nothing needs to be marked volatile?
4. Is this equivalent to a mutex?

Answer 1

Consider two threads concurrently calling MyISR and setCount respectively:

T1                             T2

if (count_locked)
        return;

                               count_locked = true;

 ++count; /*non-atomic*/       count = newCount;        // << data race

 if (count == TARGET_COUNT)
    // Do something

                               count_locked = false;

The atomic does not protect writes to count .

1. No

2. The data is modifed without being properly locked anyhow

3. Yes. Quoting from When to use volatile with multi threading? : "volatile is (nearly) useless for platform-agnostic, multithreaded application programming."

4. No