Re: Ravenscar-compliant bounded buffer

[brodax <matteo.bordin@gmail.com>]

As I wrote in a previous post, I would suggest always thinking in
terms of building blocks: sporadic entities, cyclic entities and
(entry-less) protected entities. By following this approach you have
several main advantages: for example the system is *practically*
amenable to static timing analysis.

Just to make an example of a sporadic building block:

generic
   with procedure Sporadic_Operation;
   Task_Priority : Priority;
   --minimum interarrival time
   MAT : Positive;
   Max_Pending : Positive;
package Sporadic_Entity is

   -- Invoking this procedure release the sporadic task
   procedure Release;

private

   protected type Protocol is
      entry Wait(Release_Time : out Time);
      procedure Release;
   private
      Barrier : Boolean := False;
      Pending : Integer := 0;
   end Protocol;

   task type Thread(P : Priority; Interval : Positive) is
     pragma Priority(P);
   end Thread;

   T : Thread(Task_Priority, MAT);

end Sporadic_Entity;


package body Sporadic_Entity is

   P : Protocol;

   -------------
   -- Release --
   -------------

   procedure Release is
   begin
      P.Release;
   end Release;

   --------------
   -- Protocol --
   --------------

   protected body Protocol is

      procedure Update_Barrier is
      begin
         Barrier := (Pending > 0);
      end Update_Barrier;

      ----------
      -- Wait --
      ----------

      entry Wait(Release_Time : out Time) when Barrier is
      begin
         Release_Time := Clock;
         Pending := Pending - 1;
         Update_Barrier;
      end Wait;

      -------------
      -- Release --
      -------------

      procedure Release is
      begin
         if Pending < Max_Pending then
            Pending := Pending + 1;
            Update_Barrier;
         end if;
      end Release;

   end Protocol;

   ------------
   -- Thread --
   ------------

   task body Thread is
      Next_Time : Time := System_Release_Time;
      --  System_Release_Time is a system-wide constant specifying the
release time of all
      --+ tasks in the system
   begin
      delay until Next_Time;
      loop
         P.Wait(Next_Time);
         Sporadic_Operation;
         Next_Time := Next_Time + Milliseconds(MAT);
         delay until Next_Time;
      end loop;
   end Thread;

end Sporadic_Entity;

Basically the sporadic building block let you instantiate a Ravenscar
compliant sporadic task enforcing a minimum interarrival time. Please
note that with this pattern you are sure by construction that at most
1 task is queued on an entry. The pattern can be easily extended to
include parameters for the sporadic operation (just put a queue where
parameters are stored inside Protocol). The Reader/Writer are
naturally sporadic, as they are release by an event (the buffer is non-
empty/non-full). The Buffer is an entry-less protected object. Then
you can put the logic for the release of the Reader/Writer inside the
buffer: for example, every time the Writer writes a value, it may
release the Reader (by invoking Reader.Release); and the Writer is
released either by writing on a non-full (after writing) buffer or by
the Reader when it reads on the last position of the buffer (the state
of the buffer changes from full to non-full).