Re: Ada Shootout program for K-Nucleotide (patches)

[Georg Bauhaus <rm.tsoh.plus-bug.bauhaus@maps.futureapps.de>]

Jeffrey R. Carter wrote:

> How about
> 
> subtype Index is Stream_Element_Offset range
>    Stream_Element_Offset(Item'First) .. Stream_Element_Offset(Item'Last
> + 1);
> subtype XString is String (Item'First .. Item'Last + 1);
> 
> followed by
> 
> Stream_IO.Write (stdout, To_Bytes (Item & ASCII.LF) );

Shorter, and consistently faster when strings are short (10:11).
I'll add this.

I don't know, though, whether or not exchanging one  "&" for
one less Stream_IO.Write is also good when strings are larger,
because of the copying in "&", CPU cache sizes, ...
The test results I get from the program below vary a lot
for anything but the short string (1..70) variant.

Since the test has been run in a VM on top of Vista, I don't
trust the timings that much anyway.  Maybe the order
of tests has an effect, too?  Does somebody have a stable
Linux (or Unix) test environment?  Could you try this?


package Print_Pak is

   procedure Print_Old (Item : String);

   procedure Print (Item : String);

end Print_Pak;


with Ada.Real_Time;  use Ada.Real_Time;
with Print_Pak;

procedure Test_Print is

   type String_Kind is (Short_Strings,
                        Medium_Strings,
                        Long_Strings);
   type String_Access is access String;
   type Run is record
      Data : String_Access;
      Rounds : Positive;
   end record;

   Test_Size : constant := 50_000_000;
   Max_Run : constant array (String_Kind) of Run :=
     (Short_Strings =>
        (Data => new String(1 .. 70 * 1),
         Rounds => Test_Size / 1),
      Medium_Strings =>
        (Data => new String(1 .. 70 * 100),
         Rounds => Test_Size / 100),
      Long_Strings =>
        (Data => new String(1 .. 70 * 10_000),
         Rounds => Test_Size / 10_000));

   Start, Stop: array (String_Kind) of Time;

   procedure Terminal (Message : String) is separate;

begin

   Old: for Kind in Short_Strings .. Long_Strings loop

      Start(Kind) := Clock;
      for K in 1 .. Max_Run(Kind).Rounds loop
         Print_Pak.Print_Old (Max_Run(Kind).Data.all);
      end loop;
      Stop(Kind) := Clock;

      Terminal ("Print_Old, "
                  & String_Kind'Image(Kind)
                  & ": "
                  & Duration'Image (To_Duration (Stop(Kind)
                                                   - Start(Kind))));
   end loop Old;

   for Kind in Short_Strings .. Long_Strings loop

      Start(Kind) := Clock;
      for K in 1 .. Max_Run(Kind).Rounds loop
         Print_Pak.Print (Max_Run(Kind).Data.all);
      end loop;
      Stop(Kind) := Clock;

      Terminal ("Print, "
                  & String_Kind'Image(Kind)
                  & ": "
                  & Duration'Image (To_Duration (Stop(Kind)
                                                   - Start(Kind))));
   end loop;


end Test_Print;


with Ada.Text_IO;

separate (Test_Print)
procedure Terminal (Message : String) is
begin
   Ada.Text_IO.Put_Line(Ada.Text_IO.Current_Error, Message);
end Terminal;


with Ada.Streams.Stream_IO;  use Ada.Streams;
with Unchecked_Conversion;

package body Print_Pak is

    function To_Byte is new Unchecked_Conversion
     (Source => Character,
      Target => Stream_Element);

   stdout : Stream_IO.File_Type;

   procedure Print_Old (Item : String) is
      subtype Index is Stream_Element_Offset range
        Stream_Element_Offset(Item'First) ..
Stream_Element_Offset(Item'Last);
      subtype XString is String (Item'Range);
      subtype XBytes is Stream_Element_Array (Index);
      function To_Bytes is new Unchecked_Conversion
        (Source => XString,
         Target => XBytes);
      LF : constant Stream_Element_Array := (1 => To_Byte (ASCII.LF));
   begin
      Stream_IO.Write (stdout, To_Bytes (Item));
      Stream_IO.Write (stdout, LF);
   end Print_Old;

   procedure Print (Item : String) is
      subtype Index is Stream_Element_Offset range
        Stream_Element_Offset(Item'First)
        .. Stream_Element_Offset(Item'Last + 1);
      subtype XString is String (Item'First .. Item'Last + 1);
      subtype XBytes is Stream_Element_Array (Index);
      function To_Bytes is new Unchecked_Conversion
        (Source => XString,
         Target => XBytes);
   begin
      Stream_IO.Write (stdout, To_Bytes (Item & ASCII.LF));
   end Print;

begin
   Stream_IO.Open (stdout,
                   Mode => Stream_IO.Out_File,
                   Name => "/dev/stdout");
end Print_Pak;