[Es ist so oder so ein Assemblerbefehl, ob man das halbe 64-Bit Register ausliest oder das ganze. Bei 64-Bit Werten ist es allerdings ein Assemblerbefehl mehr als mit Integer was z.B. bei einer Addition herauskommt.
Integer unter 64-Bit: der erste Wert wird aus dem Stack in ein Register geladen und der zweite mit add direkt aus dem Stack hinzuaddiert
Int64 uner 64-Bit: beide Werte werden aus dem Stack in Register geladen und dann addiert
Insgesamt generiert der 64-Bit Compiler eher mehr Assemblerbefehle als der 32-Bit Compiler. Was aber wirklich die Performance reduziert, ist, dass die aktuellen Planungen dazu führen, dass eher reines Object Pascal benutzt wird. Das heißt wo es für 32-Bit assembleroptimierte Routinen gab, ist das für 64-Bit in der Regel nicht mehr so, insbesondere bei Stringroutinen. Das kostet allerdings selbst bei Benchmark oft nur wenige Prozentpunkte, so viel langsamer ist das meistens nicht.
Schneller ist man bei 64-Bit, wenn es um viele Fließkommaoperationen geht. Solche Berechnungen sind durch die Multimedia-Befehle der CPU deutlich schneller.
Vielen Dank, Jaenicke, das war mal wieder sehr informativ ... wie man das halt von dir gewohnt ist
Dass 64-Bit oft langsamer ist, ist aber nicht nur bei Delphi so, das sieht man auch bei Java oder C++ z.B., aber der Irrglaube, dass man unbedingt 64-Bit braucht und da alles besser ist, hält sich leider (auch bei manchen hier im Forum) hartnäckig. In der Realität ist es für den Großteil der Projekte aber eher ein Nachteil.
Genau deshalb wollte ich das wissen. Ich fürchte nämlich, dieser Irrglaube wurde von den Reklamefritzen bewußt in die Welt gesetzt, um den Absatz von 64-Bit-Hard- und Software anzukurbeln. Dabei gibt es bei den herkömmlichen PCs ganz andere "Nadelöhre", an die man sich aber um der heiligen Kompatibilität willen nicht herantraut ...
Vielleicht erinnerst du dich noch: Ich hatte mal vor einiger Zeit einen Test gemacht mit Delphi XE2, und zwar ging es da um das Ausführen von Locate-Befehlen und setzen von IndexFieldNames beim Start einer Anwendung. Da waren die 64-Bit-Kompilationen größtenteils schneller als die 32-bittigen (Angaben im ms):
Testreihe mit Sortierung und Lokalisierung beim Start
*** Debug 32
IDE **********
DatMod.Verbinden_Tabellen 50
Set_Einstellungen 27790
*** Release 32
IDE **********
DatMod.Verbinden_Tabellen 48
Set_Einstellungen 27967
*** Debug 64
IDE **********
DatMod.Verbinden_Tabellen 47
Set_Einstellungen 24026
*** Release 64
IDE **********
DatMod.Verbinden_Tabellen 47
Set_Einstellungen 24489
*** Debug 32 EXE **********
DatMod.Verbinden_Tabellen 46
Set_Einstellungen 23111
*** Release 32 EXE **********
DatMod.Verbinden_Tabellen 49
Set_Einstellungen 22823
*** Debug 64 EXE **********
DatMod.Verbinden_Tabellen 46
Set_Einstellungen 19745
*** Release 64 EXE **********
DatMod.Verbinden_Tabellen 45
Set_Einstellungen 20034
Getestet wurde die Zeit, die zum Verbinden mehrerer Tabellen benötigt wird (MyQuery.Open), wenn IndexFieldNames einen Wert hat und im select ein Order-Befehl steht. Wieso das bei den 64-Bit-Versionen schneller war, weiß ich nicht. Fließkommaberechnungen finden dabei ja wohl kaum statt. Oder etwa doch?