Re:Ditch your (mut)ex, you deserve better
by gpderetta on Tuesday November 18, 2025 @07:28AM
(#45964701)
CPS can trivially deadlock for all meaningful definitions of deadlock.
Would you consider this a mutex?
async_mutex mux;
co_await mux.lock();
/* critical section */
co_await mux.unlock();
What about:
my_mutex mux; {
std::lock_guard _{mux};
/* critical section */
}
where the code runs in a user space fiber.Would you consider boost synchronized a mutex?
Don't confuse the semantics with the implementation details (yes async/await leaks implementation details).
Re:Ditch your (mut)ex, you deserve better
by mgaunard on Wednesday November 19, 2025 @06:13AM
(#45978217)
You only achieved a deadlock by re-introducing mutexes.
Re:Ditch your (mut)ex, you deserve better
by gpderetta on Wednesday November 19, 2025 @06:33AM
(#45978329)
Given:
Something someting;
async_mutex mtx;
void my_critical_section(Data&);
1: await mtx.lock();
my_critical_section(something);
await mtx.unlock();
2: auto my_locked_critical_section() {
await mtx.lock();
my_critical_section(something);
await mtx.unlock();
}
...
await my_locked_critical_section(something);
3: auto locked(auto mtx, auto critical_section) {
await mtx.lock();
critical_section();
await mtx.unlock();
}
...
await locked(mtx, [&]{ my_critical_section(something); });
4: template<class T>
struct synchronized {
async_mutex mtx;
T data;
auto async_visit(auto fn) { locked(mtx, [fn,&data]{ fn(data); }); }
};
synchronized<Something> something;
await something.async_visit([](Something& data) { my_critical_section(something); });
If 1 is a mutex, at which point it stops being a mutex? Note that 4 is my initial example.
Re:Ditch your (mut)ex, you deserve better
by mgaunard on Wednesday November 19, 2025 @04:14PM
(#45985291)
it's a mutex iff it's acquiring a resource exclusively.
which you don't need to do for synchronization of coroutines since you can control in which order things are scheduled and whether that's done concurrently or not.
Re:Ditch your (mut)ex, you deserve better
by gpderetta on Thursday November 20, 2025 @04:35AM
(#45990813)
Not if you have multiple schedulers. Case in point: asio.strand or execution::on [1].
And even with one scheduler it makes sense to explicitly mark your critical sections.
Really, at the end of the day the primary purpose of a mutex is serialization of all operations on some data. The blocking behaviour is just a way to implement it.
CPS shouldn't be able to deadlock for example?