Esercizi Assembly

Esercizi Assembly
Un programma per calcolare la media
Dato un vettore di 32 bytes unsigned memorizzato a
partire dalla locazione 0x20a0, calcolarne la media e
memorizzarne il valore sovrascrivendo l’ultima
posizione del vettore. Se viene rilevato un overflow
in V[31] e’ posizionato il valore ff ff ff ff
0x20a0
V[0]
V[1]
V[2]
…
V[31]
V[31]=_i=031V[i]/32
Come gestire l’overflow?
L’istruzione da controllare e’:
addb (R1)+, R2
Microcodice :
1.
MAR<-R1
2.
R1<-R1+1
3.
Temp1<-[MDR] 8 //gli 8 lsbs di MDR estesi in segno vanno in T1
4.
Temp2<-[R2] 8 //gli 8 lsbs di R2 estesi in segno vanno in T2
5.
ALU_OUT=Temp1+Temp2
Se (Temp1 + Temp2) >232-1 il CARRY bit viene settato per
segnalare l’overflow. Quindi , e’ sufficiente far seguire
all’operazione di somma un salto condizionato del tipo:
jc error
org 400h
ARRAY
DIM
LOG2DIM
loop:
error:
fine:
Il codice
EQU 20a0h
EQU 32
EQU 5
; indirizzo base array
; num.elementi array
; log. base 2 di DIM
code
movl #DIM,R0
movl #ARRAY,R1
xorl R2,R2
;resetta R2, risultato parziale
addb (R1)+,R2
;somma i-esimo elem. i=0..DIM-1
jc error
;bit c settato =>Overflow
subl #1,R0
;decrementa contatore
jnz loop
;se contatore!=0 continua il cicla
lsrb #LOG2DIM, R2;dividi per il numero di elementi,
;usiamo LSRB poichè lavoriamo con unsigned
movb R2, -(R1)
;memorizza la media in ARRAY[DIM-1]
jmp fine
movl #DIM, R1
;gestione overflow, calcola in R1
addl #ARRAY, R1 ; R1=ARRAY+DIM
subl #1,r1
xorl R3,R3
notl R3,R3
; R3=111....111
movb R3,(R1)
; ARRAY[DIM]=11111111
halt
end
Una variazione sul tema…
ora, senza contatore!
Calcolare la media di 128 words memorizzate a
partire dall’indirizzo 0x20ab, ma senza impiegare
un registro appositamente come contatore (R0 del
programma precedente) .
0x20 ab
0x20ad
V[0]
V[1]
V[2]
…
0x21a9
0x21 ab
V[127]
NOTA: non si considera
l’overflow.
V[127]=_i=0127V[i]/127
Il codice
(funziona solo se il numero di elementi è pari a 128 words)
org 400h
DATI
EQU 20abh
code
main:
xorl R2,R2
movl #DATI,R1
movb R1,R0
loop:
addw (R1)+, R2
cmpb R1,R0
jnz loop
lsrw #7,R2
movw R2,-(R1)
halt
end
; programma allocato a partire da 400h
;indirizzo inizio
;inizio istruzioni
; R2=risult.parziale
; puntatore elemento
; copio lsB addr. inizio
; in R0
; lsB addr. elemento
; e' = lsB addr. inizio ?
; divido per 128
;serve solo per bloccare il simulatore
;fine della compilazione
Un altro esempio: la moda
Assumiamo di avere un vettore,V, di N bytes che
memorizza nella posizione i-esima l’altezza in
centimetri dell’i-esimo studente.
altezza
PROBLEMA:
Trovare l’altezza piu’ frequente
tra gli studenti (moda).
id-studente
Prima soluzione:
vettore di frequenze
Vogliamo calcolare la moda, costruendo innanzitutto
un vettore di frequenze, F, di 255 longwords, che
associ in posizione j, il numero di ricorrenze
dell’altezza j nel vettore di partenza V.
num.studenti
Probabilmente: F[j]=0 se i<50 o i>220
Osservazione:
Noto il vettore delle frequenze F, il
calcolo della moda si riconduce a
determinare per quale i, F[i]=max{F}
cm.
L’algoritmo per il calcolo delle frequenze
Possiamo costruire F in 2 passi.
1) Inizializziamo l’array F, di 255 longwords, con tutti 0.
for (i=0;i<256;i++) {
array2[i]=0;
}
2) Memorizziamo le frequenze in F scandendo una sola volta V e
incrementando di volta in volta l’elemento di F in posizione V(i) di 1.
for (i=0;i<N;i++) {
index=array1[i];
array2[index]++;
}
Codice
org 1400h
array1 equ 800h
array2 equ 1500h
dim equ 30
code
; V, vettore originale
; F, vettore frequenze
;inizializzo array2 con tutti 0
; for (i=0;i<256;i++) {
;
array2[i]=0;
;}
;
MOVL #array2,R5
movl #0,r4
clean:
movl #0, (R5)+
addl #1,r4
cmpl #0ffh,r4
jc clean
; r4 è inizializzato a zero perchè la successiva mvlb
; si aspetta i 3 bytes + significativi di R4 uguali a 0
mvlb array1(R3),R4 ;R4=V[i]=array1[R3]
;NOTA: MVLB non estende il segno
aslw #2,R4
;offset_array2=R4*4
;Moltiplicando per 4 il contenuto
;del lsb di R4 possiamo avere trabocchi,
;quindi usiamo aslw per operare con 2 byte
movl array2(R4),r5 ;r5=array2[offset_array2]
addl #1,r5
; r5=array2[offset_array2]+1
addl #array2,r4
; prima r4 era = offset_array2, ora
;r4=offset_array2+base_add_array2
movl r5,(r4) ;array2[offset_array2]=array2[offset_array2]+1
addl #1,R3
; i=i+1
cmpl #R2,R3
jnz count
;R2 base dell'array
; memorizzo frequenze in array2
; for (i=0;i<N;i++) {
;
index=array1[i];
;
array2[index]++;
;}
MOVL #dim,R2
XORL R3,R3
array1;
count: xorl r4,r4
;R2 dimensione di array1
;R3=0, contatore e offset per
halt
end
Prima soluzione:
determiniamo il max su F
Ora che abbiamo il vettore delle frequenze, il
calcolo della moda si riconduce a determinare per
quale i, F[i]=max{F}
num.studenti
170=moda
cm.
Codice
org 1400h
array2 equ 1500h
code
MOVL #255,R1
;copia il lsb byte in R1
ASLL #2,R1
ADDL #array2,R1 ; in R1 c’è l’indirizzo dell 256° elemento di Array2
MOVL #array2,R2 ;R2 puntatore all'array
XORL R3,R3
;R3=0;
MOVL #1,R4
;R4=1
loop:
MOVL (R2)+,R5
CMPB R5,R3
JNC skip
; se R3>=R5 salta a skip
MOVL -(R2),R3
; in R3 c'è il massimo temp.
MOVL R2,R4
; in R4 c'è l'indice corrisp.all'elemento massimo
ADDL #4,R2
skip:
CMPB R2,R1
jnz loop
; condizione di uscita dal ciclo
SUBL #ARRAY2,R4
; R4=[OFFSET_MAX_FREQUENZA*4]
ASRL #2,R4
; R4 / 4=OFFSET_MAX_FREQUENZA
halt
end
Ancora Moda… evitiamo il calcolo del
vettore delle frequenze
Dato un vettore di DIM dati da un byte, rappresentati come unsigned trovare:
1) l’elemento con il massimo numero di ricorrenze (moda)
2) il corrispondente numero di ricorrenze
L’ALGORITMO
MAX_NUM=0; //memorizza la moda
MAX_RIC=0; //memorizza il numero di ricorrenze della moda
FOR INT I=0 TO DIM-1 {
IF ((I==0) || ( (I!=0) && (A[I]!=MAX_NUM) ) ) {
// Conta il numero di ricorrenze dell’elemento i-esimo se e solo se I=0, oppure
// I!=0 e l’elemento A[I] non è già la moda
TEMP_RIC=0;
FOR INT J=I TO DIM-1
{ IF A[J]=A[I] TEMP_RIC++; }
IF (TEMP_RIC>MAX_RIC) {MAX_RIC=TEMP_RIC; MAX_NUM=A[I];}
}
Codice
ORG 400H
ARRAY EQU 1000H
DIMEQU 10
MAXNUM EQU 950H
MAXRIC EQU 951H
CODE
XORL R0,R0 ; MAXNUM=0
XORL R1,R1 ; MAXRIC=0
XORL R2,R2 ; I=0
FOR1:
MOVB ARRAY(R2),R5; R5=A[I]=ARRAY(R2)
CMPL #0,R2
JZ DOIT
; IF (I==0) JMP DOIT
CMPB R5,R0 ; ELSE IF A[I]== MAXNUM
JZ NOMAX ; JMP NOMAX (SKIP INNER CICLE)
DOIT:
MOVL R2,R3 ;J=I
XORL R4,R4 ;TEMPRIC=0
FOR2:
CMPB ARRAY(R3), R5 ; IF A[I]!=A[J]
JNZ NOADD
; SKIP ADD
ADDL #1,R4
; TEMPRIC++
NOADD:
ADDL #1,R3
; J++
CMPL #DIM,R3
; IF (J!=N) GOTO FOR2
JNZ FOR2
CMPL R4,R1
; IF MAXRIC>TEMPRIC
JNC NOMAX
; SKIP UPDATING MAX
MOVL R4,R1
; MAXRIC=TEMPRIC
MOVB ARRAY(R2),R0; MAXNUM=A[I]
NOMAX:
ADDL #1,R2
CMPL #DIM,R2
JNZ FOR1
; I++
; IF (R2!=DIM)
; GOTO FOR1
MOVB R0, MAXNUM
MOVL R1, MAXRIC
HALT
END
Inversione di un array
Dato un array di 10 elementi, memorizzato a partire
da 250h, rimpiazzarlo con l’array inverso (senza
usare un altro vettore di appoggio).
250h
254h
258h
25Ch
260h
264h
268h
26Ch
270h
274h
prima
11
1
21
5
2
13
4
8
9
3
250h
254h
258h
25Ch
260h
264h
268h
26Ch
270h
274h
dopo
3
9
8
4
13
2
5
21
1
11
Il primo passo di esecuzione
R3=10/2=5
11
1
21
5
2
13
4
8
9
3
scambia (R1) con (R2)
R1
R2
11
1
21
5
2
13
4
8
9
3
R3=R3-1=4
3
1
21
5
2
13
4
8
9
11
R1
R2
Rappresentazione dell’informazione
250h
254h
258h
25Ch
260h
264h
268h
26Ch
270h
274h
11
1
21
5
2
13
4
8
9
3
336 (dec)
340
344
348
352
356
360
364
368
372
258h
259h
25ah
25bh
00010101
00000000
00000000
00000000
Base_Addr(Array)
+
(DIM-1)*size_of(elem) =
Addr(Array[DIM-1])
9*4=36 (OFFSET)
344
345
346
347
336 +
9*4=
372
Il codice
ORG 400H
DIM EQU 10
ARRAY EQU 250H
CODE
MOVL #ARRAY,R2
MOVL #DIM,R4
SUBL #1,R4
ASLL #2,R4 ; offset da sommare alla base dell'array per ottenere l'ultimo elemento
ADDL R4,R2 ; in R2 c'è l'indirizzo dell'ultimo elemento dell'array
MOVL #ARRAY,R1 ; R1 <-indirizzo array
MOVL #DIM,R3 ; R3<-10 (000... 00001010)
ASRL #1,R3 ; R3=R3/2=5 (000... 000000101)
REPEAT:
MOVL (R1),R0; R0 registro d'appoggio per lo scambio
MOVL (R2),(R1); Copia memoria memoria dell'"ultimo" elemento sul "primo"
MOVL R0,(R2); recupera il valore del primo elemento da R0 e copialo in coda
ADDL #4,R1; avanza di 4 byte il valore dell'offset sul vettore originale
SUBL #4,R2; decrementa di 4 byte il valore dell'offset sul vettore invertito
SUBL #1,R3; decrementa il contatore
JNZ REPEAT; fino a 0
HALT
END
Un algoritmo per la moltiplicazione
Il set di istruzioni del PD32 non prevede istruzioni per
effettuare la moltiplicazione tra due operandi.
La moltiplicazione puo’ essere realizzata banalmente
sommando al moltiplicando se stesso, un numero di volte
pari al valore del moltiplicatore. 5*3=5+5+5=15.
Tale algoritmo ha complessità computazionale pari a O(N),
dove N è il valore del moltiplicatore.
Vogliamo proporre un algoritmo per la moltiplicazione la cui
complessità sia pari a O(log2N).
Moltiplicazione: primo approccio
00110 x
00101 =
00110
00000
00110
somme
00000
parziali
00000
000011110
00000
00110
00110
00000
000110
00110
0011110
00000
00011110
00000
000011110
+
somma
parziale
+
+
“prodotto
parziale”
+
+
Risultato
finale
In altre parole...
Traslo a destra il moltiplicatore di una posizione per
verificare se il suo lsb vale 1. Il suo lsb finisce in C.
C=1
C=0
Sommo il moltiplicando
alla somma parziale.
Traslo a destra la somma parziale, copiando il bit
fuoriuscito (lsb della somma parziale) nel msb del
moltiplicatore (che diventa passo dopo passo la
parte meno significativa del risultato)
L’algoritmo (precondizioni)
moltiplicando, A=6
moltiplicatore,D=5
0
0
1
1
0
A
0
0
0
0
0
B
0
0
0
1
C
0
1
D
•
Ripeti i seguenti passi tante volte quanti sono i bit di D.
1. Azzero C
2. Trasla a destra D
3. Se C=1 somma A e B
4. Trasla a destra B
5. Se C=1 inverto il bit più significativo di D
L’algoritmo (postcondizione)
moltiplicando, A=6
Risultato=30
0
0
1
1
0
A
0
0
0
0
0
B
0
1
1
1
C
1
0
D
Il risultato della moltiplicazione necessita di un numero di
bits doppio per poter essere rappresentato. Per semplicità
moltiplicando e moltiplicatore hanno 5 bits nel nostro
esempio=> risultato scritto in 10 bits. I 5 MSB sono scritti in
B, i 5 LSB sovrascrivono il moltiplicatore.
Il codice
ADDL R0,R2
ORG 400H
LSRL #1,R2
rls EQU 2000h ;addr.parte meno sig.del risult. dopo:
JNC poi
rms EQU 2004h ;addr.parte + sig.del risult.
XORL #80000000h, R3 ;inverto il bit + significativo
A DL 6 ; variabile contenente il moltiplicando
di R3 (d)
D DL 5 ; variabile contente il moltiplicatore
poi: SUBL #1, R1
JNZ mult
MOVL R3, rls
CODE
MOVL A,R0 ; carico il moltiplicando in R0
MOVL D,R3 ; carico il moltiplicatore in R3
MOVL R2,rms
XORL R2,R2 ; azzero R2 (B)
MOVL #32,R1; R1 è il contatore: inizializzo a END
; 32, #bits moltiplicatore
mult:
CLRC
LSRL #1, R3
JNC dopo
; la parte meno significativa
; contenuta in R3 viene caricata
; nella longword di memoria
; di indirzzo rls
; la parte più significativa in rms