XProfan

- page 1 -

Ablaufzeiten (Brutto)qui Collisionsabfrage des Rechteckes 128X128X4 avec 10000 Schleifendurchgänge :
calculateur avec 1,6 Gigahz

qui Profan Tandis que-Leerschleife braucht ca 200ms.

ASM avec XPIA/XPSE (DLL) sommes es 4550 ms .

DEV C++ sommes es 6210 ms ( une For-Boucle).

DEV C++ sommes es 6260 ms (Tandis que-Boucle).

chez 10000 durchgängen lohnt es sich cet dans ASM umzusetzen, sommes ca 1,5 sec unterschied.

mfg
peter

Frank
Abbing

Votre Assembler-Routine ist pas optimiert. si du vous umstellst de Variablen sur Register ist encore einiges plus drin. Ca. 20 Prozent, schätze je.

cet Routine behält deine Programmstruktur chez, sollte mais déjà travailler plus vite:
Kompilieren Marque Séparation

If 0

    AsmStart rgb_farbe (ogl_rgbxy#,groesse%)

        mov edi,para2
        xor ecx,ecx
        mov ebx,para1

        .while ecx<=edi

            mov al,[ebx]
            mov cl,[ebx+1]
            mov dl,[ebx+2]

            .if al>252

                mov eax,255
                .break

            .endif

            .if cl>252

                mov eax,255
                .break

            .endif

            .if dl>252

                mov eax,255
                .break

            .endif

            lea ebx,[ebx+4]
            lea ecx,[ecx+4]

        .endw

    AsmEnd(z%)

EndIf

Jörg
Sellmeyer

qui Profan Tandis que-Boucle braucht ca 200ms.

es Du sûrement, qui Profan plus que 20-la fois plus rapide ist comme ASM?

Windows XP SP2 XProfan X4
... und hier mal was ganz anderes als Profan ...

Soll vide-Boucle heissen, weil je entier dessus aussi de Brutto spreche.
qui Test fonctionne chez allen dans qui gleichen Tandis que-Boucle de Profan

j'ai aussi la fois cet Freebasic getestet zum DLL erstellen.

qui dans Freebasic une DLL erstellen voudrais et ne...aucune ASM peux/voudrais et ne...aucune "C", ist avec cela bien bedient.

qui Freebasic-DLL braucht 7400ms alors seulement 1 seconde länger comme DEV C++.

Könnte pour qui Basicprogrammierer , qui une DLL erstellen serait einer qui besten Freewarealternativen son.

chez meiner Collisionstest-Auswertung avec qui Freebasic-DLL sur dem Bildschirm à qui Grafik, c'est moi qui Unterschied optique pas aufgefallen. cela objet flitzte weiterhin toujours hin et her trotz qui Überprüfung/Auswertung.

mfg
peter

Frank, deine braucht 3,5 sekunden länger.

je weiss eh bien pas, comment cela avec den Registern et LEA là funktioniert.
sur jeden le cas muss qui Adresse toujours um "4" continuer.

mfg
peter

Frank
Abbing

Frank, deine braucht 3,5 sekunden länger.

Unrichtig! Register travailler toujours plus rapide comme Varablen im grenier, selbst si vous bistrot sommes. Solche Tests habe je déjà Dutzende durchgeführt.
et so une Assemblerroutine nécessaire niemals 3,5 Sekunden länger, vous nécessaire überhaupt seulement wenige Millisekunden en tout. Selbst si du avec grossen Bitmaps arbeitest. tu peux cela volontiers avec qui ProSpeed.dll testen, qui zahlreiche Bitmapeffekte kennt. Irgendwas allez chez deinen Tests gewaltig de travers.
quoi oui c'est ca soll qui Routine car faire? vous bricht doch tout de suite ab, si vous une très hellen Farbwert findet. si du une Robotersoftware écrivons veux, qui qui données einer Cam auswertet, musst du déjà le nombre heller Bildpunkte zählen. auparavant mais cela Cambild gris faire, bzw. noir-weiss.

- page 2 -

encore suis je pas beim Roboterbild, cela hat encore zeit. je voudrais seulement einmal qui schnellsten Routinen trouver pour qui Bildauswertung im zusammenhang avec OpenGL et en représentation.
Befinde mich encore dans qui Anfangsstufe weil je cela Profan seulement avant 3 Wochen kennengelernt habe.
là cela ASM avec en supplément venez hat sich qui Lernumfang geändert.
et habe nebenbei déjà gentille erkenntnisse avec Getdibits , Setdibits usw gesammelt.

ici qui Code pour qui Laufzeiten testen :
Kompilieren Marque Séparation

DEF rgb_farbe_asm(2) ! "ogl-asm-test.dll","rgb_farbe"
DEF rgb_farbe_asm_o(2) ! "ogl-asm-test.dll","rgb_farbe_o"
declare bildxy# ,ogl_rgb#,x&,y&,z%
var groesse%=128*128*4
dim bildxy#,groesse%,z%
dim ogl_rgb#,groesse%
x&=10000
Print "Bereich mit 0 füllen"

whileloop 0,groesse%-1

    byte ogl_rgb#,&loop=0

endwhile

Print "rgb_farbe-asm"
y&=&GetTickCount

Whileloop x&

    z%=rgb_farbe_asm(ogl_rgb#,groesse%)

EndWhile

y&=&GetTickCount-y&
Print "Fertig in "+Str$(y&)+" Millisekunden."
Print "while-schleife"
y&=&GetTickCount

Whileloop x&

EndWhile

y&=&GetTickCount-y&
Print "Fertig in "+Str$(y&)+" Millisekunden."
Print "rgb_farbe-asm_o"
y&=&GetTickCount

Whileloop x&

    z%=rgb_farbe_asm_o(ogl_rgb#,groesse%)

EndWhile

y&=&GetTickCount-y&
Print "Fertig in "+Str$(y&)+" Millisekunden."
WaitInput
Fin

et ici qui ASM-Code , woraus je une DLL erstellt avec XPIA/XPSE
Kompilieren Marque Séparation

AsmStart rgb_farbe_o (ogl_rgbxy#,groesse%)

    mov edi,para2
    xor ecx,ecx
    mov ebx,para1

    .tandis que ecx<=edi

        mov al,[ebx]
        mov cl,[ebx+1]
        mov dl,[ebx+2]

        .si al>252

            mov eax,255
            .pause

        .endif

        .si cl>252

            mov eax,255
            .pause

        .endif

        .si dl>252

            mov eax,255
            .pause

        .endif

        lea ebx,[ebx+4]
        lea ecx,[ecx+4]

    .endw

AsmEnd(z%)

AsmStart rgb_farbe

    Paramètres ogl_rgbxy#,groesse%
    LOCAL r :BYTE
    LOCAL g :BYTE
    LOCAL b :BYTE
    LOCAL n :DWORD
    mov eax,para2
    mov n,eax
    mov ecx,0
    mov ebx,para1

    .tandis que ecx<=n

        mov al,[ebx+ecx]
        mov r,al
        mov al,[ebx+ecx+1]
        mov g,al
        mov al,[ebx+ecx+2]
        mov b,al
        mov al,b

        .si al>252

            mov eax,255
            .pause

        .endif

        mov al,g

        .si al>252

            mov eax,255
            .pause

        .endif

        mov al,r

        .si al>252

            mov eax,255
            .pause

        .endif

        add ecx,4

    .endw

AsmEnd(z%)

Frank
Abbing

Peter, du musst y& pour deiner ersten Zeitmessung aussi wieder zurücksetzten...

Ausserdem misst du pas qui Geschwindigkeit qui Assemblerroutine, mais qui la durée eines Dll-Aufrufs. Wobei du qui Dll nichtmal dans den grenier lädts.

mon Messungen bestätigen mon Aussage de heut l'après-midi. Votre Routine nécessaire pour qui Boucle 344 Millisekunden, si je cet Hundert Millionen(!) fois par lasse. mon Routine nécessaire pour qui gleiche Schleifenanzahl 172 Millisekunden. c'est exakt doppelt so vite!

ici qui simple Testroutine, chez qui du jederzeit meinen Code vers deinen austauschen peux zum Testen:
Kompilieren Marque Séparation

 {$cleq}
declare ogl_rgb#,y&
var groesse%=100000000
dim ogl_rgb#,groesse%
cls
Sleep 3000
y&=&GetTickCount

AsmStart rgb_farbe (ogl_rgb#,groesse%)

    mov edi,para2
    xor ecx,ecx
    mov ebx,para1

    .while ecx<=edi

        mov al,[ebx]
        mov cl,[ebx+1]
        mov dl,[ebx+2]

        .if al>252

            mov eax,255
            .break

        .endif

        .if cl>252

            mov eax,255
            .break

        .endif

        .if dl>252

            mov eax,255
            .break

        .endif

        lea ebx,[ebx+4]
        lea ecx,[ecx+4]

    .endw

AsmEnd(z%)

Print Str$(Int(&GetTickCount-y&))
WaitInput
dispose ogl_rgb#
/../funcion-referencias/XProfan/end/'>Fin

Sei dans Zukunft vorsichtiger avec deinen Behauptungen. je voudrais pas, dass de meiner Software et de Assembler überhaupt un falsches Bild entsteht, seulement weil du fehlerhafte Aussagen verbreitest aufgrund deiner fehlerhaften Testverfahren et Codes.

qui 1. Zeit ca 4000ms

qui 2. Zeit ca 200ms

qui 3. Zeit ca 8000ms

cet Testprogramm ist aus diesem Forum.
on muss toujours mißtrauischer volonté, traue aucun Fremden Programme.
j'ai so quelque chose déjà geahnt.

j'ai mir fois le Taktcyklen herausgesucht et umgerechnet. je viens presque sur deine Zeit.
So quelque chose schärft den Geist, mais quand même scheiss travail.

pouvoir toujours wieder Spass.

c'est Programmieren. Hoch lebe qui eigene Überprüfung.

So maintenant vas zum prochain Thema....., und dir plus Jungs et Mädels.

mfg

Frank
Abbing

exposition dir meinen Code doch à.
Du misst den Dll-Aufruf, cela hat avec Assemblergeschwindigkeit rein gar pas trop 1faire.

quoi misstrauisch? XPIA ist mon Programme.

Kompilieren Marque Séparation

Frank tu es Super.
aussi cet fonctionne avec deiner Messung et deinem ASM-Vorschlag seulement knapp 300ms. c'est doch quoi. Super l'affaire. là était qui Wurm drin.

Habe es avec einer FreeBasic-DLL getestet, braucht 532ms.
peux alors hochgerechnet ca pro seconde 93 Bilder auswerten avec 128*128*4 Pixel chez une Framerate de 30 bzw peux chez 970ms ca 53 BMP-Texturen einlesen.
Kompilieren Marque Séparation

EXTERN "windows-ms"
FUNCTION rgb_farbe( adr AS ANY PTR ,ByVal wert As uinteger) AS INTEGER EXPORT
DIM i AS UInteger,n As UInteger
Dim b As Ubyte,g As Ubyte,r As UByte,a As UByte
FOR i = 0 TO wert Step 4
b=Peek(BYTE, adr+i )
g=Peek(Byte,adr+i+1)
r=Peek(Byte,adr+i+2)

If (b>252) Or (g>252) Or (r>252) Then

    a=255
    Exit for

EndIf

NEXT
Return a
END Function
function bmptex ( adr AS ANY PTR ,ByVal wert As uinteger) AS INTEGER EXPORT
DIM i AS UInteger,n As UInteger
Dim b As ubyte,g As ubyte,r As UByte
FOR i = 0 TO wert Step 4
b=Peek(BYTE, adr+i ) And 255
g=Peek(Byte,adr+i+1) And 255
r=Peek(Byte,adr+i+2) And 255

If (r=0) and (b=0) and (g=0) Then

    Poke Byte,adr+i+3,0

Else

    Poke Byte,adr+i+3,255

EndIf

Poke Byte,adr+i+2,b
Poke Byte,adr+i,r
NEXT
END function
END Extern

DEF rgb_farbe(2) !"ogl-dll.dll","rgb_farbe"
declare ogl_rgb#,y&,z%
var groesse%=100000000
dim ogl_rgb#,groesse%
cls
Sleep 1000
imprimer "test"
y&=&GetTickCount
z%=rgb_farbe(ogl_rgb#,groesse%)
Imprimer Str$(Int(&GetTickCount-y&))
WaitInput
dispose ogl_rgb#
Fin