| |
|
|
GDL | Hallo Frank,
möchte doch in XPIA einiges realisieren.Mit den Grundversionen komme ich dank deiner Beispiele langsam klar. Bräuchte aber bei den Arrays noch hilfe. Möchtest du mir bitte dies als Beispiel übersetzen?
num%=0 whilenot num% > 100 A%[num%]=num%+1 1feldarray B%[num%,num%+1]=num%+3 2feldarray inc num% wend
Die Schleife bekomme ich ja hin, aber wie lege ich die Arrays an? Und wie bekomme ich die Arrays wieder nach Profan zurück?
Servus Georg |
|
|
| |
|
|
|
Frank Abbing | Hallo Georg,
Assembler bietet von Haus aus keine Unterstützung für Arrays an. Wenn man aber bedenkt, dass Arrays auch nur Speicherbereiche sind, in denen die Daten hintereinander gespeichert stehen, ist die Lösung simpel. Behandle Arrays einfach wie Bereiche wobei du aber beachten musst, dass Word-Arrays wie z.B. spielfeld%[0,0] 4 Bytes pro Eintrag benötigen, genauso wie Long-Arrays, z.B. spielfeld&[0,0]. Ein mit >Declare spielfeld%[2,2]< geschaffenes Array benötigt also 3x * 3y *4 Bytes = 36 Bytes.
Um bei meinem Beispiel zu bleiben: KompilierenMarkierenSeparierenDeclare feld%[2,2]
feld%[0,0] = 1 : feld%[1,0] = 2 : feld%[2,0] = 3
feld%[0,1] = 4 : feld%[1,1] = 5 : feld%[2,1] = 6
feld%[0,2] = 7 : feld%[1,2] = 8 : feld%[2,2] = 9
Im Speicher steht das Array jetzt folgendermassen:
[box:c9f0d92ac8]7FD30010 : 01 00 00 00 - 02 00 00 00 - 03 00 00 00 - 04 00 00 00 7FD30020 : 05 00 00 00 - 06 00 00 00 - 07 00 00 00 - 08 00 00 00 7FD30030 : 09 00 00 00 00000036 : BYTES TOTAL[/box:c9f0d92ac8] [hr:c9f0d92ac8] So, um deinen Code umzusetzen, übergibts du zuerst einmal die Adresse der Arrays an die Assemblerroutine und manipulierst die Werte direkt im Speicher. Der Anfang zur Konvertierung wäre also:
AsmStart FillArrays(addr(a%[0]),addr(b%[0,0]))
In para1 steht jetzt die Adresse von Array a% und in para2 steht die Adresse von Array b%
Jetzt kannst du die Werte in den Speicher schreiben. Versuch mal, ob du die Konvertierung jetzt schon selber hinbekommst. |
|
|
| |
|
|
|
GDL | Hallo Frank,
Komme mit dem Speicher nicht klar, aber mit dem Beispiel aus dem Kurs müsste es auch gehen. AsmStart Arrays Parameters adresse1&,wert1&,adresse2&,wert2& jmp @f data dd 0,0,0,0,0,0,0,0,0,0,0,0 ;Datenbereich(muss so gross wie die arraydeclare sein) @f: mov ebx,para1 mov eax,para2 mov ecx,para3 mov edx,para4 lea esi,data mov [esi+ebx],eax;Wert1 schreiben mov [esi+ecx],edx;Wert2 schreiben
AsmEnd |
|
|
| |
|
|
|
Frank Abbing | Georg, lass uns bei deinem ersten Code bleiben und nicht alles durcheinander werfen. Du möchtest also das hier umgesetzt bekommen? KompilierenMarkierenSeparieren {$iq}
Declare num%,a%[101],b%[101,101],x&,y&
num%=0
whilenot num% > 100
A%[num%]=num%+1 1feldarray
B%[num%,num%+1]=num%+3 2feldarray
Print a%[num%],b%[num%,num%+1]
inc num%
wend
AsmStart ShowMe(addr(a%[0]),addr(b%[0,0]))
PrintDec para2
DumpMem para1,400
DumpMem para2,800
AsmEnd
Print "Fertig."
WaitInput
End
|
|
|
| |
|
|
|
Frank Abbing | So, hier hast du beide Versionen des gleichen Codes. Der Assemblercode ist nicht optimiert, damit die Arbeitsweise besser verständlich wird: KompilierenMarkierenSeparieren!{$iq}
Declare num%,a%[101],b%[101,101],x&,y&
*** Profanversion
num%=0
whilenot num% > 100
A%[num%]=num%+1
B%[num%,num%+1]=num%+3
inc num%
wend
*** Assemblerversion
AsmStart FillArray(addr(a%[0]),addr(b%[0,0]))
mov ebx,para1
mov edx,para2
add edx,408
mov ecx,0
.while ecx <=100
inc ecx ;ecx = num%+1
mov [ebx],ecx
add ebx,4 ;Adresse des nächsten Wertes in a%[]
add ecx,2 ;ecx = num%+3
mov [edx],ecx
add edx,412 ;Adresse des nächsten Wertes in b%[,]
sub ecx,3
inc ecx ;Schleifenzähler um eins erhöhen
.endw
AsmEnd
WaitInput
End
Ich empfehle dir bei weiteren Umsetzungen nach Assembler Bereiche zu verwenden. Arrays sind eben nicht sonderlich kompatibel zu Assembler. |
|
|
| |
|
|
|
GDL | Hallo Frank,
erstmal Danke für Dein Beispiel.Aber ich verwende desswegen Arrays, da es wesentlich einfacher ist. Beispiel: Speedausgabe&=standardspeed&[punkt&,lok&] oder neue Standardspeed für Lok& irgendeine Lok für irgendeinen Punkt standardspeed&[punkt&,lok&]=lesewert&
lok&,punkt&,lesewert&=sind immer 8bit breit.
Das erste Quellcodebeispiel war nur ein fiktives Beispiel um die Materie erstmal zu kapieren,also für den Einstieg.
Ich werde es wahrscheinlich mit Data machen.Data nutzt auch Atmelassembler bei seinen Arrays.Bin davon ausgegangen das MASM32 Arrays kann. Werde hier aber weitermachen, da die Geschwindigkeitszuwächse vor allem auf Rechnern unter 800 Mhz enorm sind.(Lies dein Rechenbeispiel laufen).
Muss bei den Data Beispiel Kit auf den Augen gehabt haben.Dieses Beispiel öffnet bei meinem Prog überhaupt gänzlich neue Routinen.
Servus Georg
P.S. Bei deinem Beispiel vermute ich mal dass alles in den Registern ebx und edx abgehandelt wird . Ich muss also immer erst 8 bit breite 0 Werte erzeugen diese dann Auffüllen und am richtigen Platz in dem Bereich kopieren.Und bei Profan hernach bei jedem Arrayersatz selbige Prozedur wieder.Verstehe ich das so richtig? |
|
|
| |
|
|
|
Frank Abbing | Hi.
[quote:7bd08b357f]Aber ich verwende desswegen Arrays, da es wesentlich einfacher ist.[/quote:7bd08b357f] Alles Sache der Gewöhnung. Aber im Grunde hast du recht.
[quote:7bd08b357f]Ich werde es wahrscheinlich mit Data machen.Data nutzt auch Atmelassembler bei seinen Arrays.Bin davon ausgegangen das MASM32 Arrays kann.[/quote:7bd08b357f] Das selbe in grün. Nur erzeugst du in deinem DATA-Beispiel den Speicher mittels MASM32, während in meinem umgesetzen Code Profan den Speicher (in den Fall als Array) zur Verfügung stellt.
[quote:7bd08b357f]P.S. Bei deinem Beispiel vermute ich mal dass alles in den Registern ebx und edx abgehandelt wird . Ich muss also immer erst 8 bit breite 0 Werte erzeugen diese dann Auffüllen und am richtigen Platz in dem Bereich kopieren.Und bei Profan hernach bei jedem Arrayersatz selbige Prozedur wieder.Verstehe ich das so richtig?[/quote:7bd08b357f] Nein. Register mit drei Buchstaben (EAX usw.) arbeiten immer mit 32 Bit... Ich denke nicht, dass du meine Umsetzung verstanden hast. Mein Assemblercode füllt die Profan-Arrays, direkt. Profan übergibt Zeiger auf die Arrays, also die Adressen, in denen die Werte des Arrays im Speicher stehen. Dann schreibt die Assembler-Schleife direkt Werte in die Arrays, sodass sie Profan nach dem Verlassen der Assembler-Routine schon zur Verfügung stehen. Dein DATA-Beispiel nützt in sofern nichts, weil Assembler den Speicher zur Verfügung stellen soll und Profan später nichts davon hat...
Übrigens stellt die MASM32.lib einige Arrayfunktionen zur Verfügung. Da XPIA diese Library eingebunden hat, kannst du sie ohne weiteres benutzen.
arr_add Add an integer to every member of a DWORD array arr_mul Multiply every member of a DWORD array by an integer arr_sub Subtract an integer from every member of a DWORD array create_array Create an array of pointers to a user defined array
Näheres dazu findest du im MASM32-Paket in help/masmlib32.hlp |
|
|
| |
|
|
|
GDL | Hallo Frank,
hast recht,verstehe dies noch nicht ganz.Habe momentan mit der jetztigen Fassung genug Stress.(Hardware erstellen). Kann gesundheitlich nicht mehr so viel. Werde aber drann bleiben, da immer mehr Mitglieder das Prog haben wollen, aber teilweise nur 486DX33 Rechner (Modellbahnrechner halt) haben. Vielleicht könnten wir uns mal unter Skype unterhalten, wenn du möchtest?
Servus Georg |
|
|
| |
|
|
|
Frank Abbing | Natürlich, gerne. Du findest mich dort unter dem Namen grasshopper64 |
|
|
| |
|
|
|
Michael Wodrich | Hmm, , Im Herbst nicht mehr im Gras unterwegs? |
|
|
| Programmieren, das spannendste Detektivspiel der Welt. | 18.10.2006 ▲ |
|
|
|
|
GDL | Hallo Frank,
bekomme es wie im ersten Antwortposting nicht auf die Reihe.Habe aber in einer Kopie von betrieb angefangen mittels Data zu arbeiten und den Rückgabewert dann in Profan ins Array zu schreiben.Funzt auch. Habe jetzt ein kleines Warmstartprogramm vorweg dass die Festplattenwerte in die Datapositionen schreibt.In Zusammenarbeit mit meiner RAMdisk wesentlich schneller als vorher. Zwar nicht der Königsweg, aber es geht versuchsweise schon ganz gut.GDL eben.
Servus Georg |
|
|
| |
|
|
|
Frank Abbing | Wenns läuft. Bei der Rückschau auf ältere Code von mir bemerke ich auch oft, dass ich manches heute anders lösen würde. Man lernt eben immer dazu, und genauso wird es dir auch ergehen, wenn du deinen Code in 2-3 Jahren ansiehst. |
|
|
| |
|
|