[gelöst] PureBasic nach (Inline -)FASM (Prozentrechnen)

[ccode_new]

@Mijikai:

Ja so ist es besser!

So kann man auch unter Linux etwas damit anfangen.

Aber deine ASM-Funktion ist trotzdem langsamer als die "normale" Variante.

Kann man da noch optimieren?

[Mijikai]

...
Kann man da noch optimieren?

Ja, der Code der reinen Purebasic Funktion z.B.
läd den Float Wert direkt ohne ihn umwandeln zu müssen fdiv
ist zudem schneller als fdivp da fdivp den stack manipuliert.

Was noch alles möglich ist kann ich nicht sagen

Das sind meine ersten Gehversuche mit der FPU

[ccode_new]

Ach noch etwas:

Ich habe die Procedure "Processed" (Also die "Normale") und die Procedure "ASM_Processed" mal mit ElapsedMilliseconds() und einer laaangen FOR-Schleife getestet.

Dabei sind mir zwei Dinge aufgefallen:

1. Die Proceduren sind "fast" gleich schnell. (Die "normale" ist bei mir nur 1ms schneller als die Assemblervariante)

2. Es kommt bei der Assemblervariante zu einem Bug.

Ich habe mal folgende Beispielwerte getestet:

Code: Alles auswählen

go1 = ElapsedMilliseconds()

For i = 0 To 10000
  Debug ASM_Processed(10,20)
Next i

Debug ElapsedMilliseconds() - go1

Ab dem 7. Durchlauf liefert nur die Assembler-Variante einen Bug.

Hier der Debug:
200
200
200
200
200
200
-9223372036854775808
-9223372036854775808
...und so weiter

[Mijikai]

Wahrscheinlich ein Problem mit dem Stack durch 'fld st1'.

Tritt der Fehler auch damit auf?

Code: Alles auswählen

Procedure.i ASM_Processed(Bytes.i,BytesProcessed.i)
  !fild qword[p.v_Bytes]
  !mov qword[p.v_Bytes],64h
  !fild qword[p.v_Bytes]
  !fdivp
  ;...
  !fistp qword[p.v_Bytes]
  !mov rax,[p.v_Bytes]
  ProcedureReturn
EndProcedure

[ccode_new]

Ähm Nö!
So tritt der Fehler nicht auf, aber die "Procedure" liefert aber auch nur "0" als Rückgabewert.

Can you find the error?

[Mijikai]

Neue Version

Code: Alles auswählen

Procedure.i ASM_Processed(Bytes.i,BytesProcessed.i)
  !fild qword[p.v_Bytes]
  !fdiv dword[_FLT]
  !fstp qword[p.v_Bytes]
  !fild qword[p.v_BytesProcessed]
  !fdiv qword[p.v_Bytes]
  !fistp qword[p.v_Bytes]
  !mov rax,[p.v_Bytes]
  ProcedureReturn
  !_FLT:
  !dd 42C80000h
EndProcedure

[ccode_new]

Cool!
So funktioniert die Prozedur.

Aber die Funktion ist trotzdem bei mir noch 1 bis 3 ms langsamer als die "normale" Variante.

Mmmh, eigentlich sind beide Varianten eben fast gleich schnell. (Manchmal sogar gleich schnell im ms-Bereich)

Also müsste die "Procedure" noch weiter optimiert werden.

[Mijikai]

Bei mir ist die Inline Variante schneller.

Testcode:

Code: Alles auswählen

Procedure.i Processed(Bytes.i,BytesProccessed)
  Protected Factor.f = Bytes / 100
  ProcedureReturn BytesProccessed / Factor
EndProcedure

Procedure.i ASM_Processed(Bytes.i,BytesProcessed.i)
  !fild qword[p.v_Bytes]
  !fdiv dword[_FLT]
  !fstp qword[p.v_Bytes]
  !fild qword[p.v_BytesProcessed]
  !fdiv qword[p.v_Bytes]
  !fistp qword[p.v_Bytes]
  !mov rax,[p.v_Bytes]
  ProcedureReturn
  !_FLT:
  !dd 42C80000h
EndProcedure

sequence = 10000000

start1 = ElapsedMilliseconds()            
For t = 1 To sequence
  ASM_Processed(500,33)
Next 
end1 = ElapsedMilliseconds() - start1

start2 = ElapsedMilliseconds()            
For t = 1 To sequence
  Processed(500,33)
Next 
end2 = ElapsedMilliseconds() - start2

MessageRequester("Ergebnis","Inline: " + StrF(end1) +" ms" + Chr(13) + "PureBasic: " + StrF(end2) +" ms")

[ccode_new]

Mmmh ich revidiere meine Aussage.
Die Inline-Variante ist doch "etwas" schneller.

Wie groß ist die Differenz bei dir ?

Bei mir max. 300 ms. (Debugger) (Inline is the winner )

->max. 7 ms (ohne Debugger) (nach 20 Versuchen)

[Mijikai]

Die Inline Variante ist bei mir mit Debugger ca. 200 ms schneller
und ohne ca. 10 ms schneller.