9.11 Example of Tasking and Synchronization

1. The following example defines a buffer protected object to smooth variations between the speed of output of a producing task and the speed of input of some consuming task. For instance, the producing task might have the following structure:

2. task Producer;
   

3. task body Producer is
      Char : Character;
   begin
      loop
         ... --  produce the next character Char
         Buffer.Write(Char);
         exit when Char = ASCII.EOT;
      end loop;
   end Producer;
   

4. and the consuming task might have the following structure:

5. task Consumer;
   

6. task body Consumer is
      Char : Character;
   begin
      loop
         Buffer.Read(Char);
         exit when Char = ASCII.EOT;
         ... --  consume the character Char
      end loop;
   end Consumer;
   

7. The buffer object contains an internal pool of characters managed in a round-robin fashion. The pool has two indices, an In_Index denoting the space for the next input character and an Out_Index denoting the space for the next output character.

8. protected Buffer is
      entry Read (C : out Character);
      entry Write(C : in  Character);
   private
      Pool      : String(1 .. 100);
      Count     : Natural := 0;
      In_Index, Out_Index : Positive := 1;
   end Buffer;
   

9. protected body Buffer is
      entry Write(C : in Character)
         when Count < Pool'Length is
      begin
         Pool(In_Index) := C;
         In_Index := (In_Index mod Pool'Length) + 1;
         Count    := Count + 1;
      end Write;
   

10.    entry Read(C : out Character)
          when Count > 0 is
       begin
          C := Pool(Out_Index);
          Out_Index := (Out_Index mod Pool'Length) + 1;
          Count     := Count - 1;
       end Read;
    end Buffer;
    

Go to the first, previous, next, last section, table of contents.