Delphi Performance Vergleich zu C#

[Stevie]

Halt stop!

Wenn du Foo inline markierst, wird der Code schneller, weil er nix mehr ausführt (siehe H2077 in den Compilermeldungen) außer einer leeren Schleife. Es wird nix mit x gemacht also spart er sich auch die Multiplikation. Ein beherztes Writeln(x) nach der Schleife und der code ist wieder langsam. Das liegt einfach daran, dass der Delphi Compiler schrottigen Code erzeugt und Register nicht optimal nutzt.

Aus dem geinlinetem x:=Foo(x) Aufruf wird folgendes:

Delphi-Quellcode:

Project351.dpr.38: x:=foo(x);
004EE8DD 8B155C944F00     mov edx,[$004f945c]
004EE8E3 8D1452           lea edx,[edx+edx*2]
004EE8E6 89155C944F00     mov [$004f945c],edx

Die Variable wird also nicht einfach im Register gehalten sondern unnötigerweise immer zurück geschrieben und gelesen. Den Code und die globalen Variablen in eine Routine zu verlagern hilft übrigens auch nicht. Die Multiplikation direkt durchzuführen hat übrigens denselben ungünstigen Assembly Code zum Ergebnis.

Edit: Wenn Writeln(x) direkt vor oder nach dem sw.Stop steht, dann ist der Assembly Code optimal, denn dann kann x im Register gehalten werden.

[Uwe Raabe]

Zitat von Stevie:

Ein beherztes Writeln(x) nach der Schleife und der code ist wieder langsam.

Nicht in 10.3.3 Rio. Da liegen die Werte mit und ohne Writeln(x) annähernd gleichauf.

Übrigens bekomme ich ähnliche Werte, wenn ich den Schleifenbody komplett auskommentiere

Delphi-Quellcode:

program BenchmarkCallSpeed;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Diagnostics;

function foo(x:integer):integer; inline;
begin
  result:=x*3;
end;

const
  Iterations=1000000000;
  TestTarget=100;

var
  s:string;
  tc:TStopwatch;
  i:integer;
  itotal:integer;
  x:integer;
  totalMSecs:Int64;
begin
  try
    totalMSecs:=0;

    tc:=TStopwatch.Create.Create;
    Writeln('Start');
    for itotal := 1 to TestTarget do
    begin
      x:=3;

      tc.Reset;
      tc.Start;
      for i := 0 to Iterations-1 do
      begin
        x:=foo(x);
      end;
      tc.Stop;
      totalMSecs := totalMSecs + tc.ElapsedMilliseconds;
      Writeln(x);
      Writeln('Step: '+itotal.ToString()+' = '+tc.ElapsedMilliseconds.ToString()+ ' ms');
    end;
    Writeln('TOTAL~: '+(totalMSecs/TestTarget).ToString());

    Writeln('ENDE');
    Readln(s);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

[Stevie]

Zitat von Uwe Raabe:

Zitat von Stevie:

Ein beherztes Writeln(x) nach der Schleife und der code ist wieder langsam.

Nicht in 10.3.3 Rio. Da liegen die Werte mit und ohne Writeln(x) annähernd gleichauf.

Dann schreib doch mal das Writeln(x) hinter das Writeln('Step: '+itotal.ToString()+' = '+tc.ElapsedMilliseconds.ToString()+ ' ms');

Der Punkt bleibt: der Delphi Compiler optimiert relevante Stellen nicht, nur weil er später den Wert noch benötigt und ihn bis dahin nicht im Register halten kann.
Er könnte problemlos für die Schleife mit dem Register arbeiten und danach einmal das mov machen.

Erzähl mir nochmal einer, dass nativ kompiliert so viel geiler ist als diese teuflische managed Zeugs!

[sakura]

Zitat von Stevie:

Dann schreib doch mal das Writeln(x) hinter das Writeln('Step: '+itotal.ToString()+' = '+tc.ElapsedMilliseconds.ToString()+ ' ms');

Willst Du uns verarschen Alter Falter...!

......

[4dk2]

Zitat von sakura:

Zitat von Stevie:

Dann schreib doch mal das Writeln(x) hinter das Writeln('Step: '+itotal.ToString()+' = '+tc.ElapsedMilliseconds.ToString()+ ' ms');

Willst Du uns verarschen Alter Falter...!

......

Grad getestet, es ist wirklich so

Delphi-Quellcode:

Writeln('Step: '+itotal.ToString()+' = '+tc.ElapsedTime.ToString());
Writeln(x);
==2,3 sec

Writeln(x);
Writeln('Step: '+itotal.ToString()+' = '+tc.ElapsedTime.ToString());
==1,4 sec

Ist auf Jedenfall seeeehr interessant.

[4dk2]

Also bei C# wurd das vorher denke ich auch wegoptimiert, jetzt liege ich beim functionsaufruf bei
0,7227 sec EDIT! : irgendwie nen messfehler? siehe weiter unten
zum vergleich:
direkte berechnung in der schleife

Code:

for (int i = 0; i < Iterations; i++)
{
//x = Foo(x);
x = x*3;
}

== 0,444 sec

[DelTurbo]

Hi,
ich habe eine Frage zu dem inline. Das interessiert mich. Wie macht es eigentlich Delphi 2007? Kann man folgenden Artikel auch auf Delphi 2007 beziehen, oder muss man es dort ein bissl anders machen?

http://docwiki.embarcadero.com/RADSt...frufen_(Delphi)

Gruß

[Stevie]

Zitat von 4dk2:

Also bei C# wurd das vorher denke ich auch wegoptimiert

In meinem Test nicht. netcore 3.0 mit oder ohne Ausgabe von x war von Anfang an so schnell wie die Variante in Delphi, die in der Schleife das Register nutzt.

[4dk2]

Zitat von Stevie:

Zitat von 4dk2:

Also bei C# wurd das vorher denke ich auch wegoptimiert

In meinem Test nicht. netcore 3.0 mit oder ohne Ausgabe von x war von Anfang an so schnell wie die Variante in Delphi, die in der Schleife das Register nutzt.

ok, ich hab bei mir auch nochmal core im vergleich zu Standard laufen lassen,
beide ungefähr gleichschnell und egal ob mit oder ohne Ausgabe.
0,41 sek~ in beiden Fällen

[Stevie]

Ach, noch was - solang du nichts daran geändert hast, wird dein .net Projekt mit Any CPU gebaut und läuft somit vermutlich als 64bit. Wenn ich das explizit auf x86 umstelle wirds auch langsam.

Hingegen wird es auf der Delphi Seite noch gruseliger, wenn ich auf Win64 umstelle. Da wird sogar ein explizites x:=x*3 direkt in der Schleife zu einem dämlichen

Delphi-Quellcode:

Project351.dpr.40: x := x*3;
000000000055A67B 8B0DCB770300     mov ecx,[rel $000377cb]
000000000055A681 488D0C49         lea rcx,[rcx+rcx*2]
000000000055A685 890DC1770300     mov [rel $000377c1],ecx

Von den Ergebnissen auf Linux, mit dem ach so tollen LLVM Backend, wo die Hälfte der wichtigen Optimierungen hardcoded ausgeschaltet wurden, fang ich gar nicht erst an... yay native compiled...