Re: C omega

[Adrian Knoth <adi@thur.de>]

Pascal Obry <pascal@obry.org> wrote:

> class ReaderWriter
> {
>   ReaderWriter() { idle (); }
>
>   public void Shared() & async idle() {s (1); }
>   public void Shared() & async s(int n) { s(n+1); }
>   public void ReleaseShared() & async s(int n) {
>     if (n == 1) idle (); else s(n-1);
>   }
>   public void Exclusive() & async idle() {}
>   public void ReleaseExclusive() {idle (); }
> }
>
> I'm not sure to fully understand the code above, but it looks quite complex
> to me :)

Looks pretty much like semaphore-handling (Dijkstra?). Access to
a shared value (not shown here) is handled. When you call the
the Shared()-function for an instance of ReaderWriter it checks
whether this resource is idle and if so, sets s to 1.
If it is already used by others it increments the value of waiting
processes by one.

The ReleaseShared might be called to let one process say he's
no longer willingly to access this shared value, so the number
is decremented. If there is only one process left using it the
state is changed to idle.

Function Eclusive seems not to be implemented or it is a builtin
function and there is nothing more to do.

ReleaseExclusive marks the resource as available (dile).

The constructor lets new instances be idle.

> What is interesting is that the same code(*) in Ada (not compiled) is:

I wouldn't say it's the same code. Unfortunately you haven't mentioned
the website where you found this example. Otherwise it would be
possible to see what is really ment instead of wild guessing.



-- 
mail: adi@thur.de  	http://adi.thur.de	PGP: v2-key via keyserver

Leute, die mehr als ein xterm offen haben, kann man ja wohl sowieso
nicht ernst nehmen.      (Felix von Leitner in dcoul-tng@socha.net)