Architektúrák gyakorlat 2007 (levelező)

A gyakorlaton 1 db ZH dolgozatot kell teljesíteni az utolsó alkalommal. A ZH-n maximum 50 pont szerezhető amelyből legalább 20 pontot el kell érni a gyakorlat teljesítéséhez. Ha valaki tehát 20, vagy annál több pontot szerez, akkor mehet vizsgázni.

Tanenbaum A Függelék. Számok konvertálása 2-es, 10-es, 16-os számrendszerek között. Pl:

77d = 100 1101b = 4dh
185d = 1011 1001b = 0b9h
bedh = 1011 1110 1101b = 3053d

19,625d = 1 0011,101b
114,25d = 111 0010,01b

Hány különböző szám fejezhető ki 1 bájton?
Hány különböző szám fejezhető ki n darab bináris számjegyen?
Helyik a legnagyobb?
Ha r az alap?

Összeadás, kivonás 2-es, 16-os számrendszerben.
Negatív számok: előjeles abs érték, 1-es, 2-es komplemens, többletes.
Hajtsuk végre a következő számításokat 8 bites kettes komplemensű számokon:

00101101 + 01101111
11111111 + 11111111

Tanenbaum B függelék. IEEE szabvány egyszeres pontosságú, normalizált.

114.25     ==> 0100 0010 1110 0100 1000 0000 0000 0000b
             = 42e4 8000h
39.25      ==> 421d 0000h
1.0625     ==> 3f88 0000h
3fc0 0000h ==> 1,5

Nem kötelező feladat: C program a konvertálásra?

Mi a Neumann elv?
Valamikor 1 mikron átmérőjű volt a mikroprocesszor egy tranzisztora. Moore szabálya szerint mekkora volt az átmérője három évvel később?

Mekkora a hexadecimális E6 és C7 Hamming távolsága?
Az alábbi memóriák közül melyik lehetséges, melyik ésszerű? Indokolja meg!

10 bites címek    1024 db    8 bites rekesz
10                1024      12
 9                1024      10
11                1024      10
10                  10    1024
1024                10      10

Szegmens:offszet címzés: Lineáris cím = segm * 16 + offs.

  segm:1272h  ===> *16  ===>    12720h
  offs:1a3bh                   + 1a3bh
                               -------
                                1415bh    lineáris cím

Egy lineáris címnek hány logikai (szegmens:offszet) címe van? Mondjunk olyan logikai címeket, melyek az 12345h lineáris címre mutatnak. Mi a helyzet a 0ffffh:0010h címmel?

Helyesek e az alábbi címzések? Ha igen, mely lineáris címre hivatkoznak? Tegyük fel, hogy a regiszterek tartalma: AX=0021h, BX= 0031h, CX=0001h, DX=0341h, SI=1223h, DI=0402h, DS=1234h SS=0405h, ES=2365h, BP=1200h;

[BX + 0121h]
[CX + 4]
IP:[BX + SI + 0123h]
ES:[SI + 0001]
[123456789ABCh]
ES:[09D3h]
[SI-500d]
SS:[BX+DI+1999d]
[SI+DI]
[IP]
[BP+SI]
DS:[BP+SI]

Tegyük fel hogy a következő példákban az adatszegmensünk így néz ki:
ds:0000 CD 20 FF 9F 00 9A F0 FE

Bájtsorrend!

mov       al, [0]         ;al=CD
mov       ax, [0]         ;ax=20CD

mov       ax, 5h         ;ax=0005h
add       al, 0001h      ;ax=0006h

mov       ax, 5h
add       al, [0001h]    ;ax=0025h

mov       ax, 5h
mov       bx, 6h
add       ax, bx         ;ax=000Bh

mov       ax, 5h
mov       bx, 6h
add       ax, [bx]       ;ax=FEF5h

mov       ax, 0102h
mov       cx, 0003h
mul       cl             ;ax=0006h

mov       ax, 0102h
mov       cx, 0003h
mul       cx             ;dxax=0000 0306h

mov       ax, 0202h
mov       si, 0003h      ;ds:0003= 9fh
mul       byte ptr [si]  ;ax=013eh

mov       ax, 0602h
mov       si, 0003h      ;ds:0003= 9f 00h
mul       word ptr [si]  ;0602h*009fh = 0003 bb3eh

Írjunk egy programrészletet, amely kiszámolja az alábbi kifejezés értékét! Feltesszük, hogy minden regiszter előjeltelen számot tartalmaz és minden művelet eredménye elfér 16 biten. Az eredményt tároljuk ax-ben.

(cx + ax ) * bx

add       ax, cx
mul       bx

bx * dx + ax

mov       cx, ax         ;ax mentése
mov       ax, dx         ;csak ax-ben tudunk szorozni
mul       bx             ;szorzás bx-el
add       ax, cx         eredmény ax-ben

ax * ax + bx * bx

mul       ax             ;ax*ax
mov       cx, ax         ;ax mentése
mov       ax, bx         ;bx-et attesszük ax-be
mul       ax             ;
add       ax, cx         ;eredmény ax-ben

Számoljuk ki a következő kifejezés értékét! Az eredményt helyezzük AX-be!
min( a*c , a+b ) ahol, a és c 8, b 16 bites előjeltelen számok.

  mov al, a
  mul c         ;ax=a*c

  mov bx, b     ;bx=b
  mov cl, a     ;cl=a
  xor ch, ch    ;cx=a tizenhat biten
  add bx, cx    ;bx=a+b

  cmp ax, bx    ;flagek bx-ax szerint
  jb  vege      ;ha ax kisebb, ugrik
  mov ax, bx
vege:

Az adatszegmens

  a     db 4
  c     db 3
  b     dw 9

A teljes forráskód letölthető innen.

Adjunk össze egy 8 bites előjeles számot és egy 16 bites előjeltelen számot! Például a -10d-t és a 2525d-t.

mov al, -10d             ;al=0f6h
cbw                      ;ax=0fff6h
mov bx, 2525d            ;bx=09ddh
add ax, bx               ;ax=09d3h

Szorozzuk össze a 8 bites -2d-t a szintén 8 bites 3d-vel!

mov       al, -2d        ;al=0feh
mov       cl, 3d         ;cl=03h
imul      cl             ;ax=fffah

Szorozzunk össze egy 8 bites előjeles, ill. egy 16 bites előjeles számot! Például a -2d-t és a -520d-t.

mov       al, -2d        ;al=0feh
cbw                      ;ax=0fffeh
mov       cx, -520d      ;cx=0fdf8h
imul      cl             ;dxax=0000 0410h azaz 1040d

Számoljuk meg, hogy milyen hosszú egy sztring! Tegyük fel, hogy a sztringet a 0 karakter zárja.

  mov cx, 0     ;szamlalo
  mov bx, offset hahostr
 betolt:
  mov al, [bx]
  cmp al, 0
  je  vege
  inc bx
  inc cx
  jmp betolt
vege:

Az adatszegmens

  hahostr   db "Haho !", 0

A teljes forráskód letölthető innen.

Írjon programrészletet amely megszámolja az 50 elemű, szavakból álló A tömb 100-nál nagyobb elemeit!

Keressük meg egy bájtokból álló számsorozat legnagyobb elemét! A számsorozat hosszát a len változó tartalmazza. Az eredményt taroljuk a max változóban.

    mov   cx, len   ;cx= hossz
    mov   bx, offset sor ;bx-be kerul sor offsetje
    xor   dx, dx    ;dx=0
betolt:
    mov   al, [bx]  ;szam betöltése al-be
    cmp   al, dl    ;ha kisebb= mint az eddigi legnagyobb
    jbe   kov       ;ugorja át a következő utasítást
    mov   dl, al    ;ez lesz az aktuális legnagyobb
kov:
    inc   bx        ;index növelése
    loop  betolt
    mov   max, dl   ;max valtozóba tároljuk el dl-t

Az adatszegmens pl. a következő is lehet:

adat  segment
    len   dw 5
    max   db 0
    sor   db 4,5,2,7,3
adat  ends

A teljes forráskód letölthető innen.

Számoljuk meg, hogy hány darab "a" betű van egy karakterláncban! Párhuzamosan cseréljünk minden a betűt b betűre.

    mov   cl, 0     ;számláló
    mov   bx, offset text
    mov   si, 0
kov: 
    mov   al, [bx+si] ;betöltjük a köv. betűt
    cmp   al, 0     ;elérkeztünk a végére?
    je    vege      ;ha igen, ugrik a végére
    cmp   al, 'a'   ;kell-e számolni
    jne   nemszamol ;ugrik, ha nem kell számolni
    inc   cl        ;noveli a számlálót
    mov   byte ptr[bx+si], 'b'
nemszamol:
    inc   si
    jmp   kov
vege:   
    mov   n, cl     ;n-be rakjuk a végeredményt

A teljes forráskód letölthető innen.

Módosítsuk egy string kisbetűit, a megfelelő nagybetűkre.

    mov   cl, 0     ;számláló
    mov   bx, offset text
    mov   si, 0
betolt: 
    mov   al, [bx+si] ;betöltjük a köv. betűt
    cmp   al, 0     ;elérkeztünk a végére?
    je    vege      ;ha igen, ugrik a végére
    cmp   al, 'a'   ;a-nal nagyobb? 
    jb    kov       ;ugrik, ha nem
    cmp   al, 'z'   ;z-nel kisebb?
    ja    kov       ;ugrik ha nem
    add   al, 'A'-'a'
    mov   [bx+si], al
kov:
    inc   si
    jmp   betolt
vege:   

A teljes forráskód letölthető innen.

Módosítsuk a maximum kereső programot hogy szavakból (dupla bájt) álló számsorozatra is működjön.

Módosítsuk a maximum kereső programot minimum kereső programra! Azaz keressük meg a sorozat legkisebb elemét. Figyeljünk a megfelelő kezdőértékekre!

Egészítsük ki a maximum kereső programot, hogy a legnagyobb szám első/utolsó előfordulási helyét a "pos" változóban tároljuk!

Módosítsuk a nagybetűsre konvertáló programot, hogy kisbetűkre konvertálja a nagybetűket.

Módosítsuk a nagybetűsre konvertáló programot, hogy kisbetűket nagyra, a nagybetűket kicsire konvertálja.

Fordítsunk meg egy stringet! Írjunk eljárást, amely egy string tartalmát megfordítja. Az eljárás SI regiszterben várja a string elejét.

Megoldás verem használatával!

    
;eljárás ami megfordít egy stringet verem használatával.
;a string elejét SI mutatja
strvfordit proc
        push    si, di    ;regiszterek mentése

        mov     cx, 0     ;számláló számolja a str. hosszát
        mov     di, si    ;si mentése di 
berak:
        mov     al, [si]  ;betöltjük a betűt
        cmp     al, 0     ;0 jelzi a str végét
        je      berakvege
        push    ax        ;betű be a verembe
        inc     cx        ;számláló növelése
        inc     si        ;si mutasson a köv betűre
        jmp     berak     ;ugrás vissza a ciklus elejére
berakvege:
        cmp     cx, 0     ;számláló akkor 0, ha str üres volt
        je      strvforditvege
kivesz:
        pop     ax
        mov     [di], al
        inc     di
        loop    kivesz
strvforditvege:
        pop     di, si
        ret
strvfordit endp

A teljes forráskód letölthető innen.

Verem használata nélkül!

;eljárás ami megfordít egy stringet.
;a string elejét SI mutatja
strfordit proc
    push si di     ;regiszterek mentése

    mov  di, si    ;di fog mutatni a string végére
keres:
    mov  al, [di]  ;de, először meg kell keresnünk a végét
    cmp  al, 0     ;vége?
    je   keresvege ;ha igen ugrik
    inc  di        ;di mutasson a következő betűre
    jmp  keres     ;ugrás a keresés elejére
keresvege:

    mov  ax, di
    sub  ax, si    ;ax = di - si
    cmp  ax, 2     ;ha 0 v. 1 a hossz, akkor vege is
    jb   vege
    dec  di
    
csere:
    mov  al, [di]   
    xchg al, [si]  ;kicseréli
    mov  [di], al  ;[si]-t és [di]-t
    inc  si
    dec  di
    cmp  si, di    ;vége?
    jb   csere
vege:
    pop  di si    ;regiszterek visszatöltése
    ret
strfordit endp

A teljes forráskód letölthető innen.

Írjuk egy eljárást amely összead 2 számot. A paramétereket a veremben adjuk át!

osszead proc
  push  bp         ;bp mentése
  mov   bp, sp     ;verem teteje
  push  bx         ;bx mentése
  
  mov   bx, [bp+4] ;2. paraméter
  mov   ax, [bp+6] ;1. paraméter
  add   ax, bx     ;összeadás
  
  pop   bx         ;bx visszatöltése
  pop   bp         ;bp visszatöltése
  ret
osszead endp

A teljes forráskód letölthető innen.

Számoljuk meg hány n-el osztható szám van egy sorozatban!

;eljárás amelyik meghatározza, h. hány n-el osztható 
;szám van sorozatban. Az eredményt ax-be teszi.
;1. param: 16 bites előjeltelen sorozat eleje
;2. param: hossz
;3. param: n
ndiv  proc
    push    bp        ;bp mentése
    mov     bp, sp    ;bp = sp
    push    si bx cx dx;regiszterek mentése

    mov     si, [bp+8];sorozat eleje
    mov     cx, [bp+6];hossz
    mov     bx, 0     ;számolja az n-el osztható elemeket
kezd:
    mov     ax, [si]  ;ax-be a sor következő eleme
    mov     dx, 0     ;a köv. div dx:ax-et osztja!
    div     word ptr [bp+4] ;osztunk n-el
    cmp     dx, 0
    jne     nemoszthato
    inc     bx        ;számláló növel
nemoszthato:
    add     si, 2     ;kov elem
    loop    kezd    
    mov     ax, bx    ;eredmény ax-be
    pop     dx cx bx si;regiszterek visszatöltése
    pop     bp
    ret
ndiv  endp   

A teljes forráskód letölthető innen.