Delphi Performance Vergleich zu C#

[Bernhard Geyer]

Zitat von 4dk2:

hmmm, okaay, dann ist delphi gleichauf:

Oft sind es die kleinen Dinge.
Auch eine const-Angabe hilft teilweise.
Oder in diesem Fall ein var-Übergabe damit gar (fast) keine zusätzlichen Variablen/Stack/.... benötigt werden.

Hate "damals" zu D6 Zeiten unsere Anwendung Unicode-Enabled.
Eine ergänzung von const an allen String-Übergabeparametern hatte hier schon auch ind der kompletten Anwendung merklich Geschwindigkeit gebracht.

Für Sowas empfiehlt sich immer eine Performance-Analyse mit AQTime um die relevanten stellen gleich zu finden.

[4dk2]

Zitat von Bernhard Geyer:

Zitat von 4dk2:

hmmm, okaay, dann ist delphi gleichauf:

...
Oder in diesem Fall ein var-Übergabe damit gar (fast) keine zusätzlichen Variablen/Stack/.... benötigt werden.

Delphi-Quellcode:

procedure fooVar(var x:integer);//inline;
begin
  x:=x*3;
end;

procedure fooOut(x:integer;out xout:integer);//inline;
begin
  xout:=x*3;
end;

falls du das so meintest, mit und ohne inline, sind die langsam, langsamer als die normale ohne inline (2,1 sek)

[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.