Delphi vs. C# vs C++

[luisk]

Zitat von Phoenix:

Nein, er sagt genau gar nichts aus. Nur das das verwendete UI-Framework (bekanntermassen) nicht das schnellste ist.

Das UI spielt doch bei dem Vergleich keine Rolle, da eh nur bei
if (li mod 1000=0) then begin
ausgegeben wird !


Die Frage ist: wie schnell läuft das Teil auf C++ ?
kann das mal jemand testen ?

[Union]

Zitat von luisk:

Das UI spielt doch bei dem Vergleich keine Rolle, da eh nur bei
if (li mod 1000=0) then begin

Hast Du eine Messung ausgeführt um Deine Vermutung zu verifizieren?

[luisk]

Zitat von Union:

Hast Du eine Messung ausgeführt um Deine Vermutung zu verifizieren?

Genau !
Kannst Du evtl. mal den Code bei C++ messen, um zu vergleichen ?
Hab leider kein C++ zur Hand.

[Stevie]

Debug oder Release Config?

Einfacher oder mehrfacher Durchlauf (Stichwort JiT)?

[Union]

Wenn der gcc schlau optimiert, macht er sowieso das draus:

Code:

int main() {
  return 0;
}

[mkinzler]

Zitat:

Ergebnis: Das Programm läuft im einstelligen Millisekundenbereich (1-2ms), wobei anzumerken ist, dass in dem Bereich Messungen im Verhältnis ungenau sind; Programm läuft aber in wenigen Millisekunden.
Ich habe auch mit den Werten rumgespielt, statt 50000 auch 50 oder 1000000, das Ergebnis blieb dabei aber nahezu konstant (+/-1ms, nehme an das sind Messungenauigkeiten).

Wirklich nur 2 ms?

Der selbe Code als Konsolenanwendung in Delphi benötigt rund 17 Sekunden.

[TRomano]

Ich finde diese Art von Messungen sinnfrei und wenn man schon C++,C# und Delphi vergleicht sollte man sich mit dem Debugger auch mal den erzeugten Assembler-Code ansehen. Vielleicht optimiert ein guter/aggressiver Compiler die einfachen (sinnlosen) Schleifen auch einfach weg und macht nix wie eben "return 0". Da kann doch nichts vergleichen !
Wenn man die CPU-Arithmetik und die Qualität des erzeugten Codes testen will muss man schon etwas Anspruchvolleres proggen. Dann könnte man auch testen, ob der Compiler die Befehlssätze (Stichwort SSE-SSE4.2) der CPU sinnvoll nutzt.

[JasonDX]

Zitat von mkinzler:

Zitat:

Ergebnis: Das Programm läuft im einstelligen Millisekundenbereich (1-2ms), wobei anzumerken ist, dass in dem Bereich Messungen im Verhältnis ungenau sind; Programm läuft aber in wenigen Millisekunden.
Ich habe auch mit den Werten rumgespielt, statt 50000 auch 50 oder 1000000, das Ergebnis blieb dabei aber nahezu konstant (+/-1ms, nehme an das sind Messungenauigkeiten).

Wirklich nur 2 ms?

Der selbe Code als Konsolenanwendung in Delphi benötigt rund 17 Sekunden.

Das hängt eben stark vom Compiler ab. Debug vs. Release, und wie viel er optimiert. Union hats richtig erkannt - der Compiler überspringt einfach die leere(n) Schleifen. Das war auch der Sinn hinter dem Beispiel: "Einfach so" Performance messen und vergleichen bringt kein sinnvolles Ergebnis. Haben zwar schon viele angedeutet, wurden aber überhört - der TE wollte eine Messung für C++ sehen, vielleicht öffnet das die Augen.

[mkinzler]

Diese Vermutung hatte ich. Wenn man aus 50000 5000 oder sogar 50 macht und sich an der Zeit nichts ändert, spricht es auch dafür.

C# (2015) benötigt sogar etwas weniger als Delphi (16,6 Sekunden)

VC++ (2015): 0 ms. Nach Abschalten der Optimierung sind es dann 103s

c#:

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int li = 0;
            int lj = 0;
            int st = System.Environment.TickCount;

            for (li = 0; li < 50000; li++)
            {
                for (lj = 0; lj < 1000000; lj++)
                {
                }
  
            }
            int et = System.Environment.TickCount - st;
            Console.WriteLine(et);
            Console.ReadLine();
        }
    }
}

Delphi:

Delphi-Quellcode:

program Test;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils, Windows;

  var li,lj:integer;
      st: Cardinal;
begin
  try
        li := 0;
        lj := 0;
        st := GetTickCount;
            for li:=0 to 50000 do
            begin
               for lj:=0 to 1000000 do
               begin

               end;
               {if (li mod 1000=0) then
               begin
                   WriteLn( li);
               end; }
            end;
        Writeln( IntToStr(GetTickCount - st));
        Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

c++:

Code:

#include "stdafx.h"
#include <iostream>
#include <windows.h>
using namespace std;
#pragma optimize( "", off )

int main() {
   int i, j, k;
   DWORD st = GetTickCount();

   for (i = 0; i < 50000; i++)
      for (j = 0; j < 1000000; j++)
      {
         
      }

   DWORD et = GetTickCount();

   cout << (et - st);
   cin >> i;
   return 0;
}

[Phoenix]

Natürlich macht die Ausgabe am UI extrem viel aus.

Eine Ausgabe am UI ist grob so langsam wie einige tausende Schleifendurchläufe in denen nichts sonst gemacht wird.
Das heisst wenn Du alle 1000 Durchläufe stoppst, um irgendwas zu machen was grob geschätzt um die 8 - 12 mal so viel Zeit braucht wie die 1000 durchzuzählen, misst Du ausschliesslich die Darstellung am UI.

Beschäftige Dich erstmal mit den theoretischen Grundlagen von korrekten Performance-Tests bevor Du versuchst einen komplett unsinnigen Test mit anderen Sprachen / Plattformen durchführen zu lassen.

Und das ist auch der Grund, warum Dir hier niemand dieses unsinnige Beispiel mit C++ testen mag. Die Leute hier haben keine Lust sich mit sowas offensichtlich sinnlosem zu beschäftigen.