Assemblerfunktion zum Aufsummieren direkt in AutoIt

**AspirinJunkie**

Diese Frage geht direkt an die (vielen) Assembler-Profis hier im Forum.
Aktuell arbeite ich in den letzten Monaten an meinem bisher größten AutoIt-Projekt (werde ich im Laufe des Jahres noch veröffentlichen).
Hierfür wäre es sehr schön, wenn ich eine Funktion hätte, welche sehr fix die Summe über ein Float- oder Double-Array im Speicher berechnet.
Die Windows-API bietet so eine Funktionalität nicht und die anderen Möglichkeiten die ich habe, sind auch nur Workarounds die mir nicht so gefallen.

Da ich weiß, dass hier viele fähige Assemblerköpfe im Forum herumlungern, wollte ich mal fragen ob jemand mir eine Funktion schreiben kann, welche den Code über Assembler realisiert und aus AutoIt heraus fix aufrufbar macht (gesehen habe ich soetwas hier schon - bin aber selbst völlig minderbemittelt bei dem Thema).
Das Grundgerüst stelle ich mir hierfür folgendermaßen vor:

AutoIt

Global $tData = DllStructCreate("DOUBLE[100]")
; füllen
For $i = 1 To 100
	DllStructSetData($tData, 1, $i, 1)
Next

$fSum = _sumUpMemory(DllStructGetPtr($tData), 100)
ConsoleWrite($fSum)


Func _sumUpMemory($pPointer, $iN, $sType = "DOUBLE")
	; hier sollte irgendwie der Binary mit den x64 und x86-Binärcode stehen
	; dieser sollte dann in den Speicher zur Ausführung geschrieben werden
	; und dann per (vermutlich) DllCallAddress ausgeführt werden 

	If $sType = "DOUBLE" Then
		If @AutoItX64 Then
			; hier sollte der x64 DOUBLE-Code hin
		Else
			; hier sollte der x64 FLOAT-Code hin
		EndIf
	Else ; "FLOAT"
		If @AutoItX64 Then
			; hier sollte der x86 DOUBLE-Code hin
		Else
			; hier sollte der x86 FLOAT-Code hin
		EndIf
	EndIf

EndFunc

Alles anzeigen

Man bräuchte also ingesamt 4x Binärcode, da es ja insgesamt 4 Fälle gibt.
Genial wäre natürlich auch die Nutzung von Vektorfunktionalitäten, wenn diese in älteren CPUs aucht unterstützt werden (soll ja große Kompatibilität haben).

Wer weiß - vielleicht hat einer ja Lust mir entsprechend zu helfen.

**Andy**

Heyho!

Zitat von AspirinJunkie

Wer weiß - vielleicht hat einer ja Lust mir entsprechend zu helfen.

Aber sowas von!!!! Endlich habe ich mal Gelegenheit, mich für deine vielen genialen Posts und Scripte zu revanchieren

Ich geh mal in die Spur....

**UEZ**

Da ich mich erst stundenlang in ASM einarbeiten muss, um eine simple Addition durchzuführen, lasse ich Andy den Vorrang, zumal das Ergebnis wesentlich besser sein dürfte, aber hier die DLL Version, falls Interesse besteht:

Code

#AutoIt3Wrapper_UseX64=n

$hDLL = DllOpen(@AutoItX64 ? "Sum64.dll" : "Sum.dll")

$len = 900000

Global $tData = DllStructCreate("DOUBLE x[" & $len & "]")
$sum = 0
; füllen
For $i = 1 To $len
	$tData.x(($i)) = 1 / $i
	$sum += $tData.x(($i))
Next
ConsoleWrite("AutoIt sum: " & $sum & @CRLF)
ConsoleWrite("----------------" & @CRLF)
$aReturnF = DllCall($hDll, "float", "SumF", "struct*", $tData, "ulong", $len)
ConsoleWrite("DLL sum float: " & $aReturnF[0] & @CRLF)
$aReturnD = DllCall($hDll, "double", "SumD", "struct*", $tData, "ulong", $len)
ConsoleWrite("DLL sum double: " & $aReturnD[0] & @CRLF)

DllClose($hDLL)

Alles anzeigen

Im Anhang die zwei DLLs.

Die DLL habe ich in Freebasic geschrieben.

Btw, wie soll bei der Float summiert werden, wenn du ein Double Array übergibst? Soll Float summiert werden oder Double? Das Ergebnis ist natürlich Float.

**Andy**

Naja,

man könnte ja die dll, bzw deren Inhalte/Code mit entsprechendem Header versehen und in eine AutoIt-Funktion aka DllCallAddress() überführen.

AspirinJunkie hat ja die "Kompatibilität" auch zu "älteren" Prozessoren angesprochen, ich werde "oldschool" x86 (8088)-Code schreiben, und, da es ja auch Leute mit "neueren" Prozessoren geben sollte, deren SSE- bzw. AVX-Fähigkeiten ansprechen. Es gibt dort Prozessorfunktionen um 4/8/16 floats/double in einem rutsch zu addieren. das bekommst du ohne C bzw. C++ "intrinsics" (welche auch nur die Prozessorfunktiopn wrappern) nicht hin.

**UEZ**

Das ist der optimierte x64 ASM Output vom Compiler:

Code

	.file	"Sum.c"
	.intel_syntax noprefix
	.text
/APP
	.section .drectve
	.ascii " -export:\"SumF\""
	.ascii " -export:\"SumD\""

	.text
/NO_APP
	.p2align 4
	.globl	SumF
	.def	SumF;	.scl	2;	.type	32;	.endef
	.seh_proc	SumF
SumF:
	.seh_endprologue
	vxorps	xmm0, xmm0, xmm0
	mov	eax, 1
	dec	edx
	vcvtsd2ss	xmm0, xmm0, QWORD PTR [rcx]
	mov	r8d, edx
	and	r8d, 7
	cmp	edx, 1
	jb	.L42
	test	r8d, r8d
	je	.L2
	cmp	r8d, 1
	je	.L28
	cmp	r8d, 2
	je	.L29
	cmp	r8d, 3
	je	.L30
	cmp	r8d, 4
	je	.L31
	cmp	r8d, 5
	je	.L32
	cmp	r8d, 6
	jne	.L44
.L33:
	mov	r9d, eax
	vcvtss2sd	xmm3, xmm0, xmm0
	inc	eax
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r9*8]
	vcvtsd2ss	xmm0, xmm4, xmm4
.L32:
	mov	r10d, eax
	vcvtss2sd	xmm5, xmm0, xmm0
	inc	eax
	vaddsd	xmm0, xmm5, QWORD PTR [rcx+r10*8]
	vcvtsd2ss	xmm0, xmm0, xmm0
.L31:
	mov	r11d, eax
	vcvtss2sd	xmm1, xmm0, xmm0
	inc	eax
	vaddsd	xmm2, xmm1, QWORD PTR [rcx+r11*8]
	vcvtsd2ss	xmm0, xmm2, xmm2
.L30:
	mov	r8d, eax
	vcvtss2sd	xmm3, xmm0, xmm0
	inc	eax
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r8*8]
	vcvtsd2ss	xmm0, xmm4, xmm4
.L29:
	mov	r9d, eax
	vcvtss2sd	xmm5, xmm0, xmm0
	inc	eax
	vaddsd	xmm0, xmm5, QWORD PTR [rcx+r9*8]
	vcvtsd2ss	xmm0, xmm0, xmm0
.L28:
	mov	r10d, eax
	vcvtss2sd	xmm1, xmm0, xmm0
	inc	eax
	vaddsd	xmm2, xmm1, QWORD PTR [rcx+r10*8]
	vcvtsd2ss	xmm0, xmm2, xmm2
	cmp	edx, eax
	jb	.L42
.L2:
	mov	r11d, eax
	vcvtss2sd	xmm3, xmm0, xmm0
	lea	r8d, 1[rax]
	lea	r9d, 2[rax]
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r11*8]
	lea	r10d, 3[rax]
	lea	r11d, 4[rax]
	vcvtsd2ss	xmm5, xmm4, xmm4
	vcvtss2sd	xmm0, xmm5, xmm5
	vaddsd	xmm1, xmm0, QWORD PTR [rcx+r8*8]
	lea	r8d, 5[rax]
	vcvtsd2ss	xmm2, xmm1, xmm1
	vcvtss2sd	xmm3, xmm2, xmm2
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r9*8]
	lea	r9d, 6[rax]
	vcvtsd2ss	xmm5, xmm4, xmm4
	vcvtss2sd	xmm0, xmm5, xmm5
	vaddsd	xmm1, xmm0, QWORD PTR [rcx+r10*8]
	lea	r10d, 7[rax]
	add	eax, 8
	vcvtsd2ss	xmm2, xmm1, xmm1
	vcvtss2sd	xmm3, xmm2, xmm2
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r11*8]
	vcvtsd2ss	xmm5, xmm4, xmm4
	vcvtss2sd	xmm0, xmm5, xmm5
	vaddsd	xmm1, xmm0, QWORD PTR [rcx+r8*8]
	vcvtsd2ss	xmm2, xmm1, xmm1
	vcvtss2sd	xmm3, xmm2, xmm2
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r9*8]
	vcvtsd2ss	xmm5, xmm4, xmm4
	vcvtss2sd	xmm0, xmm5, xmm5
	vaddsd	xmm1, xmm0, QWORD PTR [rcx+r10*8]
	vcvtsd2ss	xmm0, xmm1, xmm1
	cmp	edx, eax
	jnb	.L2
.L3:
.L42:
	ret
	.p2align 4
	.p2align 3
.L44:
	vcvtss2sd	xmm1, xmm0, xmm0
	vaddsd	xmm2, xmm1, QWORD PTR 8[rcx]
	mov	eax, 2
	vcvtsd2ss	xmm0, xmm2, xmm2
	jmp	.L33
	.seh_endproc
	.p2align 4
	.globl	SumD
	.def	SumD;	.scl	2;	.type	32;	.endef
	.seh_proc	SumD
SumD:
	.seh_endprologue
	lea	r8d, -1[rdx]
	cmp	edx, 6
	jbe	.L50
	lea	r9d, -2[rdx]
	vmovups	xmm1, XMMWORD PTR [rcx]
	mov	r10d, 1
	shr	r9d
	lea	eax, 1[r9]
	and	r9d, 7
	cmp	eax, 1
	jbe	.L125
	test	r9d, r9d
	je	.L47
	cmp	r9d, 1
	je	.L105
	cmp	r9d, 2
	je	.L106
	cmp	r9d, 3
	je	.L107
	cmp	r9d, 4
	je	.L108
	cmp	r9d, 5
	je	.L109
	cmp	r9d, 6
	je	.L110
	vaddpd	xmm1, xmm1, XMMWORD PTR 16[rcx]
	mov	r10d, 2
.L110:
	mov	r11, r10
	inc	r10
	sal	r11, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r11]
.L109:
	mov	r8, r10
	inc	r10
	sal	r8, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r8]
.L108:
	mov	r9, r10
	inc	r10
	sal	r9, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r9]
.L107:
	mov	r11, r10
	inc	r10
	sal	r11, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r11]
.L106:
	mov	r8, r10
	inc	r10
	sal	r8, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r8]
.L105:
	mov	r9, r10
	inc	r10
	sal	r9, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r9]
	cmp	eax, r10d
	jbe	.L125
.L47:
	mov	r11, r10
	mov	r8, r10
	mov	r9, r10
	sal	r11, 4
	sal	r8, 4
	sal	r9, 4
	vaddpd	xmm0, xmm1, XMMWORD PTR [rcx+r11]
	mov	r11, r10
	sal	r11, 4
	vaddpd	xmm2, xmm0, XMMWORD PTR 16[rcx+r8]
	mov	r8, r10
	sal	r8, 4
	vaddpd	xmm3, xmm2, XMMWORD PTR 32[rcx+r9]
	mov	r9, r10
	sal	r9, 4
	vaddpd	xmm4, xmm3, XMMWORD PTR 48[rcx+r11]
	mov	r11, r10
	sal	r11, 4
	vaddpd	xmm5, xmm4, XMMWORD PTR 64[rcx+r8]
	mov	r8, r10
	add	r10, 8
	sal	r8, 4
	vaddpd	xmm1, xmm5, XMMWORD PTR 80[rcx+r9]
	vaddpd	xmm0, xmm1, XMMWORD PTR 96[rcx+r11]
	vaddpd	xmm1, xmm0, XMMWORD PTR 112[rcx+r8]
	cmp	eax, r10d
	ja	.L47
.L125:
	vunpckhpd	xmm2, xmm1, xmm1
	add	eax, eax
	vaddpd	xmm0, xmm2, xmm1
	cmp	edx, eax
	je	.L126
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+rax*8]
.L49:
.L126:
	ret
	.p2align 4
	.p2align 3
.L50:
	mov	edx, r8d
	vmovsd	xmm0, QWORD PTR [rcx]
	mov	r10d, 1
	and	edx, 7
	cmp	r8d, 1
	jb	.L126
	test	edx, edx
	je	.L46
	cmp	edx, 1
	je	.L99
	cmp	edx, 2
	je	.L100
	cmp	edx, 3
	je	.L101
	cmp	edx, 4
	je	.L102
	cmp	edx, 5
	je	.L103
	cmp	edx, 6
	je	.L104
	vaddsd	xmm0, xmm0, QWORD PTR 8[rcx]
	mov	r10d, 2
.L104:
	mov	eax, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+rax*8]
.L103:
	mov	r9d, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+r9*8]
.L102:
	mov	r11d, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+r11*8]
.L101:
	mov	edx, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+rdx*8]
.L100:
	mov	eax, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+rax*8]
.L99:
	mov	r9d, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+r9*8]
	cmp	r8d, r10d
	jb	.L126
.L46:
	mov	r11d, r10d
	lea	edx, 1[r10]
	lea	eax, 2[r10]
	lea	r9d, 3[r10]
	vaddsd	xmm3, xmm0, QWORD PTR [rcx+r11*8]
	lea	r11d, 4[r10]
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+rdx*8]
	lea	edx, 5[r10]
	vaddsd	xmm5, xmm4, QWORD PTR [rcx+rax*8]
	lea	eax, 6[r10]
	vaddsd	xmm1, xmm5, QWORD PTR [rcx+r9*8]
	lea	r9d, 7[r10]
	add	r10d, 8
	vaddsd	xmm0, xmm1, QWORD PTR [rcx+r11*8]
	vaddsd	xmm2, xmm0, QWORD PTR [rcx+rdx*8]
	vaddsd	xmm3, xmm2, QWORD PTR [rcx+rax*8]
	vaddsd	xmm0, xmm3, QWORD PTR [rcx+r9*8]
	cmp	r8d, r10d
	jnb	.L46
	jmp	.L126
	.seh_endproc

Alles anzeigen

x86:

Code

	.intel_syntax noprefix

.section .text
.balign 16

.globl _DllMain@12
_DllMain@12:
push ebp
mov ebp, esp
sub esp, 4
mov dword ptr [ebp-4], 0
.L_0004:
mov dword ptr [ebp-4], 1
cmp dword ptr [ebp+12], 1
jne .L_0006
push 0
push 0
call _main
add esp, 8
.L_0006:
.L_0005:
mov eax, dword ptr [ebp-4]
mov esp, ebp
pop ebp
ret 12
.balign 16

.globl _SumF
_SumF:
push ebp
mov ebp, esp
sub esp, 16
push ebx
mov dword ptr [ebp-4], 0
.L_0007:
push dword ptr [_Lt_000E]
pop dword ptr [ebp-8]
mov dword ptr [ebp-12], 0
mov eax, dword ptr [ebp+12]
add eax, 4294967295
mov dword ptr [ebp-16], eax
jmp .L_000A
.L_000D:
fld dword ptr [ebp-8]
mov eax, dword ptr [ebp-12]
sal eax, 3
mov ebx, dword ptr [ebp+8]
add ebx, eax
fadd qword ptr [ebx]
fstp dword ptr [ebp-8]
.L_000B:
inc dword ptr [ebp-12]
.L_000A:
mov ebx, dword ptr [ebp-16]
cmp dword ptr [ebp-12], ebx
jbe .L_000D
.L_000C:
push dword ptr [ebp-8]
pop dword ptr [ebp-4]
.L_0008:
fld dword ptr [ebp-4]
pop ebx
mov esp, ebp
pop ebp
ret 8
.balign 16

.globl _SumD
_SumD:
push ebp
mov ebp, esp
sub esp, 24
push ebx
mov dword ptr [ebp-8], 0
mov dword ptr [ebp-4], 0
.L_000F:
push dword ptr [_Lt_0016]
push dword ptr [_Lt_0016+4]
pop dword ptr [ebp-12]
pop dword ptr [ebp-16]
mov dword ptr [ebp-20], 0
mov eax, dword ptr [ebp+12]
add eax, 4294967295
mov dword ptr [ebp-24], eax
jmp .L_0012
.L_0015:
mov eax, dword ptr [ebp-20]
sal eax, 3
mov ebx, dword ptr [ebp+8]
add ebx, eax
fld qword ptr [ebx]
fadd qword ptr [ebp-16]
fstp qword ptr [ebp-16]
.L_0013:
inc dword ptr [ebp-20]
.L_0012:
mov ebx, dword ptr [ebp-24]
cmp dword ptr [ebp-20], ebx
jbe .L_0015
.L_0014:
push dword ptr [ebp-16]
push dword ptr [ebp-12]
pop dword ptr [ebp-4]
pop dword ptr [ebp-8]
.L_0010:
fld qword ptr [ebp-8]
pop ebx
mov esp, ebp
pop ebp
ret 8
.balign 16
_main:
push ebp
mov ebp, esp
and esp, 0xFFFFFFF0
sub esp, 12
mov dword ptr [ebp-4], 0
call ___main
push 0
push dword ptr [ebp+12]
push dword ptr [ebp+8]
call _fb_Init@12
.L_0002:
.L_0003:
mov eax, dword ptr [ebp-4]
mov esp, ebp
pop ebp
ret

.section .data
.balign 4
_Lt_000E:	.long	0x00000000
.balign 8
_Lt_0016:	.quad	0x0000000000000000

.section .drectve
	.ascii " -export:SumF"

	.ascii " -export:SumD"

Alles anzeigen

x64:

Code

	.file	"Sum.c"
	.intel_syntax noprefix
	.text
	.globl	SumF
	.def	SumF;	.scl	2;	.type	32;	.endef
	.seh_proc	SumF
SumF:
	push	rbp
	.seh_pushreg	rbp
	mov	rbp, rsp
	.seh_setframe	rbp, 0
	sub	rsp, 16
	.seh_stackalloc	16
	.seh_endprologue
	mov	QWORD PTR 16[rbp], rcx
	mov	DWORD PTR 24[rbp], edx
	lea	rax, -16[rbp]
	mov	DWORD PTR [rax], 0
.L2:
	pxor	xmm0, xmm0
	movss	DWORD PTR -4[rbp], xmm0
	mov	DWORD PTR -8[rbp], 0
	mov	eax, DWORD PTR 24[rbp]
	sub	eax, 1
	mov	DWORD PTR -12[rbp], eax
	jmp	.L3
.L10:
	nop
.L4:
	cvtss2sd	xmm1, DWORD PTR -4[rbp]
	mov	eax, DWORD PTR -8[rbp]
	sal	rax, 3
	mov	rdx, rax
	mov	rax, QWORD PTR 16[rbp]
	add	rax, rdx
	movsd	xmm0, QWORD PTR [rax]
	addsd	xmm0, xmm1
	cvtsd2ss	xmm0, xmm0
	movss	DWORD PTR -4[rbp], xmm0
.L5:
	mov	eax, DWORD PTR -8[rbp]
	add	eax, 1
	mov	DWORD PTR -8[rbp], eax
.L3:
	mov	eax, DWORD PTR -8[rbp]
	cmp	eax, DWORD PTR -12[rbp]
	jbe	.L10
	nop
.L6:
	movss	xmm0, DWORD PTR -4[rbp]
	movss	DWORD PTR -16[rbp], xmm0
	nop
.L7:
	movss	xmm0, DWORD PTR -16[rbp]
	add	rsp, 16
	pop	rbp
	ret
	.seh_endproc
	.globl	SumD
	.def	SumD;	.scl	2;	.type	32;	.endef
	.seh_proc	SumD
SumD:
	push	rbp
	.seh_pushreg	rbp
	mov	rbp, rsp
	.seh_setframe	rbp, 0
	sub	rsp, 32
	.seh_stackalloc	32
	.seh_endprologue
	mov	QWORD PTR 16[rbp], rcx
	mov	DWORD PTR 24[rbp], edx
	lea	rax, -24[rbp]
	mov	QWORD PTR [rax], 0
.L12:
	pxor	xmm0, xmm0
	movsd	QWORD PTR -8[rbp], xmm0
	mov	DWORD PTR -12[rbp], 0
	mov	eax, DWORD PTR 24[rbp]
	sub	eax, 1
	mov	DWORD PTR -16[rbp], eax
	jmp	.L13
.L20:
	nop
.L14:
	mov	eax, DWORD PTR -12[rbp]
	sal	rax, 3
	mov	rdx, rax
	mov	rax, QWORD PTR 16[rbp]
	add	rax, rdx
	movsd	xmm0, QWORD PTR [rax]
	movsd	xmm1, QWORD PTR -8[rbp]
	addsd	xmm0, xmm1
	movsd	QWORD PTR -8[rbp], xmm0
.L15:
	mov	eax, DWORD PTR -12[rbp]
	add	eax, 1
	mov	DWORD PTR -12[rbp], eax
.L13:
	mov	eax, DWORD PTR -12[rbp]
	cmp	eax, DWORD PTR -16[rbp]
	jbe	.L20
	nop
.L16:
	movsd	xmm0, QWORD PTR -8[rbp]
	movsd	QWORD PTR -24[rbp], xmm0
	nop
.L17:
	movsd	xmm0, QWORD PTR -24[rbp]
	add	rsp, 32
	pop	rbp
	ret
	.seh_endproc
/APP
	.section .drectve
	.ascii " -export:\"SumF\""
	.ascii " -export:\"SumD\""

	.text

Alles anzeigen

**AspirinJunkie**

Hui und wie mache ich daraus einen in AutoIt verwendbaren Binärcode?

Zitat von UEZ

wie soll bei der Float summiert werden, wenn du ein Double Array übergibst?

Gar nicht. Wenn ich ein Float-array habe dann soll der Float-Code verwendet werden. Gemischt wird natürlich nicht.

Ansonsten möchte ich ja eben keine Dlls dazulegen, sondern das bewusst intern im AutoIt-Code selbst mitliefern.

Aber danke schonmal Jungs. Wusste doch, dass ich die Spezis damit anfixe.

**Andy**

Zitat von UEZ

Das ist der x64 ASM Output vom Compiler:

Cool, bin nur drübergeflogen, aber wie das aussieht, ist der "clevere" Teil von dir geschrieben. Zeig mal bitte den Freebasic-code.

**UEZ**

Zitat von Andy

Cool, bin nur drübergeflogen, aber wie das aussieht, ist der "clevere" Teil von dir geschrieben. Zeig mal bitte den Freebasic-code.

Den ASM Code hat der Compiler gebastelt - der FB Code ist simpel:

Code

#ifdef __FB_64BIT__
	#cmdline "-RR -m Sum64 -dll -export -gen gcc -Wc -Ofast -Wc -march=native -Wc -funroll-loops -Wc -mfpmath=sse"
#else
    #cmdline "-RR -m Sum -dll -export -gen gcc -Wc -Ofast -Wc -march=native -Wc -funroll-loops -Wc -mfpmath=sse"
#endif

Extern "Windows-MS"
	
Function SumF(tStruct As Double Ptr, iLen As ULong) As Single Export
	Dim As Single fSum = 0
	For i As ULong = 0 To iLen - 1
		fSum += tStruct[i]
	Next
	Return fSum
End Function
	
Function SumD(tStruct As Double Ptr, iLen As ULong) As Double Export
	Dim As Double fSum = 0
	For i As ULong = 0 To iLen - 1
		fSum += tStruct[i]
	Next
	Return fSum
End Function
End Extern

Alles anzeigen

Man kann auch die Optimierung ausschalten, damit mehr Kompatibilität ensteht, aber zugunsten der Geschwindigkeit.

Zitat von AspirinJunkie

Hui und wie mache ich daraus einen in AutoIt verwendbaren Binärcode?
Gar nicht. Wenn ich ein Float-array habe dann soll der Float-Code verwendet werden. Gemischt wird natürlich nicht.
Ansonsten möchte ich ja eben keine Dlls dazulegen, sondern das bewusst intern im AutoIt-Code selbst mitliefern.
Aber danke schonmal Jungs. Wusste doch, dass ich die Spezis damit anfixe.

Ich muss mal checken, wie man aus dem Code ein Binär Code erstellt, sodass man ihn einfach per DLLCallAddress aufruft.

Wie du in der Funktion SumF sehen kannst, ist innerhalb der Funktion die Variable fSum als Single (Float) definiert, d.h. die Summe ist anders als mit Double, deshalb meine Nachfrage.

**Kanashius**

Hi, ich kenn mich mit Assembler in AutoIt nicht so gut aus, nutze aber im moment Rust gerne und dachte mir, dass die Sprache doch sehr optimiert sein soll.
Mit den passenden Parametern hab ich das ganze auf 8KB (x86) / 9KB (x64) bekommen und die Funktionen sind in Assembly auch deutlich kürzer, als dass was ich bei UEZ bei Freebasic sehe.
Weiß aber leider nicht, wie man das mit AutoIt ausführt und ob der Code so funktioniert

x86:

Code

; =============== S U B R O U T I N E =======================================
                public sum_double
sum_double      proc near               ; DATA XREF: .rdata:off_10002508↓o
var_8           = qword ptr -8
arg_0           = dword ptr  8
arg_4           = dword ptr  0Ch
                push    ebp
                mov     ebp, esp
                and     esp, 0FFFFFFF8h
                sub     esp, 8
                mov     eax, [ebp+arg_4]
                test    eax, eax
                jz      short loc_1000102C
                mov     ecx, [ebp+arg_0]
                xorpd   xmm0, xmm0
                mov     ecx, [ecx]
                nop     dword ptr [eax+00000000h]
loc_10001020:                           ; CODE XREF: sum_double+28↓j
                addsd   xmm0, qword ptr [ecx]
                add     ecx, 8
                dec     eax
                jnz     short loc_10001020
                jmp     short loc_10001030
loc_1000102C:                           ; CODE XREF: sum_double+E↑j
                xorpd   xmm0, xmm0
loc_10001030:                           ; CODE XREF: sum_double+2A↑j
                movsd   [esp+8+var_8], xmm0
                fld     [esp+8+var_8]
                mov     esp, ebp
                pop     ebp
                retn
sum_double      endp

; =============== S U B R O U T I N E =======================================
                public sum_float
sum_float       proc near               ; DATA XREF: .rdata:off_10002508↓o
var_4           = dword ptr -4
arg_0           = dword ptr  4
arg_4           = dword ptr  8
                push    eax
                mov     eax, [esp+4+arg_4]
                test    eax, eax
                jz      short loc_10001074
                mov     ecx, [esp+4+arg_0]
                xorps   xmm0, xmm0
                mov     ecx, [ecx]
                nop     word ptr cs:[eax+eax+00000000h]
                nop     dword ptr [eax+00h]
loc_10001060:                           ; CODE XREF: sum_float+28↓j
                addss   xmm0, dword ptr [ecx]
                add     ecx, 4
                dec     eax
                jnz     short loc_10001060
                movss   [esp+4+var_4], xmm0
                fld     [esp+4+var_4]
                pop     eax
                retn
loc_10001074:                           ; CODE XREF: sum_float+7↑j
                xorps   xmm0, xmm0
                movss   [esp+4+var_4], xmm0
                fld     [esp+4+var_4]
                pop     eax
                retn
sum_float       endp

Alles anzeigen

x64:

Code

; =============== S U B R O U T I N E =======================================
                public sum_double
sum_double      proc near               ; DATA XREF: .rdata:off_1800027D8↓o
                test    edx, edx
                jz      short loc_18000101D
                mov     rcx, [rcx]
                mov     r8d, edx
                mov     eax, r8d
                and     eax, 7
                cmp     edx, 8
                jnb     short loc_180001021
                xorpd   xmm0, xmm0
                xor     edx, edx
                jmp     short loc_180001068
loc_18000101D:                          ; CODE XREF: sum_double+2↑j
                xorps   xmm0, xmm0
                retn
loc_180001021:                          ; CODE XREF: sum_double+13↑j
                and     r8d, 0FFFFFFF8h
                xorpd   xmm0, xmm0
                xor     edx, edx
                nop     dword ptr [rax+rax+00h]
loc_180001030:                          ; CODE XREF: sum_double+66↓j
                addsd   xmm0, qword ptr [rcx+rdx*8]
                addsd   xmm0, qword ptr [rcx+rdx*8+8]
                addsd   xmm0, qword ptr [rcx+rdx*8+10h]
                addsd   xmm0, qword ptr [rcx+rdx*8+18h]
                addsd   xmm0, qword ptr [rcx+rdx*8+20h]
                addsd   xmm0, qword ptr [rcx+rdx*8+28h]
                addsd   xmm0, qword ptr [rcx+rdx*8+30h]
                addsd   xmm0, qword ptr [rcx+rdx*8+38h]
                add     rdx, 8
                cmp     r8, rdx
                jnz     short loc_180001030
loc_180001068:                          ; CODE XREF: sum_double+1B↑j
                test    rax, rax
                jz      short locret_18000108D
                lea     rcx, [rcx+rdx*8]
                xor     edx, edx
                db      66h, 66h, 66h, 66h, 2Eh
                nop     word ptr [rax+rax+00000000h]
loc_180001080:                          ; CODE XREF: sum_double+8B↓j
                addsd   xmm0, qword ptr [rcx+rdx*8]
                inc     rdx
                cmp     rax, rdx
                jnz     short loc_180001080
locret_18000108D:                       ; CODE XREF: sum_double+6B↑j
                retn
sum_double      endp

; =============== S U B R O U T I N E =======================================
                public sum_float
sum_float       proc near               ; DATA XREF: .rdata:off_1800027D8↓o
                test    edx, edx
                jz      short loc_1800010AC
                mov     rcx, [rcx]
                mov     r8d, edx
                mov     eax, r8d
                and     eax, 7
                cmp     edx, 8
                jnb     short loc_1800010B0
                xorps   xmm0, xmm0
                xor     edx, edx
                jmp     short loc_1800010F8
loc_1800010AC:                          ; CODE XREF: sum_float+2↑j
                xorps   xmm0, xmm0
                retn
loc_1800010B0:                          ; CODE XREF: sum_float+13↑j
                and     r8d, 0FFFFFFF8h
                xorps   xmm0, xmm0
                xor     edx, edx
                nop     dword ptr [rax+00000000h]
loc_1800010C0:                          ; CODE XREF: sum_float+66↓j
                addss   xmm0, dword ptr [rcx+rdx*4]
                addss   xmm0, dword ptr [rcx+rdx*4+4]
                addss   xmm0, dword ptr [rcx+rdx*4+8]
                addss   xmm0, dword ptr [rcx+rdx*4+0Ch]
                addss   xmm0, dword ptr [rcx+rdx*4+10h]
                addss   xmm0, dword ptr [rcx+rdx*4+14h]
                addss   xmm0, dword ptr [rcx+rdx*4+18h]
                addss   xmm0, dword ptr [rcx+rdx*4+1Ch]
                add     rdx, 8
                cmp     r8, rdx
                jnz     short loc_1800010C0
loc_1800010F8:                          ; CODE XREF: sum_float+1A↑j
                test    rax, rax
                jz      short locret_18000111D
                lea     rcx, [rcx+rdx*4]
                xor     edx, edx
                db      66h, 66h, 66h, 66h, 2Eh
                nop     word ptr [rax+rax+00000000h]
loc_180001110:                          ; CODE XREF: sum_float+8B↓j
                addss   xmm0, dword ptr [rcx+rdx*4]
                inc     rdx
                cmp     rax, rdx
                jnz     short loc_180001110
locret_18000111D:                       ; CODE XREF: sum_float+6B↑j
                retn
sum_float       endp

Alles anzeigen

Code:

Code

#[repr(C)]
pub struct Doubles { pub data: *mut f64, }

#[repr(C)]
pub struct Floats { pub data: *mut f32, }

#[no_mangle]
pub extern "C" fn sum_double(data: *mut Doubles, size: u32) -> f64 {
    unsafe { return std::slice::from_raw_parts((*data).data, size as usize).iter().sum(); }
}

#[no_mangle]
pub extern "C" fn sum_float(data: *mut Floats, size: u32) -> f32 {
    unsafe { return std::slice::from_raw_parts((*data).data, size as usize).iter().sum(); }
}

Alles anzeigen

Cargo.toml (für die c-lib und die compiler einstellungen zur optimierung):

Code

[package]
name = "float_sum"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]

[profile.release]
codegen-units = 1
lto = "fat"

Alles anzeigen

Vielleicht hilft euch das ja weiter (und ich hatte etwas Spaß mit den Compileroptionen rumzuspielen :D)

**Andy**

sodele, hab da was....

14 Zeilen ASM-Code aka 44 Bytes Code müssen für die Summierung der Floats reichen

Problem ist, wie üblich bei Summierung von vielen Floats, die Ungenauigkeit. AutoIt lügt ja wie gedruckt, rechnet intern mit 64 Bit, da finden dann keine/kaum Überläufe statt aber der ASM-Code rechnet "nur" mit 32Bit pro Float

Aktuell bin ich bei 0,7 Prozessortakten pro Addition....die Compiler optimieren sehr stark, machen loop unrolling und berücksichtigen cache-lines...mache ich alles nicht....

AspirinJunkie , wie viele Floats müssen da zusammengezählt werden? Minimal und maximal? Ich würde dann den Code für X64 und Double anpassen.

Die Summe von 1.000.000 Floats werden in ca. 0.3ms berechnet, sollten das mehr Additionen sein, würde ich mit einer Handvoll Zeilen mehr noch ggf. Faktor 2-3 an Geschwindigkeit rausholen können. Aktuell muss die Anzahl durch 4 teilbar sein (Struct ggf. mit Nullen auffüllen) wenn man gleichzeitig 16 Zahlen addiert (per AVX) , muss die Structgröße glatt durch 16 teilbar sein.

Dazu MUSS die Struct 16-Byte-aligned sein, warum das nicht standardmäßig in DllStructCreate implementiert ist weiß wieder mal kein Mensch...Ich habe dazu eine Funktion gebastelt. Man könnte auch eine Bitmap erstellen, die ist immer 16-Byte aligned und an deren Adresse die Struct erstellen.....

UEZ´s Compilercode liest übrigens unaligned aus dem Speicher...der S U P E R G A U !!

Code

#include <Memory.au3>

;~ #include <assembleit2_64.au3>
#AutoIt3Wrapper_UseX64=n



#cs sumfloat32

    use32
    mov edi, [esp + 4]                      ;ES:EDI = Pointer auf die struct
    mov ecx, [esp + 8]                      ;ECX = Anzahl zu summierender floats
	shl ecx,2								;geteilt durch 4, immer 4 floats gleichzeitig addieren
	xorps xmm0,xmm0							;xmm0 = 0 0 0 0
	sub ecx,16								;Adresse der letzten 4 floats
	movaps xmm0,[edi]						;xmm0 = die ersten 4 floats

	_schleife:                              ;
    addps xmm0, [edi+ecx]					;4 floats im speicher zu den 4 floats in xmm0 addieren
	sub ecx,16								;adresse der nächsten 4 floats...
    jnz _schleife							;so lange, bis alle floats addiert sind

	haddps xmm0,xmm0						;die 4 floats in xmm0 addieren
 	haddps xmm0,xmm0						;jetzt steht die gesamte summe in jedem register von xmm0

	movd dword[edi],xmm0					;in den speicher schreiben
	fld dword[edi]							;rückgabe der floats im float-stack

    ret

#ce sumfloat32



;~ Global $binarycode = _AssembleIt2("retbinary", "sumfloat32")
;~ $tCodebuffer = DllStructCreate("byte[" & StringLen($binarycode) / 2 - 1 & "]") ;Speicher für den Bytecode reservieren
;~ DllStructSetData($tCodebuffer, 1, $binarycode) ;Bytecode in den Speicher schreiben

Global $tCodeBuffer = DllStructCreate("byte[56]") ;reserve Memory for opcodes
DllStructSetData($tCodeBuffer, 1,"0x8B7C24048B4C2408C1E1020F57C083E9100F28070F58040F83E91075F7F20F7CC0F20F7CC0660F7E07D907C3") ;write opcodes into memory



$sum=0

$anzahl=1000000
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $anzahl = ' & $anzahl & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
Global $tData = _dllstructcreate64("FLOAT["&$anzahl&"]")

; füllen
For $i = 1 To $anzahl
	DllStructSetData($tData, 1, 1/$i, $i)
	$sum+=1/$i
Next

ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : AutoIt $sum = ' & $sum & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console

$t=timerinit()
$fSum = _sumUpMemory(DllStructGetPtr($tData), $anzahl)
$time=timerdiff($t)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : ASM   $fSum = ' & $fSum & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console

$diff = $sum-$fSum
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $diff = ' & $diff & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console

ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $time = ' & $time &"ms"& @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console






Func _sumUpMemory($pPointer, $iN, $sType = "FLOAT")
	; hier sollte irgendwie der Binary mit den x64 und x86-Binärcode stehen
	; dieser sollte dann in den Speicher zur Ausführung geschrieben werden
	; und dann per (vermutlich) DllCallAddress ausgeführt werden

	If $sType = "DOUBLE" Then
		If @AutoItX64 Then
			; hier sollte der x64 DOUBLE-Code hin
		Else
			; hier sollte der x64 FLOAT-Code hin
		EndIf
	Else ; "FLOAT"
		If @AutoItX64 Then
			; hier sollte der x86 DOUBLE-Code hin
		Else
;~ 			$ret = _AssembleIt2("float","sumfloat32",  "ptr",$pPointer,"uint", $iN);,"retbinary",@scriptlinenumber)
;~ 			ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $ret = ' & $ret & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console					$ret = _AssembleIt2("float","sumfloat32",  "ptr",$pPointer,"uint", $iN,"retbinary", @ScriptLineNumber)

 			$ret = DllCallAddress("float:cdecl", DllStructGetPtr($tCodebuffer), "ptr",$pPointer, "uint", $iN)
			return $ret[0]

		EndIf
	EndIf

EndFunc


Func _dllstructcreate64($struct)                                       ;align auf 64-byte adresse
    Local $temp = DllStructCreate($struct)
    Local $tempsize = DllStructGetSize($temp)
    Local $mem = _MemVirtualAlloc(0, $tempsize, $MEM_COMMIT, $PAGE_EXECUTE_READWRITE)
    $mem_dllstructcreate64_internal = $mem
    Local $sstruct = DllStructCreate($struct, Number($mem))
    Return $sstruct                                                    ;auf 64 alingned pointer
EndFunc

;~     Exit

Alles anzeigen

**Andy**

Habe mir mal den Code von Rust angeschaut....da schiessen mir ehrlich gesagt die Tränen in die Augen...

Der Prozessorbefehl, den alle Compilate (bisher) (und auch ich^^) benutzen um die Floats zusammenzuzählen lautet ADDPS

image.png

Wie man im Schaubild sieht, addiert der Befehl 4 Floats aus einem Register oder Speicher zu den 4 Floats im Register....DAS ist der Sinn und Zweck von SSE (Streaming SIMD Extensions), die parallele Ausführung von Instruktionen, hier die Addition. SIMD heißt Single Instruction Multiple Data, man kann MEHRERE Daten gleichzeitig bearbeiten.

Ich in meinem ASM-Programm mache das auch so, ich lese 128 Bit (16 Byte) an Daten ein und addiere diese zu den 128 Bit Daten (aka 4 Floats = 16 Bytes) im Register....logischerweise muss man dann, um die nächsten 4 Floats (16 Bytes) zu addieren, im Speicher auch 16 Bytes weiter springen....Rust springt 4 Bytes weiter....addiert also immer nur EINE Float!!! Natürlich werden die folgenden 3 Floats auch zu den entsprechenden Teilen im Register dazuaddiert, das ist aber völlig irrelevant, da der Compiler diese Addition nie berücksichtigt!

Die Rust-Schleife läuft also 4x länger als eigentlich vorgesehen, und bei 3 von 4 ADDPS haut auch noch der unaligned Speicherzugriff voll rein...Soviel zu "Compiler-Optionen".....

UEZ´s Compiler benutzt für die Addition der Floats den uralten (seit 1999 überflüssigen) Coprozessor mit
fadd qword ptr [ebx]

und addiert, wie Rust, jede der Floats im Speicher nacheinander.....

Könnte mal jemand BITTE einen GCC oder Intel/M$-Compiler anwerfen? Und damit mal versuchen, ob mit deren Compileroptionen diese simple SSE-Addition "richtig" ausgeführt wird?

Und um jetzt die aufkommende Frage der interessierten Leser zu beantworten: "Ja, Andy, du hast jetzt im letzten Schleifendurchlauf alle Floats addiert, die bestehen im XMM-Register aber doch aus 4 einzelnen Floats die auch noch zusammengezählt werden müssen!"

Ja, stimmt! Im XMM-Register stehen 4 Floats "hintereinander", um innerhalb eines XMM-Registers die einzelnen Teile zusammenzuaddieren, gibt es den image.png

der addiert innerhalb des Registers.

Angenommen im Register xmm0 stehen die Floats 1.0 2.0 6.0 7.0

dann wird in der Instruktion HADDPS xmm0,xmm0 folgendes berechnet

6.0 + 7.0 =13.0 geht ins 4. Registerteil

1.0 + 2.0 = 3.0 geht ins 3. Registerteil

6.0 +7.0 =13.0 geht ins 2. Registerteil

1.0 + 2.0 = 3.0 geht ins 1. Registerteil

Im Register xmm0 stehen also die Floats 13.0 3.0 13.0 3.0

beim nochmaligen HADDPS xmm0,xmm0 wird berechnet

13.0 + 3.0 =16.0 geht ins 4. Registerteil

13.0 + 3.0 = 16.0 geht ins 3. Registerteil

13.0 +3.0 =16.0 geht ins 2. Registerteil

13.0 + 3.0 = 16.0 geht ins 1. Registerteil

Danach stehen in allen Registerteilen (Floats) die Summe der 4 einzelnen Floats aka die Gesamtsumme aller Floats

Tadaaaaaa!

**Andy**

Ich zitiere mich mal selbst:

Zitat von Andy

Könnte mal jemand BITTE einen GCC oder Intel/M$-Compiler anwerfen? Und damit mal versuchen, ob mit deren Compileroptionen diese simple SSE-Addition "richtig" ausgeführt wird?

Habe eben auf https://godbolt.org mal folgende Funktion mit den verschiedensten Compilern durchgetestet.

Code

void sumArray(float* x,int* n) {
    int i;
    float sum;
    for (i = 0; i < n; i++) {
        sum += x[i];
    }
}

Bin ja nicht der C-Spezialist, sollte so aber passen....

K E I N E R der von den zwölfundneunzig von mir ausgewählten Compilern hat etwas anderes gemacht, als nacheinander einzelne Floats zu addieren. Von SSE/SIMD oder anderen seit Jahrzehnten möglichen Techniken zur parallelen Berechnung keine Spur....

Ich spiele mal mit den Compileroptionen rum....schaumamal

//EDIT

So wie ich das sehe, empfehlen die Compiler-Hersteller die Verwendung von Intrinsics...

https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html

Damit werden die ASM-Instruktionen in die Hochsprache gehievt...warum auch nicht, da macht der Compiler wenigstens (ohne zu "optimieren") was er soll!

HADDPS https://www.intel.com/content/www/us…4&ssetechs=SSE3

image.png

**AspirinJunkie**

Jetzt sind wir ja schon auf dem Level den ASM-Code zu optimieren.
Der interessante Schritt dazwischen "ASM-Code in ein aus AutoIt heraus aufrufbares Binary zu überführen" sind wir aber bislang noch nicht angegangen.
Hatte AssembleIt da nicht Techniken dafür?

Zitat von Andy

wie viele Floats müssen da zusammengezählt werden? Minimal und maximal? Ich würde dann den Code für X64 und Double anpassen.

Komplett unterschiedlich: Von 2 bis 1 Million in Einerschritten alles möglich.

Ansonsten versuche ich die Taktik zu fahren: Lass sie dir erstmal ihren kleinen Finger reichen und nimm dir dann die ganze Hand
Auch wenn ich die Summenfunktion ebenso gut gebrauchen kann, benötige ich sie im konkreten Fall für die Berechnung des Mittelwertes des jeweiligen Arrays.
Wir können das, falls hier die Lust besteht - dann noch beliebig erweitern.
Z.b. könnte man anstatt dem naiven Ansatz die Kahan-Summation implementieren um den numerischen Fehler so gering wie möglich zu halten.

Um mal den Schleier fairerweise etwas zu lüften: Es geht um BLAS/LAPACK.
Die haben interessanterweise tatsächlich keine Funktionalität zum Aufsummieren (nur für Absolutsummen), einfach weil das zu profan ist und die nicht glauben konnten, dass das jemand aus einer langsamen Programmiersprache heraus aufruft.
Ganz ganz konkret benötige ich es gerade um die Mittelwerte der Spalten der Jacobimatrix zu berechnen, damit ich eine Total-Least-Squares-Lösung per Singulärwertzerlegung berechnen kann.
Momentan behelfe ich mir, indem ich einfach das Skalarprodukt des Vektors mit dem Einheitsvektor berechne.
Das geht zwar immer noch 1.000x schneller als nativ in AutoIt zu rechnen aber elegant ist es halt auch nicht.
In einem nächsten Schritt könnte man die Schleifenvariablen per Parameter anpassbar machen, wie es bei BLAS so üblich ist.
Dann könnte man z.B. auch direkt die Diagonalensumme einer Matrix berechnen ohne erst umzukopieren.
Aber wie gesagt - das alles nur optional für vielleicht später mal.

Bei aller Aufregung, sollten wir aber nicht vergessen,dass Al Bundy 1966 Vier Touchdowns in einem Spiel gemacht hat und den Polk High School Panthers damit zur Stadtmeisterschaft verholfen hat!

**Andy**

Zitat von AspirinJunkie

Der interessante Schritt dazwischen "ASM-Code in ein aus AutoIt heraus aufrufbares Binary zu überführen" sind wir aber bislang noch nicht angegangen.

Doch, schau mal in mein Script in Post #10.

Binärcode mit Aufruf per DllCallAddress()

Zitat von AspirinJunkie

Komplett unterschiedlich: Von 2 bis 1 Million in Einerschritten alles möglich.

Ok, dann wird es interessant. Ggf. macht es dann auch Sinn, den (für parallele Berechnungen) lahmarschigen Prozessor (CPU) mit Hilfe der Grafikkarte bzw. in die CPU integrierter GPU auf die Sprünge zu helfen.

Matrixberechnungen werden nicht ohne Grund bei Supercomputeranwendungen auf GPU´s ausgelagert. Die sind dafür prädestiniert, Vektorisierungen sind dort einfach zu erstellen...Cuda ist auf Nvidia beschränkt, daher habe ich solches schon in AutoIt per OpenCL umgesetzt.

Btw. Vektorisierung, UEZ und Kanashius das sollte man auch dem Compiler hinwerfen, dann macht der auch parallel ausführbaren Code...

Zitat von AspirinJunkie

Hatte AssembleIt da nicht Techniken dafür?

Na klar^^, habe imho sogar im letzten Jahr ein Howto verfasst...

AssembleIt kann nun nach dem Testen/Debuggen selbstständig den AutoItcode mit Binärcode und Aufruf über DllCallAddress() erstellen, s.S. 7 unten

How To _AssembleIt2() deutsch.pdf

**AspirinJunkie**

Zitat von Andy

Doch, schau mal in mein Script in Post #10.

Guck an - hatte das gar nicht für wahr genommen, da der ASM-Code ja nur in einem Comment steckte. Aber das ist ja wie ich nun sehe genau der Witz an AssembleIt2.

Dein godbolt.org-Seite ist ja mal interessant.
Ich habe zwar keine Ahnung von Assembler aber ein Träumchen wäre es, wenn ich dort den Code in C eingeben könnte und dann entweder direkt ein Binary oder ein ASM-Code erhalte, welchen ich in AssembleIt2 verwenden könnte,.
Wäre das damit möglich und wenn ja: Wie müsste der C-Code hierfür strukturiert sein? Also wie müsste ich die Funktionsdefinition schreiben usw.

Es kommt in meinem Fall ja auch nicht auf das theoretische letzte Prozent Performance an.

**Andy**

https://en.wikipedia.org/wiki/Kahan_summation_algorithm ist sehr interessant. Unten im Artikel ist von den optimierten sum()-Funktionen einiger Sprachen die Rede.

Dann wäre es es echt eine Überlegung wert, den von diesen Compilern erstellten Code in eine AssembleIt-Funktion zu kopieren und den Binärcode erstellen zu lassen.

Das wäre echt einfach....

Zitat von AspirinJunkie

Ich habe zwar keine Ahnung von Assembler aber ein Träumchen wäre es, wenn ich dort den Code in C eingeben könnte und dann entweder direkt ein Binary oder ein ASM-Code erhalte, welchen ich in AssembleIt2 verwenden könnte,.

Yepp, das funktioniert auch (fast) genau so

image.png

den Assemblercode (hier 64Bit) kannst du so ins AssembleIt einfügen, ich mach mal ein Beispiel.

AssembleIt2_64 v 313.zip

Code

#include <assembleit2_64.au3>
#AutoIt3Wrapper_UseX64=y


#cs square

		use64
		push    rbp
        mov     rbp, rsp
        mov     DWORD [rbp-4], ecx
        mov     eax, DWORD [rbp-4]
        imul    eax, eax

        pop     rbp
        ret

#ce square


$a=8

$ret = _AssembleIt2("int","square",  "int",$a);,"retbinary",@scriptlinenumber)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $ret = ' & $ret & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console

Alles anzeigen

in Zeile 12 wurde das Register edi durch ecx ersetzt, s. 64-Bit Aufrufkonventionen, ggf. kann man das auch per fastcall o.ä. anpassen

die DWORD PTR wurden durch DWORD ersetzt bzw. das PTR entfernt, das ist dem im AssembleIt verwendeten FASM Assembler geschuldet. Aber das erkennt AssembleIt und weist dich hin...

Ansonsten könnte man die so erstellten bzw auch von UEZ und Kanashius erstellten Codes so einfügen und per AssembleIt testen und bearbeiten

**AspirinJunkie**

Hm bei mir klappt es noch nicht ganz:

AutoIt

#include <assembleit2_64.au3>
#AutoIt3Wrapper_UseX64=y


#cs square

		use64
		push    rbp
        mov     rbp, rsp
        mov     DWORD [rbp-4], ecx
        mov     eax, DWORD [rbp-4]
        imul    eax, eax

        pop     rbp
        ret

#ce square

; ist das die Größe des 1. Parameters in Bytes?
$a=4

; Binärcode erzeugen
$bRet = _AssembleIt2("int", "square", "int", $a) ; was macht das a?!

; Binärcode in den Speicher zur Ausführung schreiben
$tCodebuffer = DllStructCreate("byte[" & StringLen($bRet) / 2 - 1 & "]") ;Speicher für den Bytecode reservieren
DllStructSetData($tCodebuffer, 1, $bRet) ;Bytecode in den Speicher schreiben
Global $pFuncSquare = DllStructGetPtr($tCodebuffer)

; Funktion im Speicher aufrufen
$aDllCall = DllCallAddress("int:cdecl", $pFuncSquare, "int", 15)
_ArrayDisplay($aDllCall)

Alles anzeigen

Zitat von Andy

In Zeile 12 wurde das Register edi durch ecx ersetzt, s. 64-Bit Aufrufkonventionen, ggf. kann man das auch per fastcall o.ä. anpassen

Ok also ganz ohne Anpassungen kann ich den Output von denen also offensichtlich nicht verwenden?

**Andy**

Zitat von AspirinJunkie

Ok also ganz ohne Anpassungen kann ich den Output von denen also offensichtlich nicht verwenden?

Jeder Compilerbauer kocht sein eigenes Süppchen. Würdest du bspw. den GCC-C-Compiler den Code erstellen/assemblieren lassen und per DllCallAddress im GCC aufrufen, dan würde das auch genau so funktionieren.

Das macht dann ein Assembler / Disassembler, bspw. so , auch online

image.png

Bin heute Abend wieder Online, dann versuchen wir das mal ohne Modifikationen am Code....bis denne

**AspirinJunkie**

Zitat von Andy

Bin heute Abend wieder Online, dann versuchen wir das mal ohne Modifikationen am Code....bis denne

Ok vielleicht hilft dir ja folgendes Skript ein bisschen:

AutoIt

; API-Documentation: https://github.com/compiler-explorer/compiler-explorer/blob/main/docs/API.md

#include "JSON.au3" ; https://github.com/Sylvan86/autoit-json-udf

; global http request object
Global $oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
;$oHTTP.SetProxy(2, "localhost:3128")

; Domain of the compiler explorer server
Global Const $__g_CE_DOMAIN = "https://godbolt.org"

; choose language
Global $sLangID = "c"
Global $sCompilerID = "cg142"

; the C source-code:
Global $sSourceCode = _
'int square(int num) {' & @LF & _
'    return num * num;' & @LF & _
'}'

; compile
Global $mCompilated = _ce_compileCode($sSourceCode, $sCompilerID, $sLangID)

; display results
MsgBox(0, "ASM Code", $mCompilated.Code)
MsgBox(0, "Binary", $mCompilated.Binary)

; compiles a code via a compiler explorer server and returns the asm-code and the binary
Func _ce_compileCode($sCode, $sCompilerID, $sLangID = "c", $sCompilerFlags = Default)

	Local $mPostData[]
	$mPostData.source = $sCode
	$mPostData.lang   = $sLangID

	Local $mOptions[]
	If IsString($sCompilerFlags) Then $mOptions.userArguments = $sCompilerFlags

	Local $mFilters[]
	$mFilters.binary       = True ; with this also opcodes are returned
	$mFilters.binaryObject = True

	$mOptions.filters = $mFilters
	$mPostData.options = $mOptions

	; do the api compile request
	Local $sResponse
    With $oHTTP
        .Open("POST", $__g_CE_DOMAIN & "/api/compiler/" & $sCompilerID & "/compile", False)
		.SetRequestHeader("Accept", "application/json") ; so that JSON comes back as return type
		.setRequestHeader("Content-type", "application/json")
        .Send(_JSON_Generate($mPostData))
        $sResponse = .ResponseText
    EndWith

	; extract the asm code and the binary opcodes
	Local $sASMCode = "", $sBinary = "", $mLine, $sOpCode
	For $mLine In _JSON_Parse($sResponse).asm
		If Not  MapExists($mLine, "text") Then ContinueLoop
		If $mLine["text"] = "main:" Then ExitLoop

		$sASMCode &= $mLine["text"] & @CRLF

		If MapExists($mLine, "opcodes") Then
			For $sOpCode In $mLine["opcodes"]
				$sBinary &= $sOpCode
			Next
		EndIf
	Next

	Local $mRet[]
	$mRet.Code = $sASMCode
	$mRet.Binary = Binary("0x" & $sBinary)

	Return $mRet
EndFunc

; describe an assembler opcode
;~ MsgBox(0, "push", _ce_describeOpcode("push").tooltip)
Func _ce_describeOpcode($sOpCode, $sInstructionSet = "amd64")
	Local $sResponse

    With $oHTTP
        .Open("GET", StringFormat("%s/api/asm/%s/%s", $__g_CE_DOMAIN, $sInstructionSet, $sOpCode), False)
		.SetRequestHeader("Accept", "application/json") ; so that JSON comes back as return type
        .Send()
        $sResponse = .ResponseText
    EndWith

	Return _JSON_Parse($sResponse)
EndFunc

; return a list of supported languages of a compiler explorer server
Func _ce_getLanguages($sLang = Default, $sInstructionSet = Default)
	Local $sResponse

    With $oHTTP
        .Open("GET", $__g_CE_DOMAIN & "/api/languages", False)
		.SetRequestHeader("Accept", "application/json") ; so that JSON comes back as return type
        .Send()
        $sResponse = .ResponseText
    EndWith

	Return _JSON_Parse($sResponse)
EndFunc

; return a list of supported compilers of a compiler explorer server
Func _ce_getCompilers($sLang = Default, $sInstructionSet = Default)
	Local $sResponse

    With $oHTTP
        .Open("GET", $__g_CE_DOMAIN & "/api/compilers" & (IsKeyword($sInstructionSet) = 1 ? "" : "/" & $sLang), False)
		.SetRequestHeader("Accept", "application/json") ; so that JSON comes back as return type
        .Send()
        $sResponse = .ResponseText
    EndWith

	Local $aCompilers = _JSON_Parse($sResponse)

	; delete all compilers that have the wrong instruction set
	Local $iNew = 0, $mCompiler
	For $i = 0 To UBound($aCompilers) - 1
		$mCompiler = $aCompilers[$i]

		; filter instruction set
		If (Not IsKeyword($sInstructionSet) = 1) And $mCompiler["instructionSet"] <> $sInstructionSet Then ContinueLoop

		; keep entry
		$aCompilers[$iNew] = $aCompilers[$i]
		$iNew += 1
	Next
	Redim $aCompilers[$iNew]

	Return $aCompilers
EndFunc

Alles anzeigen

Damit kannst du direkt aus AutoIt heraus den ASM-Code und auch das Binary von dem godbolt-Server beziehen ohne erst auf deren Seite zu müssen.

**Andy**

Zitat von AspirinJunkie

Ok vielleicht hilft dir ja folgendes Skript ein bisschen:

Ui, DAS ist ja cool...

Zitat von AspirinJunkie

Hm bei mir klappt es noch nicht ganz:

Ja, Verständnisfehler oder von mir nicht richtig/exakt beschrieben:

$bRet = _AssembleIt2("int", "square", "int", $a) aufgerufen mit dem Rückgabedatentyp, "Funktionsnamen" und den Parametern (Parameter wie beim DllCall, jeweils Datentyp und Variable) assembliert den ASM-Code, schreibt ihn in den Speicher, ruft ihn auf und gibt das Ergebnis der Funktion zurück. Der ASM-Code kann mit Debugger (aktuell nur für 32-Bitcode) nachvollzogen werden , Registerinhalte, Stack usw. Der aufgerufene (und assemblierte) ASM-Code läuft nativ auf dem Prozessor, der "Overhead" der _AssembleIt2-Funktion ist nur einige Millisekunden.

_AssembleIt2("retbinary","Funktionsname") gibt den assemblierten Binärcode zurück, den man dann allerdings noch in eine Struct schreiben und aufrufen muss....Diese Funktion ist aktuell unnötig!

Ich habe eine Erweiterung geschrieben, welche einige Zeilen AutoItcode erstellt, mit der dann der ASM-Code direkt per DllCallAddress() aufgerufen werden kann. Dazu werden die Parameter "retbinary",@ScriptlineNumber hinten an die Parameter von AssembleIt angehängt. Damit baut dann AssembleIt den kompletten Aufruf der ASM-binary aus dem Speicher, bsp:

$bRet = _AssembleIt2("int", "square", "int", $a,"retbinary",@ScriptLineNumber)

erzeugt (steht in der Scite Console und im Clipboard):

Local $aStructMem = DllCall("kernel32.dll", "ptr", "VirtualAlloc", "ptr", 0, "ulong_ptr", DllStructGetSize(DllStructCreate("byte[15]")), "dword", 4096, "dword", 64)
Local $tCodeBuffer = DllStructCreate("byte[15]", Number($aStructMem[0])) ;Address aligned 64 and Memory is $MEM_COMMIT, $PAGE_EXECUTE_READWRITE
DllStructSetData($tCodeBuffer, 1,"0x554889E5894DFC8B45FC0FAFC05DC3") ;write opcodes into memory
$ret=DllCallAddress("int:cdecl", DllStructGetPtr($tCodeBuffer), "int", $a)

und ersetzt dann

$bRet = _AssembleIt2("int", "square", "int", $a)

womit #include <assembleit2_64.au3> überflüssig wird

Hier dein Beispiel (habe deine Fragen kommentiert/beantwortet)

Code

#include <assembleit2_64.au3>
#AutoIt3Wrapper_UseX64=y


#cs square

		use64
		push    rbp
        mov     rbp, rsp
        mov     DWORD [rbp-4], ecx
        mov     eax, DWORD [rbp-4]
        imul    eax, eax
        pop     rbp
        ret

#ce square

; ist das die Größe des 1. Parameters in Bytes?
$a=4
;nein, das ist der Parameter, der Integer der quadriert werden soll

; ASM-Code ausführen
$bRet = _AssembleIt2("int", "square", "int", $a)  ; was macht das a?!
;das $a ist der Parameter, der Integer, der quadriert werden soll
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $bRet = ' & $bRet & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console

;erstellt das binary der Funktion "square"....nur noch in Ausnahmefällen nötig, da....
$binary = _AssembleIt2("retbinary","square")
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $binary = ' & $binary & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console

;....mit
$bRet = _AssembleIt2("int", "square", "int", $a,"retbinary",@ScriptLineNumber)
;erzeugt wird: (s. Console und Clipboard), damit #include <assembleit2_64.au3> überflüssig wird

Local $aStructMem = DllCall("kernel32.dll", "ptr", "VirtualAlloc", "ptr", 0, "ulong_ptr", DllStructGetSize(DllStructCreate("byte[15]")), "dword", 4096, "dword", 64)
Local $tCodeBuffer = DllStructCreate("byte[15]", Number($aStructMem[0]))  ;Address aligned 64 and Memory is  $MEM_COMMIT, $PAGE_EXECUTE_READWRITE
DllStructSetData($tCodeBuffer, 1,"0x554889E5894DFC8B45FC0FAFC05DC3") ;write opcodes into memory
$ret=DllCallAddress("int:cdecl", DllStructGetPtr($tCodeBuffer), "int", $a)

_arraydisplay($ret); da DllCallAddress() ein Array zurückgibt

;15 quadrieren
$ret=DllCallAddress("int:cdecl", DllStructGetPtr($tCodeBuffer), "int", 15)
_arraydisplay($ret)

Alles anzeigen

Noch etwas zum Verständnis:

Im 64-Bit-Modus ist eine 64 Bytes aligned Speicheradresse zwingend notwendig, um die in den Speicher geschriebenen Opcodes auszuführen.

DllStructcreate() richtet nur 4 Byte aligned aus, für den 32-Bit-Modus reicht das, bei 64-Bit-Modus nicht....daher der Umweg über VirtualAlloc. In AssembleIt gibt es eine Funktion _DllStructCreate64(), die exakt dafür vorgesehen ist. Im 32-Bit-Modus schadet das 64-Bit align auch nicht....gerade im Gegenteil, Zugriff auf aligned Daten führt idR zu schnellerem Code.