GNAT 2011, (с поддержкой многих фич стандарта А2012) Опции

[IUnknown]

Итак, 14 июня вышла наконец долгожданная версия GNAT GPL 2011.

Много улучшений, новая версия самой IDE (теперь это версия 5.0.1, вместо 4.3.1 из 2009-ой версии, и 4.4.1 из 2010), мне нравится больше, чем прежняя, одна возможность фильтрации результатов компиляции чего стОит (хотя это вроде было и в 2010, но мне сравнивать не с чем, я сразу перешел 2009 -> 2011, поэтому все нововведения будут относительно предпоследней версии).

Что говорит официальная страничка (комментарии - мои):

1. Улучшенная поддержка А2012 (да, это - главная причина, по которой я обновился. Теперь есть возможность использовать все те фичи, которые на настоящий момент утверждены для нового стандарта, а не просто наблюдать сообщение, что это будет доступно в 2012 году, как было в прежней версии GNAT. Это и "in out" параметры для функций, и условные выражения, и Case-выражения, работают Quantified expressions, дискриминанты для лимитированных тэговых типов, Pre/Post-условия, и многое другое из того, что уже внесено в окончательную редакцию стандарта)
2. Улучшенные версии (GPS 5.0 - расширенная поддержка С/С++, более мощный редактор, повышенное юзабилити, GtkAda - новые виджеты, интерфейс к граф. библиотеке Cairo). (От себя добавлю, что в редакторе наконец-то сделали выпадающий список Pragma, и список атрибутов типа:
   
   )
3. Более гибкий и эффективный менеджер проектов
4. Поддержка выгрузки плагинов
5. Улучшенная поддержка конструкций на .NET-платформе
6. Более детальные сообщения об исключениях (при использовании ключа -gnateE)
7. полная поддержка платформы Lego Mindstorms NXT, включая аудио и I2C-сенсоры (об этом есть ролик на youtube, англ.: вот он )

Как видно, много народу хочет попробовать новую среду/новый компилятор - я скачивал пакет размером 140Мб почти 12 часов, скорость иногда падала до 2-3Кб/сек. Но сейчас с этим вроде справились.

Сообщение отредактировано: IUnknown - 17.06.2011 18:40

[IUnknown]

Ну, вот такой пример отрабатывает в любом режиме, не только при полной оптимизации, надо будет только подумать, как запихать инициализацию пакета и получение из него Ret_Const в отдельную функцию:

Код (Показать/Скрыть)

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Real_Time; use Ada.Real_Time;
with IntPack;
with FuncPack;

procedure Test is

   package P1 is new IntPack(7);
   Fs01 : access function return Integer := P1.Ret_Const;
   package P2 is new IntPack(8);
   Fs02 : access function return Integer := P2.Ret_Const;
   package P3 is new IntPack(5);
   Fs03 : access function return Integer := P3.Ret_Const;
   package P4 is new IntPack(6);
   Fs04 : access function return Integer := P4.Ret_Const;
   package P5 is new IntPack(48);
   Fs05 : access function return Integer := P5.Ret_Const;
   package P6 is new IntPack(2);
   Fs06 : access function return Integer := P6.Ret_Const;
   package P7 is new IntPack(3);
   Fs07 : access function return Integer := P7.Ret_Const;
   package P8 is new IntPack(6);
   Fs08 : access function return Integer := P8.Ret_Const;
   package P9 is new IntPack(9);
   Fs09 : access function return Integer := P9.Ret_Const;

   package P10 is new FuncPack("*", Fs03, Fs04);
   Fs10 : access function return Integer := P10.Second_Order;
   package P11 is new FuncPack("*", Fs05, Fs06);
   Fs11 : access function return Integer := P11.Second_Order;
   package P12 is new FuncPack("+", Fs08, Fs09);
   Fs12 : access function return Integer := P12.Second_Order;
   package P13 is new FuncPack("*", Fs07, Fs12);
   Fs13 : access function return Integer := P13.Second_Order;
   package P14 is new FuncPack("+", Fs01, Fs02);
   Fs14 : access function return Integer := P14.Second_Order;
   package P15 is new FuncPack("-", Fs14, Fs10);
   Fs15 : access function return Integer := P15.Second_Order;
   package P16 is new FuncPack("+", Fs15, Fs11);
   Fs16 : access function return Integer := P16.Second_Order;
   package P17 is new FuncPack("-", Fs16, Fs13);
   Fs17 : access function return Integer := P17.Second_Order;


   type TNodeKind is (nkConst, nkAdd, nkSub, nkMul);

   type TNode is record
      Kind  : TNodeKind;
      Value : integer;
      L, R  : access TNode;
   end record;

   Nodes : array (1 .. 17) of aliased TNode;

   function Add (l,r : integer) return integer is begin return l+r; end;
   function Sub (l,r : integer) return integer is begin return l-r; end;
   function Mul (l,r : integer) return integer is begin return l*r; end;


   function Get_Value (T: TNode) return Integer is
   begin
      case T.Kind is
        when nkConst => return T.Value;
        when nkAdd   => return Add (Get_Value (T.L.all), Get_Value (T.R.all));
        when nkSub   => return Sub (Get_Value (T.L.all), Get_Value (T.R.all));
        when nkMul   => return Mul (Get_Value (T.L.all), Get_Value (T.R.all));
      end case;
   end;


   type TCommand is record
      proc: access function (l,r : integer) return integer;
      arg1, arg2, res: access integer;
   end record;
   Commands : array (1 .. 8) of TCommand;
   Data : array (1 .. 17) of aliased integer :=
     (7, 8, 5, 6, 48, 2, 3, 6, 9, others => <>);

   T: Time;
   Times: constant integer := 10_000_000;

begin
   -- вычисляем непосредственно
   -- 0.00 сек
   T := Clock;
   for j in 1 .. Times loop
      Data(17) := Sub ( Add (Sub (Add (7, 8), Mul (5,6)), Mul (48,2)), Mul (3, Add (6, 9)));
   end loop;
   Put_Line ("Plain => " & Duration'Image (To_Duration (Clock - T)));


   T := Clock;
   for j in 1 .. Times loop
      Data(17) := Fs17.all;
   end loop;
   Put_Line ("Fs => " & Duration'Image (To_Duration (Clock - T)));


   -- составляем АСТ-дерево
   -- 2.50 сек
   Nodes( 1) := (nkConst,  7, null, null);
   Nodes( 2) := (nkConst,  8, null, null);
   Nodes( 3) := (nkConst,  5, null, null);
   Nodes( 4) := (nkConst,  6, null, null);
   Nodes( 5) := (nkConst, 48, null, null);
   Nodes( 6) := (nkConst,  2, null, null);
   Nodes( 7) := (nkConst,  3, null, null);
   Nodes( 8) := (nkConst,  6, null, null);
   Nodes( 9) := (nkConst,  9, null, null);
   Nodes(10) := (nkMul,  0, Nodes( 3)'access, Nodes( 4)'access);
   Nodes(11) := (nkMul,  0, Nodes( 5)'access, Nodes( 6)'access);
   Nodes(12) := (nkAdd,  0, Nodes( 8)'access, Nodes( 9)'access);
   Nodes(13) := (nkMul,  0, Nodes( 7)'access, Nodes(12)'access);
   Nodes(14) := (nkAdd,  0, Nodes( 1)'access, Nodes( 2)'access);
   Nodes(15) := (nkSub,  0, Nodes(14)'access, Nodes(10)'access);
   Nodes(16) := (nkAdd,  0, Nodes(15)'access, Nodes(11)'access);
   Nodes(17) := (nkSub,  0, Nodes(16)'access, Nodes(13)'access);

   T := Clock;
   for j in 1 .. Times loop
      Data(17) := Get_Value(Nodes(17));
   end loop;
   Put_Line ("Nodes => " & Duration'Image (To_Duration (Clock - T)));

   -- составляем байт-код
   -- 1.30 сек
   Commands(1) := (Mul'access, Data( 3)'access, Data( 4)'access, Data(10)'access);
   Commands(2) := (Mul'access, Data( 5)'access, Data( 6)'access, Data(11)'access);
   Commands(3) := (Add'access, Data( 8)'access, Data( 9)'access, Data(12)'access);
   Commands(4) := (Mul'access, Data( 7)'access, Data(12)'access, Data(13)'access);
   Commands(5) := (Add'access, Data( 1)'access, Data( 2)'access, Data(14)'access);
   Commands(6) := (Sub'access, Data(14)'access, Data(10)'access, Data(15)'access);
   Commands(7) := (Add'access, Data(15)'access, Data(11)'access, Data(16)'access);
   Commands(8) := (Sub'access, Data(16)'access, Data(13)'access, Data(17)'access);

   T := Clock;
   for j in 1 .. Times loop
      for i in Commands'Range loop
         Commands(i).res.all := Commands(i).proc(Commands(i).arg1.all, Commands(i).arg2.all);
      end loop;
   end loop;
   Put_Line ("Commands => " & Duration'Image (To_Duration (Clock - T)));
end Test;

Доп. пакеты прикрепил в архиве:
 Closures.zip ( 965 байт ) Кол-во скачиваний: 644


У меня на машине в Debug-сборке способ "с лямбдой" рвёт все остальные, кроме прямого подсчета:

Plain =>  0.384574123
Fs =>  0.853194138
Nodes =>  2.288829872
Commands =>  2.034435707
[2011-07-27 01:43:00] process terminated successfully (elapsed time: 05.85s)

При сборке Optimize картина становится вот такой:

Plain =>  0.000000443
Fs =>  0.818582249
Nodes =>  1.320058477
Commands =>  0.520827938
[2011-07-27 01:45:24] process terminated successfully (elapsed time: 02.97s)

, но все равно скорость лямбд выше чем у ACT-дерева больше чем в полтора раза...

Теперь еще один вопрос: ты говорил, что у тебя сборка Optimize работала. А ты проверял, оно правильно считало (я про лямбды, разумеется)? Там точно получалось 36? Вообще, очень странно, если уж работать - то должно было как раз в дебаге, оптимизированная сборка наоборот не должна была отработать...