DLL mit FPC/Codetyphon erheblich kleiner als unter Delphi

[Benedikt Magnus]

Zitat von Uwe Raabe:

Mein Fazit dieser ganzen Diskussion: Wer eine DLL erzeugen will, die nichts macht, sollte Delphi 7 oder älter (aber nicht Delphi 1, das erzeugt nur 16 Bit) nehmen, dann nimmt sie auch nicht soviel Platz auf der Festplatte ein, lässt aber trotzdem keine ihrer Funktionalitäten vermissen. Ganz Verwegene können sie ja auch ganz weglassen und erzeugen eine 0 Byte große Datei, die sie einfach so nennen.

Naja, jetzt wirds aber...
Zuallerst sprach ich von Anfang an von einer kleinen, nicht von einer leeren DLL. Des Weiteren kann man nicht einfach einen Kritikpunkt mit "dann nutzt doch eine alte Version" abspeisen.
Ich werde aufgrund andere Faktoren weiterhin Delphi verwenden, keine Frage, das hier sollte auch gar keine Diskussion werden, ob FreePascal oder Delphi besser ist, sondern nur meine Frage beantworten, warum FreePascal bei gleicher Funktionalität ein sehr viel kleineres Kompilat erzeugen kann als Delphi.
Die Antwort ist dann wohl, wie ich aus deinen Kommentaren ableiten kann, dass Embarcadero sich einfach nicht herblässt, so etwas Unbedeutendes zu optimieren. Habe ich das richtig verstanden?

[P_G]

Man kann die Sache auch noch von einem anderen Standpunkt aus betrachten:
Ich habe kürzlich spaßeshalber ein Delphi XE5 Programm in Lazarus 1.6 importiert. Das Delphi-Kompilat ist nicht ganz 1 MB größer als das von Lazarus. Interessant ist es aber, wenn man sich die laufenden Exe's im Arbeitsspeicher ansieht. Hier ist das Delphi-Kompilat rund 2 MB kleiner, als das Lazarus-Kompilat. Von der Geschwindigkeit her sind beide übrigens mehr oder weniger identisch...

[EWeiss]

Zitat:

Die Antwort ist dann wohl, wie ich aus deinen Kommentaren ableiten kann, dass Embarcadero sich einfach nicht herblässt, so etwas Unbedeutendes zu optimieren.

Nehme ich auch an.

Zumindest haben sie deshalb schon mal einen Käufer weniger >= XE
Warum soll ich mir unnötigen Mist in meine Projekte mit ein kompilieren was nicht nötig ist.
Sagte ja schon bringt absolut keine Vorteile in welcher Art auch immer.

Hat schon seinen Grund warum viele noch mit D7 unterwegs sind.

gruss

[jaenicke]

Zitat von Delphi-Laie:

Beide DLLs tun hoffentlich das gleiche, nämlich das, was im Quelltext steht. Der Rest in der von Delphi erzeugten DLL ist nicht abrufbar.

So einfach ist es nicht. Der Compiler kann nicht feststellen ob zum Beispiel über die RTTI Codeteile ausgeführt werden. Dazu kommt dass zum Beispiel Objekte wie Application oder Screen initialisiert werden egal ob sie der Benutzer benutzt oder nicht.

Um das vollständig zu lösen, müsste der Compiler alles verstehen was in dem Programm passiert. Das ist aber Stand heute nicht möglich.

[ralfstocker]

Es ist ganz einfach. Der FPC Compiler macht einfach die bessere Analyse. Er lässt einfach mehr Sachen, die man nicht braucht, weg. Der Delphi Compiler hat sich seit Delphi 2 (1997) in dem Punkt nicht geändert. Ein weiterer wichtiger Punkt ist der generierte Code von FPC. Der ist einfach schlanker und direkter. Bei Delphi gibt es Tonnen von unnötigen Register saves und restores, die den Code langsam machen und die EXE/DLL aufblähen.

[EWeiss]

Zitat:

Das ist aber Stand heute nicht möglich.

Klar ist das möglich nur nicht mit Delphi..

C++
- Full optimization (/Ox)
- Favor small code (/Os)

mehr muss man nicht sagen..

gruss

[jaenicke]

C++ kennt aber auch keine Reflection, d.h. Methoden, die nicht im Code angesprochen werden, können auch nicht ausgeführt werden. In Delphi hingegen kannst du die RTTI benutzen um auch z.B. Methoden eines Records auszuführen usw., die nirgends im Code verwendet werden.

Außerdem ist der C++ Compiler eben auch deutlich langsamer als der von Delphi, natürlich wird in der zusätzlichen Zeit auch etwas gemacht.

Natürlich könnte man auch die Units in Delphi umschreiben, damit nicht mehr so viel automatisch geladen oder angesprochen wird. Aber genau dass ich vieles einfach so benutzen kann und zur Verfügung habe, finde ich an Delphi ja besser als eben z.B. an C++.

[jbg]

Zitat von jaenicke:

Natürlich könnte man auch die Units in Delphi umschreiben, damit nicht mehr so viel automatisch geladen oder angesprochen wird. Aber genau dass ich vieles einfach so benutzen kann und zur Verfügung habe, finde ich an Delphi ja besser als eben z.B. an C++.

Um beim Beispiel Application und Screen zu bleiben. Man müsste das Erstellen der Objekte einfach nur in den Klassen-Konstruktor (gibt es seit Delphi 2010) verschieben. Und schon könnte man Vcl.Forms einbinden ohne dass TApplication und TScreen im Kompilat laden, wenn man auf keine der Funktionalitäten direkt oder indirekt zugreift.
Idera/Embarcadero müsste halt mal die initialization und finalization der Units aufräumen (oder entfernen).

Es wäre auch mal von Vorteil, wenn z.B. das gesamte DFM Streaming aus TStream herausgelöst werden würde. Ein Konsolenprogramm, das Streams benutzt braucht in der Regel kein DFM Streaming.

Aber bei der RTL/VCL ist diese "jeder nutzt jeden" zum Glück nicht ganz so schlimm ausgeprägt wie es bei der FMX ist. Da hat man gefühlt schon fast 80% allen FMX Codes in der Anwendung zu haben, wenn man nur eine FMX Unit einbindet.

[jaenicke]

Zitat von ralfstocker:

Ein weiterer wichtiger Punkt ist der generierte Code von FPC. Der ist einfach schlanker und direkter. Bei Delphi gibt es Tonnen von unnötigen Register saves und restores, die den Code langsam machen und die EXE/DLL aufblähen.

Ein konkretes Beispiel wäre schön. Wenn ich so den generierten Code vergleiche, kann ich davon nichts sehen. Ein einfaches Beispiel:

Delphi-Quellcode:

var
  a: string;
  b: Integer;
begin
  b := 42;
  a := IntToStr(b);
  ShowMessage(a);
end;

Delphi:

Code:

Unit93.pas.30: begin
00000000006B6B80 55               push rbp
00000000006B6B81 4883EC30         sub rsp,$30
00000000006B6B85 488BEC           mov rbp,rsp
00000000006B6B88 48C7452800000000 mov qword ptr [rbp+$28],$0000000000000000
00000000006B6B90 48894D40         mov [rbp+$40],rcx
00000000006B6B94 48895548         mov [rbp+$48],rdx
00000000006B6B98 90               nop
Unit93.pas.31: b := 42;
00000000006B6B99 C745242A000000   mov [rbp+$24],$0000002a
Unit93.pas.32: a := IntToStr(b);
00000000006B6BA0 488D4D28         lea rcx,[rbp+$28]
00000000006B6BA4 8B5524           mov edx,[rbp+$24]
00000000006B6BA7 E88493D7FF       call IntToStr
Unit93.pas.33: ShowMessage(a);
00000000006B6BAC 488B4D28         mov rcx,[rbp+$28]
00000000006B6BB0 E89B3BF3FF       call ShowMessage
00000000006B6BB5 90               nop
Unit93.pas.34: end;
00000000006B6BB6 488D4D28         lea rcx,[rbp+$28]
00000000006B6BBA E8217BD5FF       call @UStrClr
00000000006B6BBF 488D6530         lea rsp,[rbp+$30]
00000000006B6BC3 5D               pop rbp
00000000006B6BC4 C3               ret

Lazarus / FPC:

Code:

unit1.pas:37                              begin
000000010002C390 55                       push   %rbp
000000010002C391 4889e5                   mov    %rsp,%rbp
000000010002C394 488d6424c0               lea    -0x40(%rsp),%rsp
000000010002C399 48894df0                 mov    %rcx,-0x10(%rbp)
000000010002C39D 488955f8                 mov    %rdx,-0x8(%rbp)
000000010002C3A1 48c745e800000000         movq   $0x0,-0x18(%rbp)
000000010002C3A9 90                       nop
unit1.pas:38                              b := 42;
000000010002C3AA c745e02a000000           movl   $0x2a,-0x20(%rbp)
unit1.pas:39                              a := IntToStr(b);
000000010002C3B1 8b45e0                   mov    -0x20(%rbp),%eax
000000010002C3B4 488d4de8                 lea    -0x18(%rbp),%rcx
000000010002C3B8 89c2                     mov    %eax,%edx
000000010002C3BA e8c11a0200               callq  0x10004de80 <SYSUTILS_$$_INTTOSTR$LONGINT$$ANSISTRING>
unit1.pas:40                              ShowMessage(a);
000000010002C3BF 488b4de8                 mov    -0x18(%rbp),%rcx
000000010002C3C3 e828201100               callq  0x10013e3f0 <SHOWMESSAGE>
unit1.pas:37                              begin
000000010002C3C8 90                       nop
000000010002C3C9 4889e9                   mov    %rbp,%rcx
000000010002C3CC e89fffffff               callq  0x10002c370 <fin$0>
unit1.pas:41                              end;
000000010002C3D1 90                       nop
000000010002C3D2 488d6500                 lea    0x0(%rbp),%rsp
000000010002C3D6 5d                       pop    %rbp
000000010002C3D7 c3                       retq

[Benedikt Magnus]

Dazu fällt mir dieser Artikel hier ein:
http://blog.synopse.info/post/2015/0...er-than-Delphi