🚀 go-pugleaf

>>> Is it possible to set up a system semaphore that must be cleared as many
>> times as it has been set in order for a waiting thread to become runnable?
>
>>I always thought that's the way RAM semaphores were implemented?

> It all depends.  If you use DosSemRequest and DosSemClear, the behavior is
> as described above.  Using a DosSemWait/DosSemClear scheme, the semaphore
> need only be cleared once for a waiting thread to become runnable.
> ----------

I'm not so sure this is true, but I can't say I've ever tried it.
According to the Programmers Reference, "The DosSemRequest function requests
that the specified semaphore be set AS SOON AS IT IS CLEAR...If the
semaphore has already been set by another thread, the function WAITS until
a thread clears the semaphore... or until a time-out occurs."

It sounds to me like this is not what is desired by the original poster.
What is needed is a way to set a semaphore without waiting, but have the
semaphore not be cleared until all threads that set the semaphore clear
it.  I'm not sure DosSemRequest can do that.

If OS/2 doesn't give you this functionality, it is possible to create
this functionality using 2 normal system semaphores.  The following
algorithm describes how to do it:

var MUTEX, DELAY: SEMAPHORE /* binary semaphores */
    K: INTEGER;   /* counting semaphore value */

    MUTEX = 1; DELAY = 0;
    K = x;      /* initialize it to highest desired value */

    P(K) = P(MUTEX);
           K = K - 1;
           if K < 0 then
               V(MUTEX);
               P(DELAY);
           else
               V(MUTEX);

    V(K) = P(MUTEX);
           K = K + 1;
           if K <= 0
               V(DELAY);
           V(MUTEX);

If this isn't clear, sorry, but I didn't have time to study it.  I
got the algorithm from "Parallel Programming" by R.H. Perrott.  Almost
any decent Operating Systems book should have a similar algorithm.

Tom Johnson