Delphi Performance Vergleich zu C#

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

[4dk2]

Neee hab die schon explizit alle auf x86 gestellt. Um das "irgendwie" gleich zu halten.
Aber 64bit bringt bei mir zum vergleich, keinen Gewinn/Verlangsamung. (bei Core und Standard)
Das wäre aber auch merkwürdig wenn doch.
Kp was der im CLR macht, aber X ist ja ne 32bit var, dürfte also ja auch keine verbesserung in der 64bit cpu bringen.