Das ist nut bei einem 32-Bit Programm logisch, bei einem 64-Bit Programm sollte es gleich sein (vermutlich funktioniert es dann auch ohne den "QWORD(1)" -Zusatz, weil eine "1" dann defaultmäßig ein int64 ist).CPU-Quaeler hat geschrieben:Das ganze ist nun mit 32x AA bei einer Benchmark-Funktion ca. 12% langsamer, aber das ist auch logisch.
Das Programm arbeitet auch dann ca. 12% langsamer, wenn es mit 64 Bits kompiliert wurde. Das könnte aber möglicherweise an der Speicheranbindung liegen? Theoretisch müssten sich in der selben Zeit ja doppelt so viele 32bit-Variablen wie 64bit-Variablen übertragen lassen?mschnell hat geschrieben:Das ist nut bei einem 32-Bit Programm logisch, bei einem 64-Bit Programm sollte es gleich sein (vermutlich funktioniert es dann auch ohne den "QWORD(1)" -Zusatz, weil eine "1" dann defaultmäßig ein int64 ist).CPU-Quaeler hat geschrieben:Das ganze ist nun mit 32x AA bei einer Benchmark-Funktion ca. 12% langsamer, aber das ist auch logisch.
Zeig 'mal den Assembler-code von beiden Varianten !CPU-Quaeler hat geschrieben:Das Programm arbeitet auch dann ca. 12% langsamer, wenn es mit 64 Bits kompiliert wurde. Das könnte aber möglicherweise an der Speicheranbindung liegen? Theoretisch müssten sich in der selben Zeit ja doppelt so viele 32bit-Variablen wie 64bit-Variablen übertragen lassen?
mschnell hat geschrieben: Zeig 'mal den Assembler-code von beiden Varianten !
Code: Alles auswählen
# GetBit:
.globl UGRAPHCOM_TGRAPHCOM_$__GETBIT$LONGWORD$BYTE$$BOOLEAN
.type UGRAPHCOM_TGRAPHCOM_$__GETBIT$LONGWORD$BYTE$$BOOLEAN,@function
UGRAPHCOM_TGRAPHCOM_$__GETBIT$LONGWORD$BYTE$$BOOLEAN:
# Temps allocated between rsp+0 and rsp+0
# Var Value located in register esi
# Var Bit located in register cl
# Var $self located in register rdi
# Var $result located in register al
# [96] begin
movb %dl,%cl
# [97] Result := (Value and (1 shl Bit)) <> 0;
movzbl %cl,%ecx
movl $1,%eax
shll %cl,%eax
andl %esi,%eax
andl $4294967295,%eax
testq %rax,%rax
setneb %al
# [98] end;
ret
.Le2:
.size UGRAPHCOM_TGRAPHCOM_$__GETBIT$LONGWORD$BYTE$$BOOLEAN, .Le2 - UGRAPHCOM_TGRAPHCOM_$__GETBIT$LONGWORD$BYTE$$BOOLEAN
.section .text
.balign 8,0x90
# SetBit:
.globl UGRAPHCOM_TGRAPHCOM_$__SETBIT$LONGWORD$BYTE$$LONGWORD
.type UGRAPHCOM_TGRAPHCOM_$__SETBIT$LONGWORD$BYTE$$LONGWORD,@function
UGRAPHCOM_TGRAPHCOM_$__SETBIT$LONGWORD$BYTE$$LONGWORD:
# Temps allocated between rsp+0 and rsp+0
# Var Value located in register esi
# Var Bit located in register cl
# Var $self located in register rdi
# Var $result located in register eax
# [103] begin
movb %dl,%cl
# [104] Result := Value or (1 shl Bit);
movzbl %cl,%ecx
movl $1,%eax
shll %cl,%eax
movslq %eax,%rax
andl $4294967295,%esi
orq %rsi,%rax
# [105] end;
ret
.Le3:
.size UGRAPHCOM_TGRAPHCOM_$__SETBIT$LONGWORD$BYTE$$LONGWORD, .Le3 - UGRAPHCOM_TGRAPHCOM_$__SETBIT$LONGWORD$BYTE$$LONGWORD
.section .text
.balign 8,0x90Code: Alles auswählen
# Zunächst der GetBit-Code:
.globl UGRAPHCOM_TGRAPHCOM_$__GETBIT$QWORD$BYTE$$BOOLEAN
.type UGRAPHCOM_TGRAPHCOM_$__GETBIT$QWORD$BYTE$$BOOLEAN,@function
UGRAPHCOM_TGRAPHCOM_$__GETBIT$QWORD$BYTE$$BOOLEAN:
# Temps allocated between rsp+0 and rsp+0
# Var Value located in register rsi
# Var Bit located in register cl
# Var $self located in register rdi
# Var $result located in register al
# [96] begin
movb %dl,%cl
# [97] Result := (Value and (qword(1) shl Bit)) <> 0;
movzbl %cl,%ecx
movq $1,%rax
shlq %cl,%rax
andq %rsi,%rax
testq %rax,%rax
setneb %al
# [98] end;
ret
.Le2:
.size UGRAPHCOM_TGRAPHCOM_$__GETBIT$QWORD$BYTE$$BOOLEAN, .Le2 - UGRAPHCOM_TGRAPHCOM_$__GETBIT$QWORD$BYTE$$BOOLEAN
.section .text
.balign 8,0x90
# Nun der SetBit-Code:
.globl UGRAPHCOM_TGRAPHCOM_$__SETBIT$QWORD$BYTE$$QWORD
.type UGRAPHCOM_TGRAPHCOM_$__SETBIT$QWORD$BYTE$$QWORD,@function
UGRAPHCOM_TGRAPHCOM_$__SETBIT$QWORD$BYTE$$QWORD:
# Temps allocated between rsp+0 and rsp+0
# Var Value located in register rsi
# Var Bit located in register cl
# Var $self located in register rdi
# Var $result located in register rax
# [103] begin
movb %dl,%cl
# [104] Result := Value or (qword(1) shl Bit);
movzbl %cl,%ecx
movq $1,%rax
shlq %cl,%rax
orq %rsi,%rax
# [105] end;
ret
.Le3:
.size UGRAPHCOM_TGRAPHCOM_$__SETBIT$QWORD$BYTE$$QWORD, .Le3 - UGRAPHCOM_TGRAPHCOM_$__SETBIT$QWORD$BYTE$$QWORD
.section .text
.balign 8,0x90Code: Alles auswählen
andl $4294967295,%eaxCode: Alles auswählen
andl %esi,%eaxStimmt. Wahrscheinlich wird im 64bit-Modus $4294967295 durch 0x00000000FFFFFFFF im Hexadezimalen repräsentiert, dann macht die Zeile Sinn.mschnell hat geschrieben: wäre bei dem Befehl nicht
andq 0x00000000FFFFFFFF,%rax
eigentlich richtig, weil doch die oberen 32 Bit von rax noch gar nicht definiert sind ?
hmmm. Gute Frage...Der Behehl
movzbl %cl,%ecx
im "richtigen" Code ist doch eigentlich auch überflüssig, ecx wird doch gar mehr verwendet ?!?!?
Durch die Compiler-Anweisung -almschnell hat geschrieben:Ich würde das gerne selbst 'mal probieren. Wie hast Du den ASM-Code erzeugt ?
Müsste irgendwie gehen (?).Ich habe im Moment keinen Rechner mit 64 Bit Linux laufen. Kann man auf einer 32 bit Maschine nach 64 Bit cross-compilieren ?
Vermutlich. habe ich aber bisher nicht 'rausbekommen. Ich vermute der 64-Bit Compiler ist ein eigenes Programm, das normalerweise für 64 Bit Maschinen übersetzt wird. Falls "offiziell" kein 32-Bit Binary für den 64-Bit Compiler zum Download existiert, müsste man es aus den Sourcen übersetzten. Die Sourcen muss man ja ohnehin haben, wenn man Lazarus installiert. also sollte ich alles da haben. Aber wie compiliert man den Compiler ? Es gibt bestimmt eine Anleitung im Netzt ...Euklid hat geschrieben:Müsste irgendwie gehen (?).
.BuildfaqAber wie compiliert man den Compiler ? Es gibt bestimmt eine Anleitung im Netzt
64 Bit VM -> 32 Bit Target = kein Problemcreed steiger hat geschrieben:Ist ne VM vielleicht die einfachere Alternative?
Da steht ein guter Tip .creed steiger hat geschrieben:http://wiki.lazarus.freepascal.org/Cross_compiling
Verein
Links
Suche