Can std::atomic_flag be used in a signal handler

Question

According to the C++17 standard, [support.signal], the atomic object should satisfy the following requirements to be used in a signal handler:

• [...], or
• f is a non-static member function invoked on an object A, such that A.is_­lock_­free() yields true, or
• f is a non-member function, and for every pointer-to-atomic argument A passed to f, atomic_­is_­lock_­free(A) yields true.

std::atomic_flag doesn't fit here formally (there is no is_lock_free method and atomic_is_lock_free can't be called with std::atomic_flag object). Though intuitively, it's very close (it's atomic and lock-free). Does it mean that std::atomic_flag can't be used in a signal handler, or it's just a C++ standard that needs clarification?

Azoic

std::atomic_flag is always lock free, so it seems to me like it should be usable in a signal handler, but I agree that it doesn't seem legal by the current wording. I don't see any existing standard defects relating to it. Assuming no one more knowledgable than myself has a better answer, there are instructions for submitting a standard defect report here. – Canticle

why do you need specifically atomic_flag? can you use atomic<bool>? their performance is exactly the same – Workout

@AndriyTylychko what to use in the signal handler is really out of the scope of my question, but yes, I just use atomic bool – Azoic

Also, note that atomic_flag is guaranteed to be lock-free, unlike atomic bool, where you have to check lock-free in runtime with method is_lock_free. I guess in practice it's always true though – Azoic

Answer 1

What you have pointed out is a defect in the standard that has been resolved in LWG 3756 Is the std::atomic_flag class signal-safe?.

The new wording obviously allows for std::atomic_flag to be used in signal handlers:

A plain lock-free atomic operation is an invocation of a function f from [atomics], such that:

• [...]
• f is a non-static member function of class atomic_flag, or
• f is a non-member function, and the first parameter of f has type cv atomic_flag*, or
• [...]

An evaluation is signal-safe unless it includes one of the following:

• a call to any standard library function, except for plain lock-free atomic operations and functions explicitly identified as signal-safe;
• [...]

It's probably safe to assume that std::atomic_flag is signal-safe in any standard prior to C++23 too, given that it's intended to be, and basically satisfies the requirements, even if not technically.

Judsonjudus