DOS-Forum

zatzen hat geschrieben:Danke!

Wenn man die Architektur ein wenig versteht, ist Assembler die logischste und
einfachste "Sprache" überhaupt...

zatzen hat geschrieben:Ich frag mich nur ob es da nicht Einbußen mit der Geschwindkeit gibt, d.h. wenn man auf eine einzelne Variable zugreifen will, ob das dann wirklich genauso schnell ist als wenn man einfach auf ein normales Array zugreift? Du schriebst mal sowas, dass Units Sachen zwar modular und übersichtlich machen, aber u.U. langsamer sind als wenn man alles direkt ins Hauptprogramm schreibt.

(DOSferatu darauf:)
Das hast Du falsch verstanden. Gemeint ist: Wenn man VÖLLIG OHNE UNTERPROGRAMME (also ohne procedures/functions) arbeitet, hat man einen SEHR GERINGFÜGIGEN Geschwindigkeitsvorteil.
Erklärung: Werden Subroutinen aufgerufen, wird ja ein CALL ausgeführt und bei Verlassen derselben ein RET. (oder bei FAR CALLs eben RETF.) Die paar Taktzyklen, die für das Ausführen dieser beiden Befehle benutzt werden, sind der "Geschwindigkeitsnachteil".
Ich hatte dies nur der Vollständigkeit halber erwähnt.

zatzen hat geschrieben:Zu folgendem hab ich eine kleine Verständnisfrage:

Und zwar, wenn ich in einem Pascal-Programm Units verwende, kommen die dann alle ins Codesegment (CS)
und sind NEAR? Und ist Pascal auf 64K Code begrenzt oder kann man über Units den ganzen konventionellen
RAM belegen? Das Datensegment scheint ja auf 64K begrenzt zu sein.

zatzen hat geschrieben: Dauert ein FAR-CALL bzw. RET länger, als ein NEAR ?

DOSferatu hat geschrieben:Genau zu verstehen was man benutzt, finde ich lobenswert und unterstützenswert. Viel zu viele "Programmierer" benutzen Zeug, von dem sie keine Ahnung haben und können dann nicht damit umgehen, wenn das Programm/der Algorithmus usw auch nur die kleinste Änderung erfordert und dies das "Fertigbauteil" zufällig nicht in seiner Grundanordnung unterstützt.

zatzen hat geschrieben:Nochmals vielen Dank an alle Helferlein!
Es ist ein gutes Gefühl, nicht mehr nur Halbwissen zu haben, man programmiert einfach sauberer.

Falls es jemand unterhaltsam findet, hier nach langer Zeit nicht ASM programmieren, meine Bitread-Function.
Ich habe sie noch nicht ausgiebig getestet, aber bei den paar Tests die ich gemacht habe hat's geklappt!
Kommt mir noch ein bisschen viel Code vor, vielleicht kann man da noch optimieren.

Code: Alles auswählen

procedure set_bitpointer(p: pointer);
begin
  bit_array_pointer := p;
  bitread_bytepos := 0;
  bitread_bitoffset := 0;
end;


function read_bits(length: byte): byte; assembler;
{
  to do:
  -----

  - word aus datenfeld einlesen
  - zurechtruecken und beschneiden
  - bytepos und bitoffset weiterzaehlen
}
asm

  mov bx, bitread_bytepos
  mov dl, bitread_bitoffset
  mov dh, length

  les si, bit_array_pointer
  add si, bx
  mov ax, es:[si]

Code: Alles auswählen

  mov cl, dl
  shr ax, cl
  { zurechtgeschoben }

Code: Alles auswählen

  mov cl, dh
  mov ch, 1  { hier stattdessen vielleicht lieber der zweizeiler " xor ch, ch ;  inc ch " ? }

mov cx, Wert
add cx, ax
mov dx, cx       ; ab hier wird der Inhalt von CX nicht mehr benötigt

xor cx, cx       ; vor dem Wechsel zu einem 8 Bit-Register
mov cl, Wert
....

xor cx, cx      ; vor dem Wechsel zu einem 8 Bit-Register
mov ch, Wert
....

Code: Alles auswählen

  shl ch, cl
  dec ch
  { maske erstellt }

  and al, ch
  { maske anwenden (ueberschuessige bits oberhalb abschneiden) }

  mov ah, 8 { mit der 8 wird unten 2x hantiert, daher nehmen wir mal ah stattdessen }

Code: Alles auswählen

  add dl, dh
  cmp dl, ah  { ah = 8 }
  jb @skip

  sub dl, ah  { ah = 8 }
  inc bx
  mov bitread_bytepos, bx

  @skip:

  mov bitread_bitoffset, dl

end;

Ich sehe schon, ich muss wohl BX nicht benutzen, kann wohl direkt die Speicherstelle nehmen.

Es sei denn, Operationen mit dem Register sind schneller und die MOVs auch sehr schnell.

Ich muss mir auch mal die Liste der Taktzyklen ausdrucken.
Und naja, anstatt mit einer "Maske" zu arbeiten könnte ich auch einfach AX einmal entsprechend
nach links und wieder rechts shiften, so dass die oberen Bits einfach rausfallen. Das ist aber
genausoviel Rechnerei wie bei der Maske, wenn nicht noch mehr bzw. langsamer.

les si, bit_array_pointer
mov ax, es:[si+bx]

Das "xor cx, cx" bewirkt hierbei das ein unmittelbar nachfolgender 8 Bit-Befehl(vom selben grösseren Registers) beim Wechsel schneller ausgeführt werden kann. Das hat was mit der internen Verarbeitung der Befehle zu tun, wobei ein "xor Register, Register" beim Wechsel zu einem kleineren Register eine Sonderrolle ein nimmt, auch wenn es sonst nichts anderes bewirkt und überflüssig zu sein scheint.

Man kann auch innerhalb einer Subroutine die Register SP/BP und SS frei verwenden, wenn man die Werte darin vorher an eine reservierte Speicherstelle sichert und am Ende der Subroutine wieder herstellt. Genauso muss man verfahren, wenn wir innerhalb unserer Subroutine noch weitere Subroutinen aufrufen möchten, dann müssen vorher auch die Register wieder hergestellt sein, damit der Zustand unseres Stacks funktionstüchtig bleibt und auch für unsere call-Befehle die Rücksprungadressen für unsere weiteren Subroutinen aufnehmen kann.

Zwischenzeitlich wenn der Stack nicht weiter von uns verwendet wird können wir die Register SP/BP und SS auch für unsere eigenen Zwecke verwenden. Dann haben wir gleichzeitig mit DS:SI und ES:DI auch noch SS:SP, oder SS:BP zur Adressierung von verschiedenen Speicherbereichen zur Verfügung an deren Adressen sich Tabellen etc. befinden können.

zatzen hat geschrieben: Nebenbei würde mich ein kurzer Abriss darüber interessieren, wie wobo die Mixing-Routine in seinem MOD-Player
realisiert hat. Ich selbst hätte drei Speicherbereiche zu adressieren: Das Sample als Quelle, eine Tabelle für die
endgültigen Samplewerte, und den Puffer wo alles reingerechnet wird. Wenn da nicht noch was dazukommt.
DS werd ich wohl brauchen, denn ich habe ja viele Parameter als Daten beim Berechnen. Zwischendurch ne
Routine aufrufen muss ich eventuell auch, je nachdem wie ich das aufbaue.

zatzen hat geschrieben:

les si, bit_array_pointer
mov ax, es:[si+bx]

Ich nehme mal an, das ist kompakter formuliert, dürfte aber ähnlich schnell sein als wenn ich
si explizit um bx erhöhe (?).

Das "xor cx, cx" bewirkt hierbei das ein unmittelbar nachfolgender 8 Bit-Befehl(vom selben grösseren Registers) beim Wechsel schneller ausgeführt werden kann. Das hat was mit der internen Verarbeitung der Befehle zu tun, wobei ein "xor Register, Register" beim Wechsel zu einem kleineren Register eine Sonderrolle ein nimmt, auch wenn es sonst nichts anderes bewirkt und überflüssig zu sein scheint.

Das ist wohl eine nicht zu unterschätzende Wissenschaft für sich, in die ich so noch überhaupt keinen Einblick
habe und auch nicht weiss wo ich dazu Informationen finden könnte. Ich habe das in anderen Threads schon mitverfolgt,
dass je nachdem wie man die ASM Befehle anordnet sich ganz verschiedene Geschwindigkeiten ergeben können.

mov ax,12  ; AX beschreiben
mov bx,ax  ; AX unmittelbar danach wieder auslesen --vorher Wartezeit
           ; bis vorheriger Befehl vollständig ausgeführt--
mov cx,4   ; CX beschreiben
mov dx,cx  ; CX unmittelbar danach wieder auslesen --vorher Wartezeit
           ; bis vorheriger Befehl vollständig ausgeführt--
mov si,77  ; usw....
mov di,si

mov ax, 12
mov cx, 4   ; Befehl kann sofort ausgeführt werden während der vorherige noch verarbeitet wird.
            ; Es besteht keine Abhängigkeit zum vorherigen Befehl.
mov si, 77  ; usw... 
mov bx, ax
mov dx, cx
mov di, si

Kommt mir sehr komplex vor, aber vielleicht ist es das gar nicht. Bisher war ich erstmal froh, überhaupt mit Assembler
eine "Hochgeschwindigkeitssprache" zu haben, aber es ist wohl noch komplexer...

zatzen hat geschrieben:Okay, das mit der Anordnung der Zugriffe für schnellere Abarbeitung lässt sich ja verstehen, das ist schön.

Was 386er Code angeht, möchte ich vielmehr wegen der Darstellung in Pascal bei 16 Bit bleiben...
Es ist eine Sache, aus AX ein EAX zu machen durch ein "db $66" davor, aber sicher noch eine ganz andere,
Register wie FS und GS kryptisch zu codieren...

 Ein Prozessorbefehl setzt sich aus bis zu neun Komponenten zusammen:
   Instruction Prefix                0 oder 1 Byte
   Address-Size Prefix               0 oder 1 Byte
   Operand-Size Prefix               0 oder 1 Byte
   Segment-Override Prefix           0 oder 1 Byte
   Opcode                            1 oder 2 Byte
   Mod R/M                           0 oder 1 Byte
   SIB, Scale Index Base (386+)      0 oder 1 Byte
   Displacement                      0, 1, 2 oder 4 Byte (4 nur 386+)
   Immediate                         0, 1, 2 oder 4 Byte (4 nur 386+)
;------------------
Address-Size Prefix (67H)
Operand-Size Prefix (66H)

Segment-Override Prefixe:
   26h   ES Override
   2eh   CS Override
   36h   SS Override
   3eh   DS Override
   64h   FS Override (386+)
   65h   GS Override (386+)

Format of Postbyte(Mod R/M aus Intel-Doku)
------------------------------------------
MM RRR MMM

MM  - Memeory addressing mode
RRR - Register operand address
MMM - Memoy operand address

RRR Register Names
Filds  8bit  16bit  32bit
000    AL     AX     EAX
001    CL     CX     ECX
010    DL     DX     EDX
011    Bl     BX     EBX
100    AH     SP     ESP
101    CH     BP     EBP
110    DH     SI     ESI
111    BH     DI     EDI

---

16bit memory (No 32 bit memory address prefix)
MMM   Default MM Field
Field Sreg     00        01          10             11=MMM is reg
000   DS       [BX+SI]   [BX+SI+o8]  [BX+SI+o16]
001   DS       [BX+DI]   [BX+DI+o8]  [BX+DI+o16]
010   SS       [BP+SI]   [BP+SI+o8]  [BP+SI+o16]
011   SS       [BP+DI]   [BP+DI+o8]  [BP+DI+o16]
100   DS       [SI]      [SI+o8]     [SI+o16]
101   DS       [DI]      [DI+o8]     [SI+o16]
110   SS       [o16]     [BP+o8]     [BP+o16]
111   DS       [BX]      [BX+o8]     [BX+o16]
Note: MMM=110,MM=0 Default Sreg is DS !!!!

32bit memory (Has 67h 32 bit memory address prefix)
MMM   Default MM Field
Field Sreg     00        01          10             11=MMM is reg
000   DS       [EAX]     [EAX+o8]    [EAX+o32]
001   DS       [ECX]     [ECX+o8]    [ECX+o32]
010   DS       [EDX]     [EDX+o8]    [EDX+o32]
011   DS       [EBX]     [EBX+o8]    [EBX+o32]
100   SIB      [SIB]     [SIB+o8]    [SIB+o32]
101   SS       [o32]     [EBP+o8]    [EBP+o32]
110   DS       [ESI]     [ESI+o8]    [ESI+o32]
111   DS       [EDI]     [EDI+o8]    [EDI+o32]
Note: MMM=110,MM=0 Default Sreg is DS !!!!

---

SIB is (Scale/Base/Index)
SS BBB III
Note: SIB address calculated as:
<sib address>=<Base>+<Index>*(2^(Scale))

Fild   Default Base
BBB    Sreg    Register   Note
000    DS      EAX
001    DS      ECX
010    DS      EDX
011    DS      EBX
100    SS      ESP
101    DS      o32        if MM=00 (Postbyte)
SS      EBP        if MM<>00 (Postbyte)
110    SS      ESI
111    DS      EDI

Fild  Index
III   register   Note
000   EAX
001   ECX
010   EDX
011   EBX
100              never Index SS can be 00
101   EBP
110   ESI
111   EDI

Fild Scale coefficient
SS   =2^(SS)
00   1
01   2
10   4
11   8