semaphore

You cannot easily (in userspace) implement mutex with semaphore(s) or semaphore with mutexe(s), because they by design have different semantics, i.e.

What we have here is an implementation of a counting semaphore, using a semaphore.

I think the point is that semaphore calls might be expensive, while in the normal case this is a simple one-instruction atomic increment.

My point, on the other hand, is that this one-instruction atomic increment and test, with a conditional wait call is a semaphore (though perhaps a faster one than the underlying semaphore).

That looks like some API/kernel call overhead; you've moved the fast path of the semaphore implementation into user space.

Some ivory tower nut proved in the 70s that semaphore-and-thread was logically equivalent to queue-and-message, i.e.

Or even with less theoretical topics, they're less likely to know what second normal form is, or semaphore P&V's etc.

Just a layman, but the thing about train track controls made me think about parallel computing and the semaphore concept.

If your attempt to open the semaphore fails, you create it and become the daemon.

But a semaphore doesn't track which thread is in the critical section, so you don't know which thread's priority to boost.

Locking a semaphore should be the same cost as accessing a (potentially cached) memory location.

But what you have there is undeniably a semaphore implementation: atomically tweak a counter, and based on that result, wait or signal.

Maybe I'm wrong, but by checking the "redundant" atomic counter before trying to acquire the semaphore, he's saving up a system call, which would imply making (unnecessary) context changes.

If I implement the mutex as you suggest -- by using the native semaphore directly, with no separate counter -- the running time of "testBenaphore" increases from 375 ms to 3 seconds on my Windows PC.

My own experience, which is fairly limited, is that Ansible is much simpler, "agent-less" (it uploads code as needed and remote executes it over SSH) and a mix between declarative and imperative in nature (a lot of the modules require you to use semaphore files or equivalent for idempotence.) Orchestration is pretty much built-in, including rolling deployment/restarts.

Semaphore, I'm suggesting: Block on N-Semaphore, with timeout Do timeout upload Replace N-Semaphore If you don't always replace the semaphore, that's a bug.

Re: Semaphore: Not dropping the connection might mean we might starve others incoming msgs of resources (which might be a good thing) [0].

In case that phrase confuses others reading that: a Condition Variable is a sync-related construct - like Mutex or Semaphore.