Re: How to avoid unreferenced objects (mutexes etc)

["Matthew Heaney" <mheaney@on2.com>]

"Darren New" <dnew@san.rr.com> wrote in message
news:3C45C12D.A229F569@san.rr.com...
> Errr, no. I'm pretty sure a selective accept works in tasks.

Yes, it does, but you shouldn't bother using it.  Have the task wait on a
guarded entry of a protected object, and communicate with the task by
calling a protected procedure of the protected object.


> Yes. But the problem is in the callee you want a selective accept, and
> in the caller you want a conditional entry, and you don't want those two
> tied together at compile time.

Fine.  So don't tie them together at compile time.  The task calls a
dispatching operation, and that dispatching operation is implemented in a
derived type by calling a guarded entry of a protected object.

The callee doesn't call an entry directly.  He calls a primitive operation
that is implemented by calling an entry (of a protected object).  I showed
this in my last post.


> In that case, you're screwed. If you
> could derive a task type from another task type, I'd be fine; that is,
> if I could have multiple different task bodies for the same task type,
> I'd not have had even conceptual problems.

The behavior that varies is encapsulated by calling private primitive
operations that dispatch:

package P is

   type T is abstract tagged limited private;

   procedure Op (O : in out T) is abstract;

private

   task type T_Task_Type (O : access T'Class);  --type is class-wide

   type T is abstract tagged limited record
      T_Task : T_Task_Type (T'Access);
   end record;

   procedure Wait (O : access T);  --primitive
end P;

package body P is

   procedure Wait (O : access T) is
   begin
      null;
      pragma Assert (False); --must override
   end;

   type T_Task_Type is
   begin
      loop
         Wait (O);  -- dispatches according to tag of discriminant
         ...
      end loop;
   end T_Task_Type;

end P;

Now you can implement a derived type by extending T with a protected object,
and then overidding Wait so that it calls an entry of the protected object.


> In other words, I reimplemented Ada's entry queues.

I don't think this is necessary.  Find a way to turn tasks into callers of
protected entries, so you can get rid of the select-accept statements.