FPC-Kompiler sehr schnell

[Mathias]

So wie es aussieht, ist man mit FPC richtig verwöhnt, was die Geschwindigkeit des Kompilers anbelangt.

Gestern hatte ich die Devel von OpenELEC (Kodi) kompiliert, mein PC war ca. 3h beschäftigt um dieses Paket zu kompilieren.
Man bedenkt, das kompilierte Paket hat nur 200MB.

Wen man bedenkt, das Lazarus/FPC-Paket (DEB oder EXE) hat auch etwas über 100MB, aber diese Pakete sind zig mal schneller erstellt (Trunc-Version).
In 5-10min hat man die üblichen 3 DEV-Pakete.

Ich verwende eine I7 mit 4 Kernen und SSD-Platte.

[Warf]

Der FPC ist schon ein Recht schneller Compiler, aber es gibt auch da Luft nach oben (so ist z.B. der D7 kompiler noch schneller), aber man darf auch nicht einfach 2 ungefähr gleichgroße Projekte gegeneinander Vergleichen. Dafür sollte man verschiedene Programme und Sprachkonstrukte verwenden und diese dann vergleichen. Interessant wäre ein Vergleich von ähnlichen Programmen in verschiedenen Sprachen schon. z.B. ein FPC programm, ein Delphi programm mit D7 und eine neuer Version, ein GCC C Programm und GCC C++. Auf so einen Vergleich wäre ich echt mal gespannt. Vielleicht, wenn ich mal Zeit finde mache ich mal 1-2 Vergleiche.

[Mathias]

Auf so einen Vergleich wäre ich echt mal gespannt. Vielleicht, wenn ich mal Zeit finde mache ich mal 1-2 Vergleiche.

Man könnte automatisch so Code erzeugen.
Anschliessend die beiden Code compilieren.

Code: Alles auswählen

program Project1;
begin
  WriteLn(1);
  WriteLn(2);
  // ...........
  WriteLn(1000000);
end.            

Code: Alles auswählen

#include <iostream>       
int main(){                                  
    std::cout <<  1 << std::endl; 
    std::cout <<  2 << std::endl; 
// .........
    std::cout <<  1000000 << std::endl; 
    return 0; }

[Mathias]

Wollte es gerade probieren, aber so wie es aussieht, ist FPC überfordert.

Code: Alles auswählen

Target OS: Linux for x86-64
Compiling pascaltest.pas
pascaltest.pas(7282,3) Fatal: Procedure too complex, it requires too many registers
Fatal: Compilation aborted
Error: /usr/bin/ppcx64 returned an error exitcode

Beim 2 Versuch kommt der Fehler noch tiefer aus dem Kompiler:

Code: Alles auswählen

Error: /usr/bin/ppcx64 can't be executed, error message: Failed to execute "/usr/bin/ppcx64", error code: -9

g++ macht das Spiel mit 10'000 Zeilen mit.
Mit 1'000'000 Zeilen hat auch g++ Mühe. Bis zu Abbruch, hat es sogar den Mauszeiger beeinflusst.

Code: Alles auswählen

g++: internal compiler error: Getötet (program cc1plus)
Please submit a full bug report,
with preprocessed source if appropriate.
See <file:///usr/share/doc/gcc-4.8/README.Bugs> for instructions.

Jetzt habe ich ohne Änderung c++ nochmal ausgeführt, jetzt hat er es kompiliert und so wie es aussieht, läuft die Execute sogar.
Komisch, das es das 2. mal geht.

Ich habe es noch mit WinXP probiert, anscheinend geht Pascal der Speicher aus.

Code: Alles auswählen

V:\DATEN\Programmierung\Lazarus\pascal c Benchmark>c:\lazarus\fpc\3.0.0\bin\i386
-win32\fpc pascaltest.pas
Free Pascal Compiler version 3.0.0 [2015/12/07] for i386
Copyright (c) 1993-2015 by Florian Klaempfl and others
Target OS: Win32 for i386
Compiling pascaltest.pas
Fatal: No memory left
Error: c:\lazarus\fpc\3.0.0\bin\i386-win32\ppc386.exe returned an error exitcode

[mse]

Interessant wäre ein Vergleich von ähnlichen Programmen in verschiedenen Sprachen schon. z.B. ein FPC programm, ein Delphi programm mit D7 und eine neuer Version, ein GCC C Programm und GCC C++. Auf so einen Vergleich wäre ich echt mal gespannt. Vielleicht, wenn ich mal Zeit finde mache ich mal 1-2 Vergleiche.

Ich habe MSEide+MSEgui lange Zeit zu Delphi kompatibel gehalten, um ein gutes Benchmark-Programm für FPC zur Verfügung zu stellen. Ich musste lernen, dass dies sehr unerwünscht ist und habe darum die Delphi-Kompatibilität aufgegeben. Der letzte Vergleich zeigt, dass D7/Kylix3 mehr als 10 mal schneller ist:
http://lists.freepascal.org/fpc-devel/2 ... 31605.html
http://lists.freepascal.org/fpc-devel/2 ... 31529.html
Im Verlaufe der Jahre wurde FPC immer langsamer.
Mit MSElang versuche ich wieder in das Gebiet von D7 vorzudringen. Für das selbst geschriebene Frontend und den selbstgeschrieben LLVM Bitcodegenerator könnte das Ziel erreicht werden. Wenn ich den C++ Code des LLVM Backends ansehe, habe ich meine Zweifel, ob damit eine gute Kompiliergeschwindigkeit möglich ist.

[Horst_h]

Hallo,

ich habe mal ein Miniprogramm erstellt

Code: Alles auswählen

 
program test;
var
  f : text;
  i,MAXCNT : LongInt;
Begin
  IF ParamCount <> 1 then
    EXIT;
  val(ParamStr(1),MAXCNT);
  Assign(f,'Out.pp');
  ReWrite(f);
  writeln(f,'program Project1;');
  writeln(f,'procedure w(i : NativeInt);begin WriteLn(i);end;');
 
  writeln(f,'begin');
  For i := 1 to MAXCNT do
    WriteLn(f,'w(',i,');');
  writeln(f,'end.');
  close(f);
end.

Beispielhaft mit 10
./test 10
Out.pp:

Code: Alles auswählen

 
program Project1;
procedure w(i : NativeInt);begin WriteLn(i);end;
begin
w(1);
w(2);
w(3);
w(4);
w(5);
w(6);
w(7);
w(8);
w(9);
w(10);
end.}
 

Ab 65521 Zeilen des Programmes steigt der Compiler aus.

Code: Alles auswählen

 
 ./test 65517
  time fpc  Out.pp
Free Pascal Compiler version 3.0.1 [2015/11/02] for x86_64
Copyright (c) 1993-2015 by Florian Klaempfl and others
Target OS: Linux for x86-64
Compiling Out.pp
Linking Out
/usr/bin/ld: warning: link.res contains output sections; did you forget -T?
65521 lines compiled, 1.4 sec
 
real  0m1.389s
user  0m1.279s
sys 0m0.108s
 
 ./test 65518
 time fpc  Out.pp
Free Pascal Compiler version 3.0.1 [2015/11/02] for x86_64
Copyright (c) 1993-2015 by Florian Klaempfl and others
Target OS: Linux for x86-64
Compiling Out.pp
Out.pp(65521,1) Fatal: Procedure too complex, it requires too many registers
Fatal: Compilation aborted
Error: /usr/bin/ppcx64 returned an error exitcode
 
real  0m0.462s
user  0m0.372s
sys 0m0.089s

DIe obige Version von

Auf so einen Vergleich wäre ich echt mal gespannt. Vielleicht, wenn ich mal Zeit finde mache ich mal 1-2 Vergleiche.

Man könnte automatisch so Code erzeugen.
Anschliessend die beiden Code compilieren.

Code: Alles auswählen

program Project1;
begin
  WriteLn(1);
  WriteLn(2);
  // ...........
  WriteLn(1000000);
end.            

ist bei mir schon bei 32767 am Ende.
VIelleicht kann man das irdendwo einstellen.


Gruß Horst

[Horst_h]

Hallo,

ich habe es mal geändert, um eine Millionen Zeilen hin zu bekommen.
Ich erzeuge X Prozeduren mit je X Zeilen.
Da der Aufruf von writeln scheinbar recht aufwändig ist, habe ich ihn in der Prozedur Ausgabe ausgelagert.
Ohne dem wäre 841 die Grenze bei mir mit 8GB RAM ( da werden mal kurz 200 Mb ausgelagert) und Kompilierzeit von 56 Sekunden.

Code: Alles auswählen

var
  f : text;
  i ,MAXCNT,ofs : LongInt;
  s: string;
 
procedure ProcCreate(name: string;ofs,cnt: NativeInt);
var
  i : NativeInt;
Begin
  writeln(f,'procedure ',name,';');
  writeln(f,'begin');
  For i := 1 to cnt do
    WriteLn(f,'Ausgabe(',ofs+i,');');
  writeln(f,'end;');
end;
 
Begin
  IF ParamCount <> 1 then
    EXIT;
  val(ParamStr(1),MAXCNT);
  Assign(f,'Out.pp');
  ReWrite(f);
 
  ofs := 0;
  writeln(f,'program Project1;');
  writeln(f,'procedure Ausgabe(i:NativeInt);begin writeln(i) end;');
 
  For i := 1 to MAXCNT do
  Begin
    str(i,s);
    s := 'f'+s;
    ProcCreate(s,ofs,MAXCNT);
    inc(ofs,MAXCNT);
  end;
 
  writeln;
  writeln(f,'begin');
  For i := 1 to MAXCNT do
  Begin
    str(i,s);
    s := 'f'+s;
    WriteLn(f,s,';');
  end;
  writeln(f,'end.');
  close(f);
end.
 

Das ergibt mit Parameter 4:
test 4 -> Out.pp

Code: Alles auswählen

 
program Project1;
procedure Ausgabe(i:NativeInt);begin writeln(i) end;
procedure f1;
begin
Ausgabe(1);
Ausgabe(2);
Ausgabe(3);
Ausgabe(4);
end;
procedure f2;
begin
Ausgabe(5);
Ausgabe(6);
Ausgabe(7);
Ausgabe(8);
end;
procedure f3;
begin
Ausgabe(9);
Ausgabe(10);
Ausgabe(11);
Ausgabe(12);
end;
procedure f4;
begin
Ausgabe(13);
Ausgabe(14);
Ausgabe(15);
Ausgabe(16);
end;
begin
f1;
f2;
f3;
f4;
end.

Jetzt test mit 1000 Prozeduren mit je 1000 Zeilen und anschliessendem Kompilieren von Out.pp

Code: Alles auswählen

./test 1000
 
time fpc Out.pp  // Belegt in der Spitze etwa 2.1 Gbyte
Free Pascal Compiler version 3.0.1 [2015/11/02] for x86_64
Copyright (c) 1993-2015 by Florian Klaempfl and others
Target OS: Linux for x86-64
Compiling Out.pp
Linking Out
/usr/bin/ld: warning: link.res contains output sections; did you forget -T?
1004004 lines compiled, 10.7 sec
 
real  0m10.767s
user  0m9.608s
sys 0m1.148s 

Mit 1800^2 = 3240000 Zeilen sind es 6,9 GB Speicherbelegung in der Spitze

Code: Alles auswählen

./test 1800
root# time fpc Out.pp
...
3247204 lines compiled, 36.5 sec
 

Gruß Horst

[Warf]

Einfach nur WriteLN gibt auch keine große Aussage, man muss auch Syntaktisch komplexere Konstrukte verwenden, wie Records, konstanten, Enums, Variablen, Arrays, das Schlüsselwort Packed, Zeiger, etc.

Z.B:

Code: Alles auswählen

program FPCTest;
 
{$MODE ObjFPC}{$H+}
 
type
  TMyInt = Integer;
  TMyDouble = Double;
 
  PTestRecord1 = ^TTestRecord1;
  TTestRecord1 = record
    IntFeld: TMyInt;
   StrFeld: ShortString;
   ByteFeld: Byte;
   Dbl1: TMyDouble;
   Float1: Single;
  end;
 
  PTestRecord2 = ^TTestRecord2;
  TTestRecord2 = record
   Dbl1: TMyDouble;
   Float1: Single;
   case Boolean of
   False:(IntFeld: TMyInt);
   True:(Byte1, Byte2: Byte; WordFeld: Word);
  end;
 
  PTestRecord3 = ^TTestRecord3;
  TTestRecord3 = packed record
    Bytes: array[0..6] of Byte;
   IntFeld: TMyInt;
   Dbl1: TMyDouble;
   Float1: Single;
  end;
 
 
  function Reduce(n: Integer): Integer;
  begin
    Result:=0;
   while n>1 do
   begin
     n:=n div 2;
     inc(Result);
   end;
  end;
 
  function Sum(n: Integer): Integer;
  begin
    Result:=1;
    While n>0 do
    begin
      Result := Result + n;
      dec(n);
    end;
  end;
 
  function Nextn(n: Integer): Integer;
  begin
   if n <= 1 then
     Result := 4
   else if n mod 2 = 0 then
     Result := NextN(n div 2)+NextN(n-1)
   else
     Result := NextN(Reduce(n)) + Sum(n);
  end;
 
const
  i1= 1;
  i2= 4;
  i3= 9;
  i4= 16;
  i5= 25;
  i6= 36;
  i7= 49;
  d1= 0.1;
  d2= 0.4;
  d3= 0.9;
  d4= 0.16;
  d5= 0.25;
  d6= 0.36;
  d7= 0.49;
var
  i, n, x: TMyInt;
  arr1: array[0..99] of TTestRecord1;
  arr2: array[0..99] of TTestRecord2;
  arr3: array[0..99] of TTestRecord3;
  arrp1: array[0..99] of PTestRecord1;
  arrp2: array[0..99] of PTestRecord2;
  arrp3: array[0..99] of PTestRecord3;
begin
  n:=60;
  for i := 0 to 99 do
  begin
    arr1[i].ByteFeld:=n mod 255;
    arr1[i].Dbl1:=n / i*´d1;
    arr1[i].Float1:=n / i*d2;
    arr1[i].IntFeld:=n+i1;
    for x:=1 to 256 do
      arr1[i].StrFeld[x]:=chr((x mod 26)+ord('A'));
    n:=Nextn(n);
  end;
  for i := 0 to 99 do
  begin
    arr2[i].Float1:=n / i;
    arr2[i].Dbl1:=n / i*321;
    if i mod 2 = 0 then
      arr2[i].IntFeld:=n+i2
    else
    begin
      arr2[i].Byte1:=n mod 255+i3;
      arr2[i].Byte2:=(n * 3) mod 255+i4;
      arr2[i].WordFeld:=n div 255+5;
    end;
    n:=Nextn(n);
  end;
  for i := 0 to 99 do
  begin
   arr3[i].IntFeld:=n;
   arr3[i].Dbl1:=n / i*631+d4;
   arr3[i].Float1:=n / i+d5;
   for x:=0 to 6 do
     arr3[i].Bytes[x]:= x*x mod 255;
    n:=Nextn(n);
  end;
  for i:=0 to 99 do
    arrp1[i]:=@arr1[99-i];
  for i:=0 to 99 do
    arrp2[i]:=@arr2[99-i];
  for i:=0 to 99 do
    arrp3[i]:=@arr3[99-i];
end.

so etwas vielleicht noch mit doppelt-3 mal so vielen Zeilen.

PS:
C kann beim Kompilieren auch sehr langsam sein wegen den Präprozessor statements, die sind ja sogar eine eigene Turing mächtige Programmiersprache, so was gibt es in Pascal nicht wirklich, und die benötigt natürlich viel extra zeit

[Mathias]

Ich habe den Code von Horst_h ein wenig angepasst, und das gleiche für C++ gemacht.

Code: Alles auswählen

const
  l = 1000;
 
procedure TForm1.Button1Click(Sender: TObject);
var
  f: Text;
  i, j: integer;
begin
  AssignFile(f, 'pascaltest.pas');
  Rewrite(f);
  WriteLn(f, 'program test;' + #13#10);
 
  for i := 0 to l do begin
    WriteLn(f, 'procedure p', i, ';');
    WriteLn(f, 'begin');
    for j := 0 to l do begin
      WriteLn(f, '  WriteLn(', l * i + j, ');');
    end;
    WriteLn(f, 'end;' + #13#10);
  end;
 
  WriteLn(f, 'begin');
  for i := 0 to l do begin
    WriteLn(f, '  p', i, ';');
  end;
  WriteLn(f, 'end.');
 
  CloseFile(f);
end;
 
procedure TForm1.Button2Click(Sender: TObject);
var
  f: Text;
  i, j: integer;
begin
  AssignFile(f, 'ctest.c');
  Rewrite(f);
  WriteLn(f, '#include <iostream>   ');
 
  for i := 0 to l do begin
    WriteLn(f, 'void p', i, '()');
    WriteLn(f, '{');
    for j := 0 to l do begin
      WriteLn(f, '  std::cout << ', l * i + j, ' << std::endl;');
    end;
    WriteLn(f, '};' + #13#10);
  end;
 
  WriteLn(f, 'int main()');
  WriteLn(f, '{');
  for i := 0 to l do begin
    WriteLn(f, '  p', i, '();');
  end;
  WriteLn(f, '}');
 
  CloseFile(f);
end; 

FPC hat dafür 75s gebraucht.
C++ Hat viel länger gebraucht.
Ich hatte folgende Ausgabe:

Code: Alles auswählen

$ g++ -time ctest.c 
# cc1plus 188.24 1.02
# as 6.43 0.29
# collect2 0.56 0.07

Könnte 188s heissen.

C kann beim Kompilieren auch sehr langsam sein wegen den Präprozessor statements,

Das ist keine Entschuldigung, Fakt ist, cpp hat länger.

Ein Plus hat cpp trozdem, die Execute von Pascal ist fast doppelt so gross wie die von cpp.

[Horst_h]

Hallo,

Ich habe es mit 32-Bit Linux getestet.Dort musste ich, wegen freepascals Speicherbedarf auf l= 707 -> (l+1)^2 = 501264 Ausgabezeilen begrenzen.
Spasseshalber hab ich das Programm dann die Ausgabe ins Nirvana machen lassen.
Speicherbedarf maximal 1022 MB bei g++
Dateigröße 18.1 MB

Code: Alles auswählen

# time g++ ctest.c
 
real   1m10.182s
user   1m9.593s
sys   0m0.443s
 
# time ./a.out >/dev/nul
 
real   0m0.349s
user   0m0.127s
sys   0m0.220s
 
 

Speicherbedarf maximal 2042 MB bei freepascal 3.1.1 // da tut sich nichts gegenüpber 2.6.4
Dateigröße 20.7 MB

Code: Alles auswählen

 
# time fpc pascaltest.pas
Free Pascal Compiler version 3.1.1 [2015/08/19] for i386
Copyright (c) 1993-2015 by Florian Klaempfl and others
Target OS: Linux for i386
Compiling pascaltest.pas
Linking pascaltest
/usr/bin/ld: warning: link.res contains output sections; did you forget -T?
504808 lines compiled, 36.3 sec
 
real   0m36.402s
user   0m33.823s
sys   0m2.103s
 
# time ./pascaltest >/dev/nul
 
real   0m0.046s
user   0m0.037s
sys   0m0.007s
 

Also so groß unterschiedlich sind die Dateigrößen nicht.Auffällig, das g++ die Daten scheinbar mehr vom System verarbeiten lässt ~2/3 der Ausgabezeit.

Gruß Horst

[Christian]

aber es gibt auch da Luft nach oben (so ist z.B. der D7 kompiler noch schneller)

D7 erzeugt aber nur für win32 Code.
Multi Plattform Compiler sind immer langsamer. Wenn dann musst den Delphi Compiler vergleichen der auch OSX und 64bit kann.

[mse]

aber es gibt auch da Luft nach oben (so ist z.B. der D7 kompiler noch schneller)

D7 erzeugt aber nur für win32 Code.
Multi Plattform Compiler sind immer langsamer. Wenn dann musst den Delphi Compiler vergleichen der auch OSX und 64bit kann.

Das ist die übliche Ausrede, welche ich stark bezweifle. Die neuen Delphi Compiler werden vermutlich von Leuten gemacht, die das Handwerk nicht mehr so beherrschen wie zu D7/Kylix3-Zeiten.
Es ist ja auch nicht notwendig, da die modernen Computer auch mit nicht optimaler Software schnell genug sind. Und für etwas was nicht unbedingt notwendig ist, wird auch kein Geld ausgegeben, sondern viel gewinnversprechender in Marketingmassnahmen gesteckt.
Von FPC liest man öfters das Argument, dass die Computer schneller scheller werden als FPC langsamer...
Zudem erscheint mir ein Geschwindigkeitsunterschied von Faktor 10 mit dem Multi-Plattform Argument nicht erklärbar.

[creed steiger]

aber es gibt auch da Luft nach oben (so ist z.B. der D7 kompiler noch schneller)

D7 erzeugt aber nur für win32 Code.
Multi Plattform Compiler sind immer langsamer. Wenn dann musst den Delphi Compiler vergleichen der auch OSX und 64bit kann.

Das ist die übliche Ausrede, welche ich stark bezweifle. Die neuen Delphi Compiler werden vermutlich von Leuten gemacht, die das Handwerk nicht mehr so beherrschen wie zu D7/Kylix3-Zeiten.

naja FPC ist ins Pascal geschrieben .... da fallen schon einige händische (ASM) Optimierungen weg.
Das die Wartbarkeit für den Multiplattformansatz auch Nachteile mitbringt ist klar.

[Horst_h]

Hallo,

meist ist die Laufzeit des Kompilats wichtiger für den Benutzer
Beide Kompiler haben nur eine CPU ausgelastet, vielleicht wäre das bei verschiedenen units anders.Man könnte mal Htop/ Taskmanager anschmeissen und Lazaruzs kompilieren, um das zu sehen.Da werden mehrere Dinge parallel kompiliert.

Apropos Kompilatgröße. Bei Linux-x64 ist tatsächlich die g++ erzeugte Datei nur halb so groß, wie die von Freepascal erstellte.

Gruß Horst

[mse]

meist ist die Laufzeit des Kompilats wichtiger für den Benutzer

Naja, zum Zeitpunkt meiner Tests waren sowohl exe-Grösse wie auch die Laufzeit des Kompilats mit D7 deutlich kleiner als mit FPC. FPC 3.0 hat die Situation vielleicht verbessert. Aber wie gesagt, ich habe die Delphi-Kompatibilität fallen gelassen, da Benchmarks nicht erwünscht scheinen.