Re: Blocking protected ops (was: Tasks and C/C++ code)

[tmoran@bix.com (Tom Moran)]

The Claw Windows binding uses WSAAsyncGetHostByName, which gets
around most of the blocking.  But more generally, to call a blocking
routine in a task safe way, Mats Weber's example is basically what
you need to do.

If you are going to have multiple semaphores, you will want to
create a protected semaphore type, so you can declare different
semaphores for different resources.

If your code between Seize and Release is complex, you might find it
less error-prone to create a controlled type whose Initialize calls
Seize and whose Finalize calls Release, to make sure those are both
called properly, ie something like this:

protected type Semaphore -- like Mats Weber's example, but a type

type Access_Semaphore is access all Semaphore;

type Seizer(What : Access_Semaphore)
  is new Ada.Finalization.Limited_Controlled with null record;

procedure Initialize(S : in out Siezer);
procedure Finalize(S : in out Siezer);

...

procedure Initialize(S : in out Siezer) is
begin
  Seizer.What.Seize;
end Initialize;

procedure Finalize(S : in out Siezer) is
begin
  Seizer.What.Release;
end Finalize;

...
Gethostbyname_Protector : Semaphore;

function Protected_Gethostbyname (Name : ...
   Owner : Seizer(Gethostbyname_Protector'access);
begin
   return Gethostbyname(Name);
end Protected_Gethostbyname;


Another_Resource : Semaphore;

procedure Something ...
   Owner : Seizer(Another_Resource'access);
begin
   ....
end Something;

etc.
(I've indicated elsewhere some of the reasons I think using
System.Address is a poor idea, but that's an orthogonal issue.)