Re: problem of read and write

[Craig Carey <research@ijs.co.nz>]

On Wed, 11 Dec 2002 09:37:12 +0000 (UTC), Lutz Donnerhacke <lutz@iks-jena.de> wrote:

>* Francisco Santoyo wrote:
>> I have two tasks, one write[s] in some objects and the other read[s] from
>> them. 
>>
>> How can I avoid th[is:] the reader task read[s] the first object before...
>> the writer task [has] finish[ed]... writ[ing the first, some, or] the last?.
>
>Depending on your problem you can collect all those objects into a protected
>type or use a semaphore (also a protected type) to synchonize a long term
>access.

A sample program of reading and writing appears below.

This was my entry for the Computer Language Shootout contest of the
www.bagley.org website. The entry was rejected by a brief note I got in the
last week with the reasoning xplaining that the contest had closed last year.

The code here would be a solution to the Producer Consumer example of the
constest; and that example has a webpage here:

   http://www.bagley.org/~doug/shootout/bench/prodcons/


-------------------------------------------------------------------------------
with Text_IO, Ada.Command_Line;  --  Ref. http://www.bagley.org/~doug/shootout/
procedure Prodcons is            --  11-Dec-2002, coded in Ada 95
   type Buffer_Array is array (Positive range <>) of Integer;
   type Buffer_Array_Ptr is access Buffer_Array;
   Buffer               : Buffer_Array_Ptr;           --  Initialised to null
   Buffer_Closed_Error  : exception;
   protected Controller is
      entry Sample (Boolean) (Data : in out Integer);
      procedure Finish_Up;       --  (Calls don't queue on protected procedure)
   private                                --  (Guards can be not updated when
      Count       : Integer := 0;         --   only global variables change)
      Closed      : Boolean := False;
   end Controller;
   protected body Controller is        --  A family entry instead of 2 entries
      entry Sample (for Put_Not_Get in Boolean) (Data : in out Integer)
         when (Put_Not_Get and Count = 0) or          --  Block with 0% CPU use
              ((not Put_Not_Get) and (Count /= 0 or Closed)) is
      begin
         if Put_Not_Get then                             --  Add to the buffer
            Count := Count + 1;
            Buffer (Count) := Data;
         elsif Closed and Count = 0 then
            raise Buffer_Closed_Error;                   --  Raise an exception
         else                                            --  Take from buffer
            Data := Buffer (Count);
            Count := Count - 1;
         end if;
      end Sample;
      procedure Finish_Up is begin Closed := True; end Finish_Up;
   end Controller;
   Consumed, Produced   : Natural := 0;
   N, T1, T2, Chk       : Integer := 0;
begin
   if Ada.Command_Line.Argument_Count >= 1 then
      begin
         N := Natural'Max (0, Integer'Value (Ada.Command_Line.Argument (1)));
      exception      -- RM3.5(44) allows N to be negative if X'Max is omitted
         when Constraint_Error => N := 1;
      end;
   end if;
   Buffer := new Buffer_Array (1 .. N);   --  N can be 0 (and -1 would be OK)
   declare
      task Producer; task Consumer;          --  The tasks start when declared
      task body Producer is
      begin
         for I in 1 .. N loop
            T1 := I;                                        --  (I is constant)
            Controller.Sample (True) (Data => T1);
            Produced := Produced + 1;  Chk := Chk + I ** 3;
         end loop;                   --  Chk is OK despite overflow, no -gnato
         Controller.Finish_Up;
      end Producer;
      task body Consumer is
      begin
         loop
            begin
               Controller.Sample (False) (Data => T2);
               Consumed := Consumed + 1;  Chk := Chk - T2 ** 3;
            exception
               when Buffer_Closed_Error => exit;            --  Exit the loop
            end;
         end loop;            --  No "exit when K=N;" at bottom, to save a line
      end Consumer;           --  and the requirements seemed to allow that
   begin
      null;                   --  Wait here until the tasks have finished
   end;
   if Chk /= 0 then Text_IO.Put_Line ("Program_Error"); end if;   --  No probs
   Text_IO.Put_Line ("N =" & Integer'Image (N) & ": Produced =" & Natural'
            Image (Produced) & ", Consumed =" & Natural'Image (Consumed));
end Prodcons;
-------------------------------------------------------------------------------

That program seems to take about 12.7 secs per 1000 MHz of CPU power to get the
variable 'Produced' incremented up to 1,000,000, in Windows 2000 GNAT (with the
-O2 option), which seems very fast (at 12.7 microseconds), but it was not
ranking in the top 3.

THe Gcc entry has a loop around a mutex wait. Does someone know if that it is
actually a correct way to code when the operating system time slice interval is
bigger than 10 seconds. The Gcc entry did not contain any code to reduce the
operating system time slice interval thus I am unclear on whether it had a bug.



Craig Carey <research@ijs.co.nz>
Ada 95 mailing lists; http://www.ijs.co.nz/ada_95.htm