Re: Termination of periodic tasks

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Tue, 17 Jun 2014 07:47:49 +0000 (UTC), Natasha Kerensikova wrote:

> Hello,
> 
> On 2014-06-17, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>> On Tue, 17 Jun 2014 06:57:38 +0000 (UTC), Natasha Kerensikova wrote:
>>
>> [...]
>>> Is there a way to work around such a situation?
>>
>> The solution is always same: wrap a task pointer in a controlled object.
>> Manage the task from the object's Initialize and Finalize.
>>
> But if I change Global_Worker from an access-to-task to a controlled
> object, its master will still be the environment task, so Finalize
> wouldn't be called before termination of the worker task.
> 
> Or am I missing something?

You should put it in a separate package to ensure different scopes of the
controlled object and the access-to-task type.

> Is there a special construct that yield an
> earlier call to Finalize than Cron_Entry? Would you happen to have a
> working example?

with Ada.Finalization;

package Workers is
   type Manager is new Ada.Finalization.Limited_Controlled with private;

private
   task type Worker is
      entry Live;
      entry Die;
   end Worker;
   type Worker_Ptr is access Worker;
   
   type Manager is new Ada.Finalization.Limited_Controlled with record
      Staff : Worker_Ptr;
   end record;
   overriding procedure Initialize (Handler : in out Manager);
   overriding procedure Finalize (Handler : in out Manager);

end Workers;
--------------------------------------------------------------
with Ada.Unchecked_Deallocation;

with Ada.Text_IO;  use Ada.Text_IO;

package body Workers is
   
   task body Worker is
   begin
      accept Live;
      Put_Line ("I am born!");
      loop
         select
            accept Die;
            exit;
         else delay 1.0;
            Put_Line ("I am alive!");
         end select;
      end loop;
      Put_Line ("You killed me!");
   end Worker;

   procedure Initialize (Handler : in out Manager) is
   begin
      Handler.Staff := new Worker;
      Handler.Staff.Live;
   end Initialize;
   
   procedure Finalize (Handler : in out Manager) is
      procedure Free is
         new Ada.Unchecked_Deallocation (Worker, Worker_Ptr);
   begin
      if Handler.Staff /= null then
         Handler.Staff.Die;
         while not Handler.Staff'Terminated loop
            delay 0.01;
         end loop;
         Free (Handler.Staff);
      end if;
   end Finalize;

end Workers;
-------------------------------------------------------
with Ada.Text_IO;  use Ada.Text_IO;
with Workers;      use Workers;

procedure Test is
   X : Manager;
begin
   delay 5.0;
   Put_Line ("Good bye!");
end Test;
-----------------------------------------------------

X is finalized before Workers (and Worker_Ptr), so it does not wait for all
instances to terminate.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de