module Counting:`sig`

..`end`

`type `

t

The type of counting semaphores.

`val make : ``int -> t`

`make n`

returns a new counting semaphore, with initial value `n`

.
The initial value `n`

must be nonnegative.

**Raises**`Invalid_argument`

if`n < 0`

`val release : ``t -> unit`

`release s`

increments the value of semaphore `s`

.
If other threads are waiting on `s`

, one of them is restarted.
If the current value of `s`

is equal to `max_int`

, the value of
the semaphore is unchanged and a `Sys_error`

exception is raised
to signal overflow.

**Raises**`Sys_error`

if the value of the semaphore would overflow`max_int`

`val acquire : ``t -> unit`

`acquire s`

blocks the calling thread until the value of semaphore `s`

is not zero, then atomically decrements the value of `s`

and returns.

`val try_acquire : ``t -> bool`

`try_acquire s`

immediately returns `false`

if the value of semaphore `s`

is zero. Otherwise, the value of `s`

is atomically decremented
and `try_acquire s`

returns `true`

.

`val get_value : ``t -> int`

`get_value s`

returns the current value of semaphore `s`

.
The current value can be modified at any time by concurrent
`Semaphore.Counting.release`

and `Semaphore.Counting.acquire`

operations. Hence, the `get_value`

operation is racy, and its result should only be used for debugging
or informational messages.