Re: FIFO

[Frank Buss <fb@frank-buss.de>]

On 09/16/2017 07:22 PM, Dmitry A. Kazakov wrote:
> On 2017-09-16 19:12, Frank Buss wrote:
>
>> Oh well, I'll write my own package for it then. On the plus side it
>> wouldn't have all these interface stuff overhead and might be smaller
>> and faster, just a simple generic with the type and the size.
>
> You can borrow code from here:
>
>    http://www.dmitry-kazakov.de/ada/components.htm#Generic_FIFO

Thanks, looks similar. I tried my own version, without looking at your 
version :-) Would this work for interrupts with the volatile? Good idea 
to use the size generic argument inside the package.

And everyone feel free to criticize my code, as I'm very new to Ada. For 
example, I saw that when you want to package something neatly, but it 
consists mainly of one type, then the package is named plural of the 
type, like I did: "Ringbuffers" and "Ringbuffer" for the type. Is this 
common practice?

For testing I wrote a small program. How do Ada programmers usually test 
their libraries and programs? For Java I often use JUnit.

My version:

ringbuffers.ads:

generic
    Size : Positive;
    type Item is private;
package Ringbuffers is

    type Ringbuffer is tagged private;

    procedure Write (Self : in out Ringbuffer; e : Item);
    function Read (Self : in out Ringbuffer) return Item;
    function Is_Empty (Self : Ringbuffer) return Boolean;

private

    type Item_Array is array (1 .. Size) of Item;
    pragma Volatile (Item_Array);
    type Ringbuffer is tagged record
       Read_Index  : Positive := 1;
       Write_Index : Positive := 1;
       Items       : Item_Array;
    end record;
    pragma Volatile (Ringbuffer);

end Ringbuffers;


ringbuffers.adb:

package body Ringbuffers is

    procedure Write (Self : in out Ringbuffer; e : Item) is
    begin
       Self.Items (Self.Write_Index) := e;
       Self.Write_Index := Self.Write_Index + 1;
       if (Self.Write_Index = Size) then
          Self.Write_Index := 1;
       end if;
    end Write;

    function Read (Self : in out Ringbuffer) return Item is
       Result : Item;
    begin
       Result := Self.Items (Self.Read_Index);
       Self.Read_Index := Self.Read_Index + 1;
       if (Self.Read_Index = Size) then
          Self.Read_Index := 1;
       end if;
       return Result;
    end Read;

    function Is_Empty (Self : Ringbuffer) return Boolean is
    begin
       return Self.Write_Index = Self.Read_Index;
    end Is_Empty;

end Ringbuffers;


test_ringbuffer.adb:

with Interfaces;  use Interfaces;
with Ada.Text_IO; use Ada.Text_IO;
with Ringbuffers;

procedure Test_Ringbuffer is
    package FIFO_Package is new Ringbuffers (256, Unsigned_8);
    subtype FIFO is FIFO_Package.Ringbuffer;
    Test : FIFO;

begin
    Test.Write (1);
    Test.Write (7);
    while not Test.Is_Empty loop
       Put_Line (Unsigned_8'Image (Test.Read));
    end loop;
end Test_Ringbuffer;


-- 
Frank Buss, http://www.frank-buss.de
electronics and more: http://www.youtube.com/user/frankbuss