Arguments for single-mutex-exclusion on protected types (Was: Does Ada tasking profit from multi-core cpus?)

[Jacob Sparre Andersen <sparre@nbi.dk>]

Jeffrey R. Carter wrote:

> The last time I looked at the GNAT sources for protected objects,
> each had a mutex associated with it that was obtained before any
> action, even functions. I guess that hasn't changed.

Isn't that the most efficient implementation on a POSIX system?

 a) We use threads (and not processes) for tasks, since it is more
    efficient and a better conceptual match.

 b) We know that it is considered good style to make protected
    function bodies small.

 c) Since we use threads (a) we should use mutexes (and not
    semaphores) to implement inter-task exclusion.

 d) Since the protected function bodies can be assumed to be small
    (b), there will be a relatively large overhead in keeping track of
    the number of queued calls to protected functions and procedures.

 e) Since the protected function bodies can be assumed to be small
    (b), the probability of colliding calls to protected functions is
    relatively small.

 f) It is thus likely that using a single mutex to provide exclusion
    on a protected object is more efficient than adding counters.

The balance in (f) depends on your average collision rate for
protected function calls.  More concurrent threads (more CPU cores)
increase this value.  So does larger protected function bodies.

Now that multi-CPU-core systems are more common, it may be worthwhile
to make a proper examination of the numbers which may change the
balance against (f).

This could also be a challenge for code profilers and optimisers.  It
may be that some protected types need a detailed queue, while others
need a single mutex - depending on the code and the number of
available CPU cores.

Greetings,

Jacob
-- 
Scripts for automating parts of the daily
operations of your Linux system:
                    http://edb.jacob-sparre.dk/tcsh-samling/