PureBoard

Das deutsche PureBasic-Forum
https://www.purebasic.fr/german/

Speicherbereich umdrehen

https://www.purebasic.fr/german/viewtopic.php?t=3726

Seite 1 von 3

Speicherbereich umdrehen

Verfasst: 17.06.2005 18:35
von Franky
Hi, hab mir gerade ne funktion geschrieben und gemerkt, dass ich sie garnicht gebrauche.


wie gesagt, hiermit dreht man einfach nen speicherbereich um
123456789 wird zu
987654321

Code: Alles auswählen

Procedure TurnArrayL(buffer.l,laenge.l)
           MOV Eax,buffer
           MOV Ebx,buffer
           ADD Ebx,laenge
            TA_begin:
                        MOV Ecx, dword[Ebx]
                        XCHG dword[Eax], Ecx
                        MOV dword[Ebx], Ecx
                       ADD Eax,4 
                       SUB Ebx,4
            CMP Eax,Ebx
            JBE l_ta_begin          
EndProcedure
Es ist nix besonderes, aber vielleicht braucht es wer

Danke für die kleine Syntaxhilfe an Deeem

Achja, wenn wer ne schnellere Version weiß, bitte melden, man is ja immer gewillt, zu lernen ;)

Verfasst: 17.06.2005 21:59
von remi_meier
Nicht optimal, aber vielleicht regts an :)
2.6x schneller:

Code: Alles auswählen

Procedure TurnArrayL2(buffer.l,laenge.l) 
  MOV Eax,buffer 
  MOV Ebx,buffer 
  ADD Ebx,laenge 
  TA_begin2: 
    MOV Ecx, dword[Ebx] 
    MOV Edx, dword[Eax]
    MOV dword[Eax], Ecx
    MOV dword[Ebx], Edx 
    ADD Eax,  4
    ADD Ebx, -4
    CMP Eax, Ebx
  JBE l_ta_begin2          
EndProcedure
Kurz: XCHG ist lahm für Memory-Register
Während mit XCHG 7 Clocks benötigt werden, sind es mit 4 Movs nur 4.

greetz
Remi

Verfasst: 18.06.2005 16:09
von Deeem2031
Und die ganze Schleife dann noch ein bischen optimiert:

Code: Alles auswählen

Procedure TurnArrayL2(Buffer.l,laenge.l) 
  MOV Eax, Buffer 
  XOR Esi, Esi
  MOV Ebx, laenge
  SHR Ebx, 2
  TA_begin2: 
    MOV Ecx, dword[Eax+Ebx*4]
    MOV dword[Eax+Esi*4], Ecx 
    MOV Ecx, dword[Eax+Esi*4] 
    MOV dword[Eax+Ebx*4], Ecx 
    INC Esi
    DEC Ebx
    CMP Esi, Ebx
  JA byte l_ta_end
    MOV Ecx, dword[Eax+Ebx*4]
    MOV dword[Eax+Esi*4], Ecx 
    MOV Ecx, dword[Eax+Esi*4] 
    MOV dword[Eax+Ebx*4], Ecx 
    INC Esi
    DEC Ebx
    CMP Esi, Ebx
  JA byte l_ta_end
    MOV Ecx, dword[Eax+Ebx*4]
    MOV dword[Eax+Esi*4], Ecx 
    MOV Ecx, dword[Eax+Esi*4] 
    MOV dword[Eax+Ebx*4], Ecx 
    INC Esi
    DEC Ebx
    CMP Esi, Ebx
  JA byte l_ta_end
    MOV Ecx, dword[Eax+Ebx*4]
    MOV dword[Eax+Esi*4], Ecx 
    MOV Ecx, dword[Eax+Esi*4] 
    MOV dword[Eax+Ebx*4], Ecx 
    INC Esi
    DEC Ebx
    CMP Esi, Ebx
  JBE l_ta_begin2
    
  TA_End:
  ProcedureReturn
EndProcedure
Habs allerdings nicht getestet...

Verfasst: 18.06.2005 16:40
von NicTheQuick
Laut Testprogramm liegt Deeem2031 bei einem Speicherbuffer der Größe 10.000.000 Bytes mit 1000 Umkehrungen mit 40779 Millisekunden vor remi_meier mit 41229 ms.

Verfasst: 18.06.2005 17:00
von Franky
Hm, interessant :)
Gibt es eigentlich ein schönes Nachschlagewerk, wo genau steht, welche funktion am meisten optimiert, was welche operation genau macht und braucht und so? Also, besonders, was am meisten optimiert ist, würde mich interessieren, den rest kann ich ja inner ASM-Hilfe nachschlagen

Verfasst: 18.06.2005 19:44
von remi_meier
@Deem:
Aso mit dem 'byte' in 'JA byte l_ta_end' gibts bei mir ein 'relative jump out
of range', ohne gehts.
Das Lustige ist nur, genau den gleichen Ansatz hatte ich auch, bevor ich
mein Ding gepostet habe, es lief irgendwie nicht. Ist aber fast schade, dass
das nur so wenig Geschwindigkeit bringt..

@Franky:
In fast jeder Asm-Befehlsreferenz steht unten in einer Tabelle, wie lange
der Befehl zum ausführen braucht.

EDIT: Deem, es scheint dein Code hätte nen Fehler...
Er kehrt nicht vollständig um (bei mir), schau nochmals nach ;-)

Verfasst: 18.06.2005 22:32
von Deeem2031
remi_meier hat geschrieben:@Deeem:
Aso mit dem 'byte' in 'JA byte l_ta_end' gibts bei mir ein 'relative jump out
of range', ohne gehts.
Dann hattest du warscheinlich den Debugger an. Das "byte" war aber auch nur zum testen ob relative jumps benutzt werden, kann man also auch löschen.
remi_meier hat geschrieben:EDIT: Deeem, es scheint dein Code hätte nen Fehler...
Er kehrt nicht vollständig um (bei mir), schau nochmals nach ;-)

Der Code sollte funktionieren. Hab auch noch einen weiteren Versuch dazu gepackt, allerdings ist der nicht schneller.

Code: Alles auswählen

Procedure TurnArrayL2(Buffer.l,laenge.l) 
  MOV Eax, Buffer 
  XOR Esi, Esi 
  MOV Ebx, laenge 
  SHR Ebx, 2
  TA2_begin2: 
  MOV Ecx, dword[Eax+(Ebx-1)*4] 
  MOV Edx, dword[Eax+Esi*4] 
  MOV dword[Eax+Esi*4], Ecx 
  MOV dword[Eax+(Ebx-1)*4], Edx 
  INC Esi 
  DEC Ebx 
  CMP Esi, Ebx 
  JA byte l_ta2_end 
  MOV Ecx, dword[Eax+(Ebx-1)*4] 
  MOV Edx, dword[Eax+Esi*4] 
  MOV dword[Eax+Esi*4], Ecx 
  MOV dword[Eax+(Ebx-1)*4], Edx 
  INC Esi 
  DEC Ebx 
  CMP Esi, Ebx 
  JA byte l_ta2_end 
  MOV Ecx, dword[Eax+(Ebx-1)*4] 
  MOV Edx, dword[Eax+Esi*4] 
  MOV dword[Eax+Esi*4], Ecx 
  MOV dword[Eax+(Ebx-1)*4], Edx 
  INC Esi 
  DEC Ebx 
  CMP Esi, Ebx 
  JA byte l_ta2_end 
  MOV Ecx, dword[Eax+(Ebx-1)*4] 
  MOV Edx, dword[Eax+Esi*4] 
  MOV dword[Eax+Esi*4], Ecx 
  MOV dword[Eax+(Ebx-1)*4], Edx 
  INC Esi 
  DEC Ebx 
  CMP Esi, Ebx 
  JBE l_ta2_begin2 
  
  TA2_End: 
  ProcedureReturn 
EndProcedure

Procedure TurnArrayL3(Buffer.l,laenge.l) 
  MOV Eax, Buffer 
  MOV Edi, laenge
  SUB Edi, 4
  ADD Edi, Eax
  XCHG Edi, Esp
  
  TA3_begin2: 
  MOV Ecx, dword[Esp]
  MOV Edx, dword[Eax]
  PUSH Edx
  MOV dword[Eax], Ecx
  ADD Eax, 4
  CMP Eax, Esp
  JA byte l_ta3_end 
  
  MOV Ecx, dword[Esp]
  MOV Edx, dword[Eax]
  PUSH Edx
  MOV dword[Eax], Ecx
  ADD Eax, 4
  CMP Eax, Esp
  JA byte l_ta3_end 
  
  MOV Ecx, dword[Esp]
  MOV Edx, dword[Eax]
  PUSH Edx
  MOV dword[Eax], Ecx
  ADD Eax, 4
  CMP Eax, Esp
  JA byte l_ta3_end 
  
  MOV Ecx, dword[Esp]
  MOV Edx, dword[Eax]
  PUSH Edx
  MOV dword[Eax], Ecx
  ADD Eax, 4
  CMP Eax, Esp
  JBE l_ta3_begin2 
  
  TA3_End: 
  
  MOV Esp, Edi
  ProcedureReturn 
EndProcedure

Verfasst: 19.06.2005 06:53
von Helle
Vorschlag auf die Schnelle; nicht getestet:

Code: Alles auswählen

Procedure TurnArrayL4(buffer.l,laenge.l) 

    MOV esi,buffer
    MOV edi,esi
    ADD edi,laenge        ;korrekt laenge-4
weiter: 
    CLD 
    !LODSD 
    MOV edx,[edi]
    STD
    !STOSD
    MOV [esi-4],edx
    CMP esi,edi
    JB l_weiter

EndProcedure
Gruss
Helle

Verfasst: 19.06.2005 10:19
von Sylvia
@Helle:
so in etwa hätte ich es auch gemacht... :mrgreen:

Übrigens...hat dein Chess schon ein paar Baustellen weniger ? Schick mir
bitte mal deine neueste Version. Macht einen leistungsfähigen Eindruck,
aber der Code...ganz schön anstrengend; streckenweise fehlt mir völlig
der Durchblick. <)

Verfasst: 19.06.2005 13:05
von NicTheQuick
@Helle

Deine Procedure funktioniert bei mir aber nicht:

Code: Alles auswählen

Procedure TurnArrayL4(buffer.l,laenge.l)
  MOV esi,buffer
  MOV edi,esi
  ADD edi,laenge        ;korrekt laenge-4
  weiter:
    CLD
    !LODSD
    MOV Edx,[edi]
    STD
    !STOSD
    MOV [esi-4],Edx
    CMP esi,edi
  JB l_weiter
EndProcedure

Procedure TurnArrayL(buffer.l,laenge.l)
  MOV Eax,buffer
  MOV Ebx,buffer
  ADD Ebx,laenge
  TA_begin:
    MOV Ecx, dword[Ebx]
    XCHG dword[Eax], Ecx
    MOV dword[Ebx], Ecx
    ADD Eax,4
    SUB Ebx,4
    CMP Eax,Ebx
  JBE l_ta_begin
EndProcedure

Size = 1000000

*mem = AllocateMemory(Size)
For a.l = 0 To Size - 1 Step 4
  PokeL(*mem + a, a)
Next

time1 = ElapsedMilliseconds()
  For b.l = 1 To 100
    TurnArrayL(*mem, Size)
  Next
time1 = ElapsedMilliseconds() - time1

time2 = ElapsedMilliseconds()
  For b   = 1 To 100
    TurnArrayL4(*mem, Size)
  Next
time2 = ElapsedMilliseconds() - time2

MessageRequester("Zeiten", Str(time1) + #CRLF$ + Str(time2))
Alle Zeiten sind UTC+02:00
Seite 1 von 3

Powered by phpBB® Forum Software © phpBB Limited

Deutsche Übersetzung durch phpBB.de