Geschwindigkeitsunterschiede Apple Sillicon / Intel Win32 / Win64

[areyoudoneyet]

Danke für die schöne Erklärung!
6 zu 1 mehr Arbeit in der 32 Bit Version, hätte ich nicht gedacht.

[jaenicke]

Das hängt aber auch sehr vom konkreten System ab. Bei mir (i5-8600k) braucht Win32 ca. 1400 Millisekunden und Win64 ca. 1600 bzw. im Release 1300 vs. 400. Da ist der Unterschied geringer. Generell ist die Optimierung beim 64-Bit Compiler oft besser.

[areyoudoneyet]

Zitat von jaenicke:

Das hängt aber auch sehr vom konkreten System ab. Bei mir (i5-8600k) braucht Win32 ca. 1400 Millisekunden und Win64 ca. 1600 bzw. im Release 1300 vs. 400. Da ist der Unterschied geringer. Generell ist die Optimierung beim 64-Bit Compiler oft besser.

Verstehe

Code:

var
  counter: integer;
  startTime, endTime: TDateTime;
  timeTaken: Double;
begin
  counter := 1;
  startTime := Now; // Startzeit aufzeichnen

  asm
    mov ecx, counter
  @loop_start:
    inc ecx
    cmp ecx, 100000000
    jle @loop_start
    mov counter, ecx
  end;
  endTime := Now; 
  timeTaken := MilliSecondSpan(startTime, endTime); 
  ShowMessage(FloatToStr(timeTaken) + ' ms');
end;

jetzt nur noch ca. 50 ms für win32

Code:

procedure TForm1.Button1Click(Sender: TObject);
var
   counter:integer;
  startTime, endTime: TDateTime;
  timeTaken: Double;
begin
   counter := 0;
  startTime := Now; // Startzeit aufzeichnen
  while counter <= 100000000 do
    inc(counter);
  endTime := Now; // Endzeit aufzeichnen
  timeTaken := MilliSecondSpan(startTime, endTime); // Berechnung der benötigten Zeit in Millisekunden
  ShowMessage(FloatToStr(timeTaken) + ' ms'); // Zeigt die benötigte Zeit in Millisekunden an

end;

Ich habe jetzt mal den inc versucht. ist egal ob auf mac oder win immer bei ca. 30-60 ms.

d.h. für mich falls ich etwas Inkrementieren muss sollte ich "inc" verwenden anstelle "x := x+1;"

ich find das echt Interresant Dachte für mich immer... das ist doch das gleiche...

[jaenicke]

Deine neuen Quelltexte machen aber auch etwas anderes. Anfangs hattest du eine Schleife mit der Änderung der Schleifenvariable und zusätzlich das Inkrementieren eines Wertes. Jetzt hast du nur noch die Schleife. Dass das schneller ist, ist klar.

[areyoudoneyet]

Zitat von jaenicke:

Deine neuen Quelltexte machen aber auch etwas anderes. Anfangs hattest du eine Schleife mit der Änderung der Schleifenvariable und zusätzlich das Inkrementieren eines Wertes. Jetzt hast du nur noch die Schleife. Dass das schneller ist, ist klar.

hm stimmt.

[MEissing]

int64 ist auf Win32 ist "teuer"

Das ursprüngliche

Code:

var
  i: int64;

auf

Code:

var
  i: integer;

bringt für Win32 schon etliches (6044 -> 736ms)

[Stevie]

Zitat von jaenicke:

Generell ist die Optimierung beim 64-Bit Compiler oft besser.

Dem muss ich widersprechen - eher im Gegenteil. Es ist in diesem konkreten Fall so, dass unter 64bit nativ gerechnet werden kann und unter 32bit ein Int64 auf 2 Register aufgeteilt ist.

Zur Eingangsfrage und den um mehr als Faktor 10 unterscheidenden Ergebnissen kann ich nur sagen: da ist ziemlich sicher irgendwo ein Messfehler oder eine nicht vergleichbare Compilerkonfiguration.

[jaenicke]

Zitat von Stevie:

Zur Eingangsfrage und den um mehr als Faktor 10 unterscheidenden Ergebnissen kann ich nur sagen: da ist ziemlich sicher irgendwo ein Messfehler oder eine nicht vergleichbare Compilerkonfiguration.

Das hat ja Matthias schon beantwortet.

[Stevie]

Zitat von jaenicke:

Zitat von Stevie:

Zur Eingangsfrage und den um mehr als Faktor 10 unterscheidenden Ergebnissen kann ich nur sagen: da ist ziemlich sicher irgendwo ein Messfehler oder eine nicht vergleichbare Compilerkonfiguration.

Das hat ja Matthias schon beantwortet.

Hat er? Ich kann diese Messergebnisse mit Int64 unter Win32 nicht reproduzieren, daher liegt es entweder an den Compilersettings des TE oder seiner Hardware.
Der Overhead von Int64 unter 32bit ist messbar aber keineswegs auch nur annäherend in Bereich x10

Zitat von areyoudoneyet:

Gut C ist halt einfach schnell, dachte allerdings aus Erzählungen das Delphi nicht arg weit dahinter ist.

Das hier hatte auch noch niemand kommentiert - gcc optimiert hier schon zur Compiletime und erkennt, dass es eine Schleife mit konstanter Anzahl an Durchläufen ist und generiert einfach schon den Wert für sum, so dass zur Laufzeit überhaupt keine Schleife passiert.
Der Messwert bei swift sieht auch aus, als ob da etwas ähnliches passiert.

[jaenicke]

Zitat von Stevie:

Der Overhead von Int64 unter 32bit ist messbar aber keineswegs auch nur annäherend in Bereich x10

Bei mir liegt der Unterschied bei etwa Faktor 7. Int64 braucht wie geschrieben ca. 1400 Millisekunden, Integer ca. 200. Und dann ist die 64-Bit Variante bei mir auch langsamer.