Struttura del Computer

Presentazione sul tema: "Struttura del Computer"— Transcript della presentazione:

1 Struttura del Computer
Unità Logico- Aritmetica (ALU) Unità di Input Memoria Unità di Output Unità di Controllo I/O CPU o Processore L’Unità di Input accetta informazioni codificate dall’Operatore Tale informazione può essere memorizzata o elaborata dall’ALU La sequenza di passi necessaria ad elaborare l’informazione Viene determinata da un programma residente in memoria I risultati sono presentati all’esterno tramite le unità di Output Tutte queste operazioni sono coordinate dall’unità di controllo

2 Istruzioni e Dati Istruzioni ( o istruzioni macchina)
Sono comandi che: Governano il trasferimento di Informazioni sia all’interno del computer sia tra computer e dispositivi di I/O Specificano le operazioni Aritmetico-Logiche da effettuare Un’insieme di istruzioni che svolgono un determinato compito è un PROGRAMMA

3 Istruzioni e Dati (cont.)
I DATI sono numeri o caratteri codificati (estesa) Ogni numero, carattere o istruzione è codificata con una Una stringa di cifre binarie dette BIT (BInary digiT) Ognuno dei quali può assumere il valore 0 oppure 1 0 =  0*23+ 0*22+ 0*21+ 0*20 1 =  0*23+ 0*22+ 0*21+ 1*20 2 =  0*23+ 0*22+ 1*21+ 0*20 6 =  0*23+ 1*22+ 1*21+ 0*20

4 Programma Alto Livello
main() { int a,b,i; int c[100]; char *p; a=100; b=200; a=a+b; for (i=0;i<100;i++) c[i]=a+i; } b=0; load a,r1 load b,r2 add r1,r2 store r2,a I1  PC PC  MAR UC (Read: Load a,r1)  MDR MDR  IR a  MAR UC (Read: a)  MDR MDR  R1

5 Programma Alto Livello
Memoria i1 i+1 a i+n b c Dati Istruz. 1 ……… Istruz. n Istruz. 2 Progr. 100 200 i ** …. c+1 c+100 main() { int a,b,i; int c[100]; char *p; a=100; b=200; a=a+b; for (i=0;i<100;i++) c[i]=a+i; } b=0;

6 Sommario Quali sono le istruzioni definite (Instruction Set)
Come si definiscono i dati Come si accede ai dati da programma (Indirizzamento) Come si cambia in flusso di esecuzione di un programma in base a risultati di operazioni aritmetico-logiche (salti, condizioni)

7 Memoria Principale Composta di Celle di 1 BIT
Accesso a gruppi di n BIT (word) Ogni Operazione elementare legge o scrive 1 word n = Lunghezza della word ([16-64]) n=32 Ogni word ha associato un indirizzo che è un numero binario a k BIT k bit  2k numeri nell’intervallo 0 – (2k –1) 2k = Spazio di indirizzamento Es: k=24  S.I. = 224 word  16 Mword k=32  S.I. = 232 word  4 Gword

8 Memoria (cont.) M E O R I A MDR = Memory Data Register
Unità di controllo ALU M E O R I A M D R ….. R0 R1 Rn-1 M A R P C I R CPU MDR = Memory Data Register MAR = Memory Address Register PC = Program Counter IR = Instruction Register

9 Memoria Principale (cont.)
n bit Word 0 1 Word 1 2 Word 2 3 2 1 Byte n n-1 3 2 1 i • • • • • • • Word i 2k-1 Word 2k-1 Ogni word può contenere DATI (numeri, caratteri) o ISTRUZIONI

10 Numeri [-2.147.483.647,+2.147.483.647] Modulo e Segno Modulo
1 2 30 31 Bit di segno 0 = Positivo 1 = Negativo Modulo è espresso in notazione binaria posizionale Modulo = b30* 230+ b29* 229+…….+ b1* 21+ b0* 20 [ , ]

11 ? Numeri (cont.) AMBIGUITA’
Es: = 0* * 229+……+ 1* 25+ 0* 24+ 0* 23+ 0* 22+ 1* 21+ 1* 20 +35 = 1 1 1 -35 = 1 1 1 1 +0 = 1 ? -0 = AMBIGUITA’

12 ? Numeri (cont.) AMBIGUITA’ Complemento a 1:
Numeri Positivi = come modulo e segno Numeri Negativi = si invertono i bit del corrispondente positivo +35 = 1 1 1 -35 = 1 1 1 1 1 1 +0 = 1 ? -0 = AMBIGUITA’

13 Numeri (cont.) Complemento a 2: Numeri Positivi = come modulo e segno
Numeri Negativi = Complemento a 1 + 1 +35 = 1 1 1 -351 = 1 1 1 1 1 1 -352 = 1 1 1 1 1 1 1 +0 = 1 -01 = -02 =

14 Caratteri ASCII (7 bit) 32 bit Es: “ALBA” 3 2 1 8 bit 8 bit 8 bit
Carattere ASCII Carattere ASCII Carattere ASCII Carattere ASCII Es: “ALBA” 3 2 1 A B L A

15 Istruzioni Load a , r1 Add r1 , r2 Store r2 , b Opcode Operandi 32 bit
Indirizzo Operando 28 = 256 istruzioni

16 Problema 1 ? Da una configurazione binaria contenuta in una locazione di memoria, è possibile dire se si tratta di numero,carattere o istruzione ? NO Risposta?:

17 Convenzioni Minima unità indirizzabile è il Byte Big-Endian
1 2 30 31 31 30 29 1 Minima unità indirizzabile è il Byte 1 2 3 5 4 6 7 2k-3 2k-4 2k-2 2k-1 2 3 1 6 7 5 4 2k-2 2k-1 2k-3 2k-4 Big-Endian Little-Endian

18 Un calcolatore con memoria indirizzabile a Byte,
Problema 2 ? Un calcolatore con memoria indirizzabile a Byte, Organizzato con word di 32 bit secondo lo schema Big-Endian. Se un programma legge da tastiera la parola “INFORMATICA” e la memorizza in byte consecutivi a partire dalla locazione Quale sarà il contenuto Della memoria? N I F O M R A T 1004 2k-4 … 1000 C 1008

19 Accesso alla Memoria Fetch (Lettura) Store (Scrittura)
Copia il contenuto della memoria  CPU Store (Scrittura) CPU  Memoria

20 Linguaggi ad Alto Livello (Fortran, Cobol, C, C++, ecc.)
Linguaggi di Programmazione Linguaggi ad Alto Livello (Fortran, Cobol, C, C++, ecc.) Compilatore Assemblatore Linguaggio Macchina Assembler LOAD R0, R1

21 Istruzioni Istruzioni ( o istruzioni macchina) Sono comandi che:
Governano il trasferimento di Informazioni sia all’interno del computer sia tra computer e dispositivi di I/O Specificano le operazioni Aritmetico-Logiche da effettuare Un’insieme di istruzioni che svolgono un determinato compito è un PROGRAMMA

22 Istruzioni Trasferimento dati tra Memoria e CPU
Operazioni Aritmetiche e Logiche sui dati Controllo del flusso del programma Operazioni di I/O

23 Istruzioni (cont.) Indirizzi in memoria A, B, LOC, VAR Registri
R0, R1, ACCUM, IOSTAT, IOREAD Trasferimento dati R0  [LOC] Operazioni C = A + B  C  [A] + [B]

24 Istruzioni (cont.) C  [A] + [B] Istruzione a 3 Indirizzi ADD A,B,C
OpCode Source1,Source2,Destination

25 Istruzioni (cont.) C  [A] + [B] Istruzione a 2 Indirizzi
OpCode Source1,Destination ADD A,B  B  [A] + [B] ADD A B

26 Istruzioni (cont.) C  [A] + [B] MOVE B,C  C  [B]
ADD A,C  C  [A] + [C] MOVE B C ADD A

27 Istruzioni (cont.) C  [A] + [B] ADD A,B,C MOVE B,C  C  [B]
ADD A,C  C  [A] + [C] MOVE B C ADD A

28 Istruzioni (cont.) Registri Ogni CPU ne ha da 8 a 64
8 registri  3 bit per indirizzarli 64 registri  6 bit per indirizzarli Sono più veloci Indirizzamento con numero minore di bit ADD R0, R1, R2 R0 ADD R1 R2 Compilatore deve ottimizzare l’uso dei registri

29 L’altro operando è implicito. E’ un registro fissato della CPU
Istruzioni (cont.) Istruzioni ad 1 Operando OpCode Source OpCode Destination L’altro operando è implicito. E’ un registro fissato della CPU (ACCUMULATORE) MOVE B  ACC  [B] ADD A  ACC  [A] + [ACC] STORE C  C  [ACC] C  [A] + [B] MOVE B ADD A C STORE

30 Problema 3 ? Scrivere un Programma che valuti l’espressione: A*B + C*D In un processore con Accumulatore, ipotizzando che esistano le istruzioni: Load, Store, Add, Multiply

31 Esecuzione di Istruzioni
C  [A] +[B] MOVE A, R0 ADD B, R0 MOVE R0, C n bit i i+1 A i+2 MOVE A, R0 ADD B, R0 MOVE R0, C B C Dati Programma Esecuzione in 2 Fasi: Fetch dell’Istruzione Esecuzione dell’Istruzione

32 Sequenze Lineari • i i+1 i+2 i+n-1 i+n C NUM1 NUM2 MOVE NUM1, R0
ADD NUM2, R0 i+2 ADD NUM3, R0 • i+n-1 ADD NUMn, R0 i+n MOVE R0, C C NUM1 NUM2

33 Controllo di Flusso: Salto
MOVE N, R1 i+1 CLEAR R0 LOOP Determino l’indirizzo del NUM successivo ed Eseguo ADD NUM,R0 DEC R1 Branch > 0 LOOP MOVE R0, C N K C NUM1 NUM2 • NUMK

34 Controllo di Flusso: Condizioni
Registro di Stato C V Z N N = 1 L’operazione corrente produce un risultato negativo Z = 1 L’operazione corrente produce un risultato zero V = 1 L’operazione corrente produce un overflow C = 1 L’operazione corrente produce un riporto

35 Modalità di indirizzamento
Indirizzamento a Registro Operando contenuto in un registro della CPU. Il nome del registro è specificato nell’istruzione ADD A, R0 Indirizzamento Assoluto Operando è una locazione di memoria. L’indirizzo della locazione è specificato nell’istruzione ADD A, R0

36 Modalità di indirizzamento (cont.)
Indirizzamento immediato Operando definito esplicitamente nell’istruzione. ADD #200, R0 Indirizzamento indiretto Indirizzo dell’operando è contenuto in un registro o una locazione di memoria (puntatori). ADD (A), R0

37 Modalità di Indirizzamento (cont.)
Indirizzamento indiretto (cont.) i MOVE (A), R0 • A C C Operando

38 Modalità di Indirizzamento (cont.)
MOVE N, R1 i+1 CLEAR R0 LOOP Determino l’indirizzo del NUM successivo ed Eseguo ADD NUM,R0 Move N, R1 Clear R0 Move #NUM1, R2 LOOP: Add (R2), R0 Inc R2 Dec R1 Branch > 0 LOOP Move R0,C DEC R1 Branch > 0 LOOP MOVE R0, C N K C NUM1 NUM2 • NUMK

39 Problema 4 ? Scrivere un programma per eseguire il calcolo C = A1*B1 + A2*B2 + A3*B3 Programma che esegue una sequenza lineare Scrivere un programma con ciclo Calcolare il numero di accessi alla memoria richiesti sia per a) che b).

40 Problema 5 ? Scrivere un programma per eseguire il calcolo Il valore n è memorizzato alla locazione N. Calcolare i valori di k1 e k2 nella formula k1+k2n Che rappresenta il numero di accessi alla memoria Per il programma scritto.

41 Verifica R1 R2 ADD #200, R2 ADD A, R2 MOV #A,R1 ADD (R1), R2
500 100 ADD #200, R2 ADD A, R2 • 1000 100 MOV #A,R1 ADD (R1), R2 A=1200 1500 C=1500 1000 ADD (C), R2

42 Problema 6 ? Avere un gran numero di registri riduce Gli accessi alla memoria? Suggerire un semplice problema computazionale Che evidenzi ciò e mostrare la validità su una Macchina con 2 registri ed una con 4. “ Dati due array di k numeri A e B trovare il massimo di A ed il massimo di B e sommare i due massimi. “

43 Soluzione Problema 6 CONT = K START MAX=0 Trovare il MAX di A
MAX < A(CONT) ? MAX=A(CONT) CONT = CONT-1 CONT > 0 ? SI NO MAX_A=MAX START Trovare il MAX di A Trovare il MAX di B Sommare i due MAX END

44 Soluzione Problema 6 CONT = K START MAX=0 SI Trovare il MAX di A
MAX < B(CONT) ? MAX=B(CONT) NO Trovare il MAX di B CONT = CONT-1 Sommare i due MAX SI CONT > 0 ? NO END MAX_B=MAX

45 R0  #K CONT = K R1  #0 MAX=0 R2  #A SI MAX < A(CONT) ? R3  R1-[(R2)] SI MAX=A(CONT) NO R3 < 0 ? R1  [(R2)] NO CONT = CONT-1 R2  [R2] + 1 SI CONT > 0 ? R0  [R0] - 1 NO SI R0 > 0 ? MAX_A=MAX NO MAX_A  [R1]

46 R0  #K MOV #K, R0 R1  #0 MOV #0, R1 R2  #A MOV #A, R2 R3  [(R2)] – R1 LOOP_A: SUB (R2), R1, R3 NO BRANCH < 0 STEP_A R3 < 0 ? R1  [(R2)] MOV (R2), R1 SI STEP_A: INC R2 R2  [R2] + 1 DEC R0 R0  [R0] - 1 SI BRANCH > 0 LOOP_A R0 > 0 ? NO MOV R1,MAX_A MAX_A  [R1]

47 MOV #K, R0 MOV #K, R0 MOV #0, R1 MOV #0, R1 MOV #A, R2 MOV #A, R2 LOOP_A: SUB (R2), R1, R3 LOOP_A: MOV R1,R3 SUB (R2), R3 BRANCH < 0 STEP_A BRANCH < 0 STEP_A MOV (R2), R1 MOV (R2), R1 STEP_A: INC R2 STEP_A: INC R2 DEC R0 DEC R0 BRANCH > 0 LOOP_A BRANCH > 0 LOOP_A MOV R1,MAX_A MOV R1,MAX_A

48 MOV #K, R0 MOV #0, R1 MOV #A, R2 LOOP_A: MOV R1,R3 SUB (R2), R3 BRANCH < 0 STEP_A MOV (R2), R1 STEP_A: INC R2 DEC R0 BRANCH > 0 LOOP_A MOV R1,MAX_A MOV #B, R2 LOOP_B: MOV R1,R3 BRANCH < 0 STEP_B STEP_B: INC R2 BRANCH > 0 LOOP_B ADD MAX_A, R1 MOV R1,SOMMA

49 R0  #K CONT  #K MAX_A  #0 R1  #0 R0  #A R2  #A R1 [MAX_A] R3  [(R2)] – R1 R1  [(R0)] – R1 NO R3 < 0 ? NO R1 < 0 ? R1  [(R2)] SI R1  [(R0)] SI R2  [R2] + 1 MAX_A  [R1] R0  [R0] + 1 R0  [R0] - 1 R1  [CONT] SI R0 > 0 ? R1  [R1] - 1 NO NO SI MAX_A  [R1] R1 > 0 ? CONT  [R1]

50 CONT  #K MAX_A  #0 R0  #A R1 [MAX_A] MOV #K,CONT MOV #0,MAX_A MOV #A,R0 LOOP_A: MOV MAX_A,R1 SUB (R0),R1 BRANCH < 0 STEP_A MOV (R0),R1 MOV R1,MAX_A STEP_A: INC R0 MOV CONT,R1 DEC R1 BRANCH = 0 OUT_A MOV R1,CONT BRANCH LOOP_A OUT_A: R1  [(R0)] – R1 NO R1 < 0 ? R1  [(R0)] SI MAX_A  [R1] R0  [R0] + 1 R1  [CONT] R1  [R1] - 1 NO SI R1 > 0 ? CONT  [R1]

51 MOV #K,CONT MOV #0,MAX_A MOV #A,R0 LOOP_A: MOV MAX_A,R1 SUB (R0),R1 BRANCH < 0 STEP_A MOV (R0),R1 MOV R1,MAX_A STEP_A: INC R0 MOV CONT,R1 DEC R1 BRANCH = 0 OUT_A MOV R1,CONT BRANCH LOOP_A OUT_A: MOV #K,CONT MOV #0,MAX_B MOV #B,R0 LOOP_B: MOV MAX_B,R1 BRANCH < 0 STEP_B MOV R1,MAX_B STEP_B: INC R0 DEC R1 BRANCH = 0 OUT_B MOV R1,CONT BRANCH LOOP_B OUT_B: MOV MAX_A,R1 ADD MAX_B,R1 MOV R1,SOMMA

52 Altre Modalità di indirizzamento
Indirizzamento con autoincremento Indirizzo dell’operando è contenuto nel registro specificato. Dopo l’accesso all’operando, il contenuto del registro è Incrementato di 1 per puntare all’elemento successivo Della lista. ADD (R1)+, R0 Indirizzamento con autodecremento Il contenuto del registro è decrementato. Il nuovo Contenuto è usato come indirizzo dell’operando. ADD -(R1), R0

53 Altre Modalità di Indirizzamento (cont.)
Move #K, R1 Clear R0 Move #NUM1, R2 LOOP: Add (R2), R0 Inc R2 Dec R1 Branch > 0 LOOP Move R0,C Move #N, R1 Clear R0 Move #NUM1, R2 LOOP: Add (R2)+, R0 Dec R1 Branch > 0 LOOP Move R0,C

54 Altre Modalità di indirizzamento
Indirizzamento indicizzato Indirizzo dell’operando è ottenuto sommando un valore Costante (offset) al contenuto di un registro (registro indice) ADD 30(R0), R1 ADD 30(R0), R1 • R0 R1 800 200 830 1000 500 Offset = 30

55 Altre Modalità di indirizzamento
Indirizzamento indicizzato Indirizzo dell’operando è ottenuto sommando un valore Costante (offset) al contenuto di un registro (registro indice) ADD 10(R1), R0 ADD (R1, R2) , R0 ADD 10(R1, R2) , R0

56 Una centralina metereologica ha 3 sensori:
Problema 7 ? NUM LISTA N Ora 1 Umidità • Temperatura Pressione Ora 2 Ora N Una centralina metereologica ha 3 sensori: Temperatura, Pressione, Umidità. Ogni ora esegue le tre letture e le memorizza in locazioni di memoria consecutive. Il numero di letture effettuate è memorizzato in una locazione NUM. Scrivere un Programma che effettui la media Di tutte le misure relative allo stesso sensore.

57 Problema 7 (Soluzione) Mov #LISTA, R0 Mov NUM, R1 Clear R2 Clear R3 Clear R4 LOOP: Add 1(R0), R2 Add 2(R0), R3 Add 3(R0), R4 Add #4, R0 Dec R1 Branch > 0 LOOP Mov NUM, R1 Div R2, R1 Mov R1, MediaTemp Div R3, R1 Mov R1, MediaPress Div R4, R1 Mov R1, MediaUmid

58 Assemblatore Programma del sistema operativo che traduce la sequenza di istruzioni simboliche dell’utente (programma sorgente) in una sequenza di istruzioni in linguaggio macchina (programma oggetto). Esiste una corrispondenza 1 a 1 tra istruzioni Sorgenti e quelle oggetto. Ad 1 istruzione sorgente corrisponde 1 in linguaggio macchina

59 Assemblatore (cont.) C EQU 200 ORIGIN 201 N DATA 300 NUM1 RESERVE 300
100 MOVE N, R1 C EQU 200 ORIGIN 201 N DATA 300 NUM1 RESERVE 300 ORIGIN 100 START MOVE N,R1 MOVE #NUM1,R2 CLR R0 LOOP ADD (R2),R0 INC R2 DEC R1 BGTZ LOOP MOVE R0,C RETURN END START 101 MOVE #NUM1, R2 102 CLEAR R0 LOOP 103 ADD (R2) , R0 104 INC R2 105 DEC R1 106 Branch > 0 LOOP 107 MOVE R0, C 108 • C 200 N 201 300 202 NUM1 203 NUM2 • 501 NUMK

60 Organizzazione dei dati
NUM LISTA N Ora 1 Umidità • Temperatura Pressione Ora 2 Ora N LISTA o ARRAY

61 Organizzazione dei dati (cont.)
STACK o PILA E’ una lista di dati in cui gli elementi possono essere Inseriti o letti solo da una estremità (TOP). L’estremità Opposta è detta BOTTOM. LIFO (Last-In-First-Out)

62 Organizzazione dei dati: STACK
100 PUSH (Inserimento) Dec SP Move LOC,(SP) 101 102 100 Current TOP (Stack Pointer) 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • POP (Estrazione) Move (SP),LOC Inc SP 200 201 202 203 • 501

63 Organizzazione dei dati: STACK
100 PUSH (Inserimento) Dec SP Move LOC,(SP) 101 102 100 SP 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 1000 SP= 102 200 201 202 203 • 501

64 Organizzazione dei dati: STACK
100 PUSH (Inserimento) Dec SP Move LOC,(SP) 101 SP 102 100 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 1000 SP= 101 200 201 202 203 • 501

65 Organizzazione dei dati: STACK
100 PUSH (Inserimento) Dec SP Move LOC,(SP) 101 1000 SP 102 100 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 1000 SP= 101 200 201 202 203 • 501

66 Organizzazione dei dati: STACK
100 POP (Estrazione) Move (SP),LOC Inc SP 101 102 100 SP 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 222 SP= 102 200 201 202 203 • 501

67 Organizzazione dei dati: STACK
100 POP (Estrazione) Move (SP),LOC Inc SP 101 102 100 SP 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 100 SP= 102 200 201 202 203 • 501

68 Organizzazione dei dati: STACK
100 POP (Estrazione) Move (SP),LOC Inc SP 101 102 100 103 -38 SP 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 100 SP= 103 200 201 202 203 • 501

69 Organizzazione dei dati (cont.)
QUEUE o CODA E’ una lista di dati in cui gli elementi sono inseriti da una estremità (START) e letti da quella opposta è detta (END). FIFO (First-In-First-Out)

70 Organizzazione dei dati: QUEUE
100 PUSH (Inserimento) Inc END Move LOC,(END) 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 • POP (Estrazione) Move (START),LOC Inc START 200 201 202 203 • 501

71 Organizzazione dei dati: QUEUE
100 PUSH (Inserimento) Inc END Move LOC,(END) 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 • LOC = 1000 END = 108 200 201 202 203 • 501

72 Organizzazione dei dati: QUEUE
100 PUSH (Inserimento) Inc END Move LOC,(END) 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 108 200 109 END 200 LOC = 1000 END = 109 201 202 203 • 501

73 Organizzazione dei dati: QUEUE
100 PUSH (Inserimento) Inc END Move LOC,(END) 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 108 200 109 1000 END 200 LOC = 1000 END = 109 201 202 203 • 501

74 Organizzazione dei dati: QUEUE
100 POP (Estrazione) Move (START),LOC Inc START 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 • LOC = 1000 START = 102 200 201 202 203 • 501

75 Organizzazione dei dati: QUEUE
100 POP (Estrazione) Move (START),LOC Inc START 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 • LOC = 100 START = 102 200 201 202 203 • 501

76 Organizzazione dei dati: QUEUE
100 POP (Estrazione) Move (START),LOC Inc START 101 102 100 103 -38 START 104 25 105 738 106 15 107 1002 END 108 200 • LOC = 100 START = 103 200 201 202 203 • 501

77 Organizzazione dei dati: QUEUE con Buffer Circolare
100 BufStart PUSH (Inserimento) Inc END Cmp END,BufEnd Branch > 0 INIT Move LOC,(END) Return INIT Move #BufStart,END 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 109 200 201 BufEnd 202 203 • 501

78 Organizzazione dei dati: QUEUE con Buffer Circolare
100 BufStart 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 POP (Estrazione) Move START,LOC Inc START Cmp START,BufEnd Branch > 0 INIT Return INIT Move #BufStart,START 109 200 201 BufEnd 202 203 • 501

79 SUBROUTINE Ordinamento decrescente di numeri positivi
max(int *a,int *ind) { int max; int i; max=a[0]; ind=0; for (i=1;i<5;i++) { if (a[i] > max) { max=a[i]; *ind=i; } return; main() { int lista[5]={5,10,4,7,3}; int ord[5]={0,0,0,0,0}; int pos=0; int posmax; int i; for (i=0;i<5;i++) { max(lista,&posmax); ord[pos]=lista[posmax]; pos++; lista[posmax]=0; }

80 SUBROUTINE PC Link Register 100 101 102 102 103 104 105 106 107 108
• PC 101 • 102 Call MAX 102 103 Istruz. Success. 104 • 105 • 106 END 107 108 Link Register 109 200 Sub MAX Istruz. 1 201 202 Istruz. 2 203 • Return 501

81 SUBROUTINE PC Link Register 100 101 102 102 103 104 105 106 103 107
• PC 101 • 102 Call MAX 102 103 Istruz. Success. 104 • 105 • 106 END 103 107 108 Link Register 109 200 Sub MAX Istruz. 1 201 202 Istruz. 2 203 • Return 501

82 SUBROUTINE PC Link Register 100 101 102 200 103 104 105 106 103 107
• PC 101 • 102 Call MAX 200 103 Istruz. Success. 104 • 105 • 106 END 103 107 108 Link Register 109 200 Sub MAX Istruz. 1 201 202 Istruz. 2 203 • Return 501

83 SUBROUTINE PC Link Register 100 101 102 103 103 104 105 106 103 107
• PC 101 • 102 Call MAX 103 103 Istruz. Success. 104 • 105 • 106 END 103 107 108 Link Register 109 200 Sub MAX Istruz. 1 201 202 Istruz. 2 203 • Return 501

84 SUBROUTINE 1 - Passaggio dei parametri 2 - Procedure Annidate PC
100 Call MAX 101 102 103 104 105 106 107 108 Return 200 201 202 203 501 109 • END Istruz. Success. Sub MAX Call SUB1 Istruz. 2 Sub SUB1 1 - Passaggio dei parametri 2 - Procedure Annidate PC Link Register

85 SUBROUTINE PC 100 • 200 101 • 102 Call MAX 103 Istruz. Success. 104 • 105 • STACK 106 END 107 108 109 200 Sub MAX 201 Call SUB1 202 Istruz. 2 203 Return 501 Sub SUB1 103 Bottom

86 SUBROUTINE PC 100 • 501 101 • 102 Call MAX 103 Istruz. Success. 104 • 105 • STACK 106 END 107 108 109 200 Sub MAX 201 Call SUB1 202 Istruz. 2 203 Return 202 501 Sub SUB1 103 Bottom

87 SUBROUTINE Passaggio dei parametri main() { int lista[5]={5,10,4,7,3};
int ord[5]={0,0,0,0,0}; int pos=0; int posmax; int i; for (i=0;i<5;i++) { max(lista,&posmax); ord[pos]=lista[posmax]; pos++; lista[posmax]=0; } STACK posmax lista Indirizzo di ritorno Bottom

88 SUBROUTINE Passaggio dei parametri 100 Move #LISTA, -(SP)
101 Move N, -(SP) 102 Call LISTADD 103 Move 1(SP),SOMMA STACK 103 Top K LISTA Bottom

89 SUBROUTINE Passaggio dei parametri 100 Move #LISTA, -(SP)
101 Move N, -(SP) 102 Call LISTADD 103 Move 1(SP),SOMMA LISTADD Move_Mult R0-R2, -(SP) Move 4(SP),R1 Move 5(SP),R2 Clear R0 LOOP Add (R2)+,R0 Dec R1 Branch > 0 LOOP Move R0, 5(SP) Move_Mult (SP)+,R0-R2 Return [R2] Top [R1] [R0] 103 K LISTA Bottom

90 Riepilogo Organizzazione della Memoria e dei Registri
(lunghezza della word, big-endian,ecc.) Struttura delle istruzioni Metodo di Indirizzamento Organizzazione dei dati Controllo di flusso del programma

91 Motorola 68000

92 Motorola 68000:Memoria Lunghezza word = 16 bit
Gestisce anche i byte e le Longword (32 bit) word Byte Il ha 64 bit 16 bit per i dati 24 bit per indirizzi 24 bit per controllo e aliment. 1 2 15 8 2 224-2 Spazio indirizzamento 16 MB Big-Endian

93 Motorola 68000: Registri Longword A0 word Byte A1 D0 A2 D1 A3 D2 A4 D3
31 A0 A1 A2 A3 A4 A5 A6 A7 SP allo stack Utente SP allo Stack Supervisore SR

94 Motorola 68000: Indirizzamento
100 Istruzione 101 102 103 104 105 106 107 108 Array 2 200 201 202 203 501 109 • END Istruz. Success. N Data Array 1 Array N Bval Rm PC Immediate #val Short Absolute val (word) Long Absolute val (Longword) Register Rn Indirect Register (An) Autoincrement (An)+ Autodecrement -(An) Indexed Wval(An) Extended Indexed Bval(An,Rm.S) Relative Wval(PC) Extended Relative Bval(PC,Rm.S)

95 Motorola 68000: Formato Istruzioni
ADD #9,D3 15 12 9 7 6 5 dst src opcode size Opcode ADD Registro 3 word Immediate D C D67C 9

96 Motorola 68000: Formato Istruzioni
63910 B=201152 -21510 201200 Opcode word MOVE A, D0 201202 20 201204 1150 201206 Opcode word 201208 20 ADD B, D0 20120A 1152 20120C Opcode word 20 MOVE D0, C 20120E 201210 2200 201212 C=

97 Motorola 68000: Assemblatore
EQU C EQU $ ORG ORG % DC.S A DC.W 639 A DC.L STR DC.L “ALBA” DS.S ARRAY DS.W 200 ARRAY DS.L 200

98 Motorola 68000: Controllo di Flusso
Status Register 0 = C (carry) 1 = V (overflow) 2 = Z (zero) 3 = N (negative) 4 = X (Extension) 8-10 = Interrupt mask 13 = S (Supervisor Mode) 15 = T (Trace Mode – Debugger) C=

99 Motorola 68000: Salti LOOP ADD.W (A2)+,D0 SUBQ.W #1, D1 BGT LOOP
1002 1004 1006 Opcode word Opcode -6 LOOP ADD.W (A2)+,D0 SUBQ.W #1, D1 BGT LOOP DBGT D1,LOOP LOOP ADD.W (A2)+,D0 DBGT D1,LOOP

100 Motorola 68000: Subroutine STACK MOVE.L PARAM1,-(A7)
2010 BSR SUB1 MOVE.L 4(A7),RISULTATO ADDI.L #8,A7 Prima Procedura 2100 SUB1 MOVEM.L D0-D2/A0-A1,-(A7) MOVEA.L 28(A7),A0 ……….. MOVE.L PARAM3,-(A7) BSR SUB2 ADDI.L #4,A7 ………. MOVE.L D2,28(A7) MOVEM.L (A7)+,D0-D2/A0-A1 RTS Seconda Procedura SUB2 MOVE.L D0,-(A7) MOVE.L (A7)+,D0 1046 STACK PARAM1 [D0] da SUB PARAM3 PARAM2 2012 2154 [D0] da SUB1 [D1] da SUB [D2] da SUB [A0] da SUB [A1] da SUB 1042 1038 1034 1030 1026 1022 1018 1014 1010 1006

101 PowerPC 601

102 PowerPC: Architettura
Instruction Management Unit Floating Point ALU Integer ALU CACHE RAM

103 PowerPC:Memoria Lunghezza word = 32 bit
Gestisce anche i byte, Halfword (16 bit), Doubleword (64 bit) Double word word Halfword 1 2 3 4 5 6 7 8 15 31 32 63 232-8 Big-Endian Spazio indirizzamento 4 GB

104 PowerPC: Registri FR0 FR1 • FR31 63 R0 CTR R1 31 R2 CR • 31 XER 31 R31
63 R0 CTR R1 31 R2 CR • 31 XER 31 R31 LINK 31 31

105 PowerPC: Istruzioni Istruzioni che trasferiscono dati tra memoria e registri (Load e Store) Istruzioni Aritmetico-Logiche tra i registri R0-R31 (2 o 3 operandi) Istruzioni per il controllo di flusso Istruzioni in floating-point Istruzioni per il controllo del processore (Cache,I/O,ecc.)

106 PowerPC: Indirizzamento
Indexed HWval(Rn) Register Indexed (Rn,Rm)

107 PowerPC: Controllo di Flusso
31 CR 31 XER CR XER 0 = LT (1 se risultato < 0) 1 = GT (1 se risultato > 0) 2 = EQ (1 se risultato = 0) 3 = SO (Summary Overflow) 0 = SO (Summary Overflow) 1 = OV (Overflow) 2 = CA (Carry) C=

108 PowerPC: Salti B Salto Incondizionato all’indirizzo specificato
BC Salto all’indirizzo specificato se verificata la condizione (BGT, BLT, BEQ, BNE, ecc.) Indirizzamento nel salto Relativo offset con l’istruzione destinaz. Specificata Assoluto destinazione Specificata Indiretto a Registro destinaz. Specificata in registro

109 PowerPC: Subroutine Non esiste una istruzione specifica di chiamata a subroutine. Esiste una istruzione di ritorno (BLR) Ogni istruzione di salto memorizza l’indirizzo di ritorno nel LINK Register Per le procedure annidate e passaggio dei parametri, ad ogni procedura È riservata un area sullo stack (stack frame) a gestione della procedura

110 IA-32

111 IA-32: Evoluzione 8086-8088 (1978): 16 bit , segmentation
80286 (1982): 24 bit, protected mode, virtual memory 80386 (1985): 32 bit, parallelism 80486 (1989): more parallelism, cache, FPU Pentium (1993): two pipeline, more cache, data paths da 128 e 256 bits, dual processor Pentium P6 ( ): (Pro, II, Celeron, III, III Xeon): two cache, more pipeline, MMX, SIMD Pentium 4 ( ) (4, Xeon, M): Netburst, Hyperthreading

112 IA-32:Memoria Lunghezza word = 32 bit
Gestisce anche i byte, Halfword (16 bit), doubleword (64 bit), Fpword (80-bit) word Halfword Spazio indirizzamento 4 GB 3 2 1 4 31 15 Memoria Segmentata 232-4 Little-Endian

113 IA-32: Operating Mode Protected Mode: 64GB di Memoria
Real Address Mode: 4GB Memoria System Management Mode

114 IA-32: Registri General Purpose Register Segment Register EAX EBX ECX
EDX EBP ESP ESI EDI AL AH AX Segment Register CS DS ES FS GS SS 16 31 EFLAGS EIP

115 IA-32: Indirizzamento Immediate Es: ADD EAX ,14
Register All Register (EAX,AX,AL,AH) Memory: Segment Selector (CS,SS,DS,ES) Indirizzo nel segmento (Offset) MOV ES:[EBX], EAX

116 IA-32: Indirizzamento (cont.)
Offset (Indirizzo effettivo): Base + (index*scale)+displacement Base = registro (EAX,EBX,ECX,EDX,ESP,EBP,ESI,EDI) Index = registro (EAX,EBX,ECX,EDX,EBP,ESI,EDI) Scale = numero (1,2,4,8) Displacement = numero (none, 8-bit, 16-bit, 32-bit)

117 IA-32: Istruzioni General Purpose Instructions FPU e SIMD Instructions
MMX Instructions SSE,SSE2,SSE3 Instructions System Instructions

118 IA-32: controllo di flusso
Condizioni verificate con EFLAGS register bits

119 IA-32: Subroutine CALL e RET (Near CALL, far CALL) ENTER e LEAVE

120 IA-32: Program Template TITLE <nome programma> (templat.asm)
; Autore ; Data ; Revisione INCLUDE <nome file> .data < dichiarazioni dei dati> .code main PROC < istruzioni> Main ENDP < procedure> END main

121 Esempio: somma e differenza (versione 2)
TITLE Somma e Sottrai (addsub.asm) ; Questo programma somma e sottrae tre interi .code main PROC mov eax, 10000h ; Eax= 10000h add eax, 40000h ; Eax = Eax+40000h sub eax, 20000h ; Eax = Eax-20000h main ENDP END main

122 Esempio: somma e differenza
TITLE Somma e Sottrai (versione2) (addsub2.asm) ; Questo programma somma e sottrae tre interi .data val1 DWORD h val2 DWORD h val3 DWORD h risul DWORD ? .code main PROC mov eax, val1 ; Eax= 10000h add eax, val2 ; Eax = Eax+40000h sub eax, val3 ; Eax = Eax-20000h mov risul,eax main ENDP END main

123 IA-32: Altri comandi Costanti const EQU 100 const = 100 Array
list BYTE ,20,30,40 var2 DWORD 10 DUP(0) var2 DWORD 10 DUP(?)

124 Esempio: somma e differenza in Real-address mode
TITLE Somma e Sottrai (versione2) (addsub2.asm) ; Questo programma somma e sottrae tre interi .data val1 DWORD h val2 DWORD h val3 DWORD h risul DWORD ? .code main PROC mov mov ds,ax mov eax, val1 ; Eax= 10000h add eax, val2 ; Eax = Eax+40000h sub eax, val3 ; Eax = Eax-20000h mov risul,eax main ENDP END main