Consider the following pattern:
std::atomic_flag flag = ATOMIC_FLAG_INIT;
// Thread A
flag.test_and_set(std::memory_order_release);
flag.notify_all();
// Thread B
flag.wait(false, std::memory_order_acquire);
It can nicely be simplified with a latch:
std::latch latch{ 1 };
// Thread A
latch.count_down();
// Thread B
latch.wait();
This seems a direct improvement, but unfortunately it really isn't:
1. There's no guarantee that `std::latch` uses atomics under the hood
2. There's no guarantee that `std::latch` is "lock-free"
3. All functions in the first pattern were `noexcept`, while none of the `latch`'s functions are
I would like to be able to use the higher-level pattern using `std::latch` without sacrificing performance nor exception safety.
It would be nice if there was a way to detect at compile-time if `std::latch` uses atomic operations under the hood and is guaranteed to not throw.
Something like `std::atomic<T>::is_always_lock_free`, but for latches.
Ideas:
- std::latch::is_always_lock_free
- std::latch::uses_atomic_operations
- std::latch::is_atomic
Additionally, it would be nice if the Standard mentioned that while
`std::latch`'s functions cannot be generally be marked `noexcept`, they are guaranteed to never throw if the above trait is true.
What do you think?
Worth writing a paper?
Cheers,
Vittorio Romeo
https://vittorioromeo.com