Re: Ada Protected Object Tutorial #1

[kaz@ashi.footprints.net (Kaz Kylheku)]

On 17 Dec 1999 20:29:25 +0100, Laurent Guerby <guerby@acm.org> wrote:
>Karel Th�nissen <thoenissen@hello.nl> writes:
>> [...] He noticed that protected types are great if the caller
>> needs a single service from the protected type, but they are not that
>> great if you need more than one service from the same protected type.
>> Not only does the protected type solution require locking and unlocking
>> for every single service invocation, instead of one pair for the whole
>> deal, it also cannot avoid the situation that other tasks are serviced
>> in between two calls. 
>
>This claim is wrong, when you're inside a protected procedure, calls
>to other protected procedure on the same object are done
>without locking of course.

This requires the procedures to be passed information about whether the
object is locked by this thread or not. For example, a hidden parameterr.
In C++-like pseudocode, this might look like:

    void object::frobnicate(bool already_locked = false)
    {
	if (!already_locked);
	    lock();

	// frobnicate

	if (!already_locked)
	    unlock();
    }

That is overhead. Another thing that is possible is that the compiler might
generate two function images: one that assumes the lock and one that does not.
When a protected procedure calls another one for the same object, the compiler
will generate a call to the variant which does not acquire the lock. 

These solution requires some measure of clairvoyance: what if the protected
procedure calls into another subsystem which then calls back into a protected
procedure on the same object? How do you pass the ``already_locked'' knowledge
across calls to foreign subsystems?

The solution is probably to use recursive locks, which check the ID of the
calling against an ownership ID stored in the lock. Recursive locks are
slightly inefficient because they have to retrieve the ID of the current thread
and compare it.