Arquitectura Q

● Tiene 8 registros de uso general de 16 bits: R0…R7

● Tiene direcciones de 16 bits
● Lo operandos pueden estar en registros, ser constantes o estar en direcciones de
memoria
● Permite 3 modos de Direccionamiento:
Modo Registro: el valor buscado está en un registro
Modo Inmediato: el valor está codificado dentro de la instrucción
Modo Directo: el valor buscado está contenido en una celda de memoria
Modo Indirecto: la dirección del valor buscado está contenido en una celda
de memoria
Modo Registro Indirecto: la dirección del valor buscado está contenido en un
registro

Flags y Saltos Q4
hay que alterar el PC mediante instrucciones especiales: Con Saltos

Categoría de saltos:
Salto Relativo: el valor del PC se desplaza hasta llegar a la dirección teniendo que pasar por
otras direcciones antes, EL PC SE INCREMENTA EN 1

Salto Absoluto: el PC sabe exactamente a qué dirección ir y puede saltarse varias

direcciones

Saltos Incondicionales: tiene que saltar, no importa las condiciones, es un salto de Orden

Saltos Condicionales: va a ver los flags para hacer un salto

Ej:

Salto condicional → Relativo

Salto Incondicional → Absoluto

Q5 agrega: 2 operandos nuevos CMP, JMP y agrega Saltos condicionales y Relativos

CMP: compara (hace una resta)
JMP: hace un salto incondicional y absoluto
cualquier instrucción que resulta la ALU modifica los flags (ADD, SUB, DIV, MUL)
Saltos condicionales (relativo)

Prefijo(1111) Código Operación(4) Desplazamiento (8)

Salto Codigo de Descripción Condición

Operacion

JE 0001 igual/cero Z

JNE 1001 no igual ¬Z

JLEU 0100 menor o igual sin CvZ

signo

JGU 1100 mayor sin signo ¬(C v Z)

JCS 0101 menor sin singo C

JNEG 0110 negativo N

JVS 1010 Overflow V

JLE 0010 Menor o igual con Z v (N or V)

signo

JG 1010 Mayor con signo ¬((Z v (N or V))

JL 0011 Menor con signo N or V

JGE 1011 Mayor o igual con ¬(N or V)

signo
 Repeticiones y Arreglos Q5

Estructura general:
Inicialización
arriba: Controlar Condición de ciclo
Si no se cumple: <salir>
Cuerpo del ciclo
Volver <arriba>
salir: Finalizar programa

EJ
inició el resto = 14
controlar si resto es mayor a 3
si NO se cumple la condición, salir
Restar: resto = resto -3
volver al paso 2

Mov R1, 0x000E

arriba CMP R1, 0x0011
JL fin
SUB R1, 0x0011
JMP arriba
fin: RET

Estructura de control
estructuras que permiten controlar el flujo de secuencialidad de un programa
¿cómo guardo los datos?
con Arreglos
Arreglos:
son posiciones de memoria de manera consecutiva, donde el tamaño del arreglo tienen el
mismo tamaño, sea en forma secuencial como en la primera imagen(6) o pedazos
elementos (3) es el mismo tamaño los 2 arreglos pero agrupan diferente los elementos

el arreglo termina donde haya una condición de fin

Modo Indirecto:
por registro: [Rx] (contiene un valor de memoria)

ej MOV R0, [R5] ←– se tiene que ir a fijar que hay dentro del Indirecto [R5] dentro de [R5] hay
una dirección que tiene que ir a buscar a memoria
hace 1 acceso a memoria

Indirectos: [[0xHHHH]]
primero va a ir a dirección de memoria del primer corchete [0xFFFF] y va a tener un valor y
eso va a ser una nueva dirección de memoria

empieza en FFFF pero termina en el A0A0

hace 2 acceso a memoria

Q5 agrega: 2 modos de direccionamientos nuevos

Modo Directo: el valor buscado está contenido en una celda de memoria
 Modo Indirecto: la dirección del valor buscado está contenido en una celda
de memoria
Modo Registro Indirecto: la dirección del valor buscado está contenido en un
registro

Indirecto: 011000
Registro Indirecto: 110rrr

MOV R0, 050

CMP RO, 0x0000
JE fin

REPASO
Fórmulas
tasa de acierto: Ta
tasa de acierto: Tf

para sacar tasa de acierto es Ta= a/n =

Tasa de fallos: f/N =

Tiempo total de acceso: n(ta×tc + tf(TC+tm)) →

n(tasa de aciertos × tiempo caché + tasa de fallos (tiempo acceso a caché + tiempo de acceso a
memoria)

MOV R4, 0x0002

ciclo: CMP R4, 0x0000
JNE continuar
RET
continuar: ADD R3, [0x7A09]
SUB R4, 0x0001
JMP ciclo
palabra= índice

0001 100 100 000000

0000 0000 0000 0010
0110 100 100 000000
0000 0000 0000 0000
1111 1001
1100 0000 0000 0000
0010 100 011 001000
0111 1010 0000 1001
0011 100 100 000000
0000 0000 0000 0001
1010 000000 000000

0xCA09

0xCA09 0001 100 100 000000 0001 100 100 000000

0xCA0A 0000 0000 0000 0010

0xCA0B 0110 100 100 000000

0xCA0C 0000 0000 0000 0000

0xCA0D 1111 1001 0000 0001

0xCA0E 1100 0000 0000 0000

0xCA0F 0010 100 011 001000

0xCA10 0111 1010 0000 1001

0xCA11 0011 100 100 000000

0xCA12 0000 0000 0000 0001

0xCA13 1010 000000 000000

0xCA14 1100 1010 0000 1011

 dirección tag línea palabra a/f

0xCA09 CA 0 9 f

0xCA0A CA 0 A a

0xCA0B ca 0 b a

0xCA0C ca 0 c a

0xCA0D ca 0 d a

0xCA0F ca 0 f a

0xCA10 ca 1 0 f

0xCA11 ca 1 1 a

0xCA12 ca 1 2 a

0xCA13 ca 1 3 a

0xCA14 ca 1 4 a

0xCA0B ca 0 b f

0xCA0C ca 0 c a

0xCA0D ca 0 d a

0xCA0F ca 0 f a

0xCA10 ca 1 0 f

0xCA11 ca 1 1 a

0xCA12 ca 1 2 a

0xCA13 ca 1 3 a

0xCA14 ca 1 4 a

0xCA0B ca 0 b f

0xCA0C ca 0 c a

0xCA0D ca 0 d a

0xCA0E ca 0 e a
si no cambia el tag y la línea pero si cambia la palabra entonces es un fallo con desalojo
.
n(ta×tc + tf(TC+tm))
tasa de acierto: Ta
tasa de acierto: Tf

n: total = 24
a: aciertos = 19
f: fallos =5

para sacar tasa de acierto es Ta= a/n = 19 /24

Tasa de fallos: f/N = 5 /24

a) 1010 000 000 000000

1100 1010 0000 1011

b) Ta= a/n = 19 /24

c) 1111 1001 0000 0001

Xs=tiempo de acceso (lo que tarda en recorrer todo el programa)

tm = Xs
TC = 0,3 ( segundos del caché)
TA= 93% (Tasa de Aciertos) 1000*0,93 = 930 Aciertos
fallos=M(cantidad de accesos a memoria 1000) - 930(la cantidad de Aciertos) =70

1000(930×0,3 + 70(0,3+tm))
n es la cantidad de accesos a cache
 Linea / Tag
F1 /C
F1 /A
F1 /C

CACHE Q6
¿Qué es caché?
es una memoria que está entre CPU y RAM
● provee una velocidad de acceso parecida a los registros
● provee un mayor tamaño de memoria
 ¿Cómo trabaja el cpu con el caché y la ram?

el CPU le pide una lectura de celda al CACHE y el CACHÉ si tiene el dato entonces se lo
pasa al CPU.
De ser lo contrario y el CACHE no tenga el dato solicitado por la CPU entonces tendrá que
ir a leer a la Memoria Principal, almacenar el dato en caché y enviarlo al CPU

la RAM es más lento que el procesador por eso necesita una memoria de por medio para
que sea más rápido la memoria CACHÉ
 hacer memorias rápidas son muy caras y tiene poco espacio
Volatilidad: la memoria es volátil cuando la memoria se queda sin energía y se borra todos
los datos y no almacena información

Métodos de acceso
Secuencial: la memoria debe recorrer secuencialmente para buscar el dato

Directo: accede directamente a la zona próxima del registro a buscar

Aleatorio: el acceso porque tarda lo mismo en llegar a cualquier celda de la memoria
Asociativo: se busca un patrón o tag en un conjunto de bits de 1 celda y el acceso es
constante.
 jerarquia de memorias

Principio de Localidad

Localidad Espacial
La posiciones más cercanas son las más probables de ser referenciadas que las distantes
cuando estás recorriendo un arreglo lo más probable es que vas a acceder a una dirección
más cercana a la que estas

Localidad Temporal
cuando un programa hace referencia a una posición de memoria, se espera que vuelva a
hacerlo en poco tiempo

Como registra la caché las celdas cacheadas

ALmacena una etiqueta (tag) que identifica cada celda

Tag Contenido de la celda de memoria

Memoria Asociativa

Función de Correspondencia o Mapeo

● una memoria de 26 = 64 celdas
 ● un tamaño de bloque de 4 celdas ⟶ 16 bloques
● una cache de 8 ranuras de 4 celdas cada una

- para saber la cantidad de celdas que hay la cuenta que hay que hacer es
los Bytes o bits de la celda / el tamaño del bloque

Correspondencia Directa (Mapeo Directo)

cada una de las ranuras se corresponde a un determinado bloque de memoria

tag (1b) linea (3b) palabra *indice*(2b)

EJ
● memoria principal de 16 celdas 1 Byte cada una
● memoria cache de 4 líneas
● bloques de 1 celda
● función de correspondencia directa
¿qué tamaño tiene el tag?

por cada línea va a entrar 4

16 celdas= 16 bloques repartidos en 4 líneas

16/4=4 bloques por línea
se debe distinguir cual de los 4 bloques es el que está

Ventajas: simple y económico para implementar. No requiere memoria de acceso aleatorio

Desventajas: si un programa accede reiteradamente a palabra diferentes bloques pero que

se corresponde a la misma ranura ocurren muchos fallos
 Correspondencia Asociativa (Mapeo Asociativo)
● cualquier bloque puede almacenarse en cualquier ranura
● el tag corresponde al número de bloque
● el tag tiene que ser el número de bloque completo

tag (4b) palabra (2b)

fallo con desalojo: misma línea diferente tag

fallo normal: diferente tag

Desalojo y Escritura

Políticas de desalojo:
son las que van a marcar donde va a guardar los datos cuando el mapeo no es directo
● Algoritmo LRU (Least REcently Used = Menos recientemente usado):
se reemplaza el bloque que fue usado hace más tiempo (tiene que guardar cuando
fue la última vez que se consultó esa línea en memoria caché)

● Algoritmo FIFO (First in - FIrst Out = el primero que llega es el primero que se va)
se reemplaza el bloque de celda en memoria cache que estuvo almacenada por mas
tiempo
● Algoritmo LFU (Least Frequently Used = menos frecuentemente usado)
se reemplaza el bloque que accedió menos veces

● Algoritmo Random
reemplaza al azar, menos performante, no necesita información extra

Políticas de Escritura:
¿Cómo escribo en memoria caché?
● Write through: Se escribe inmediatamente a memoria entonces las escrituras no se
benefician de caché, cada vez que tengo que escribir entro a memoria principal

● Write back: se marca la celda como sucia(es información extra que debemos
guardar) Cuando el bloque de esa celda es desalojado, escribe a memoria. (Escribo
en memoria caché en vez de escribir en principal)
 REPASO DE RECUPERATORIO
parcial 2
4)
test MOV RO, 0x0002
arriba: CMP RO, 0x000
JE fin
MOV R5,[R1]
ADD R3,R5
SUB R0, 0x0001
JMP arriba
fin: RET

Empieza 0xAD90
4 bits para tag, 8 de bits para linea, 4 bits para palabra (DIRECTO)
la pila almacena el valor de retorno de test, SP contiene 0xFFEE
PC se encuentra en 0xAD90
R1 0xCD91

0xAD90 0001 100 000 000000

0xAD91 0000 0000 0000 0010

0xAD92 0110 100 000 000000

0xAD93 0000 0000 0000 0000

0xAD94 1111 0001 0000 0110

0xAD95 0001 100 101 110 001

0xAD96 0010 100 011 100 101

0xAD97 0011 100 000 000000

0xAD98 0000 0000 0000 0001

0xAD99 1010 00000 000000

0xAD9A 1010 1101 1001 0001

0xAD9B 1100 0000 0000 0000

test MOV RO, 0x0002

arriba: CMP RO, 0x000
JE fin
MOV R5,[R1]
ADD R3,R5
SUB R0, 0x0001
JMP arriba
fin: RET

dirección tag 4 línea 8 palabra 4 f/a f/a f/a

 0xAD90 a d9 0 f

0xAD91 a d9 1 a

0xAD92 a d9 2 a a a

0xAD93 a d9 3 a a a

0xAD94 a d9 4 a a a

0xAD95 a d9 5 a a

0xCD91 C D9 1 F F

0xAD96 a d9 6 f f

0xAD97 a d9 7 a a

0xAD98 a d9 8 a a

0xAD99 a d9 9 a a

0xAD9A a d9 A a a

0xAD9B a d9 b - a

FFEE f fe e f

5)Formulas de tiempo total

T= n(ta×tc + tf(TC+tm)) tiempo total
T=n.tc+f.tm =TiempoTotal
T=a.tc+f.(tm+tc) =TiempoTotal
ta acceso 100ms
memoria cache 3ms
aciertos 75% /* siempre dividir por 100*/
celdas 200
fallos 25%

T= 200(0,75 . 3+ 0,25(3+100))
200.(2,25 + 0,25 .103)
200.(2,25+25,75)
200.28
5,600

3(
cuantos bits necesita tag, línea y palabra

● directo
 ● memoria cache: 256 líneas con un bloque por línea =2a la8 linea
● bloques de celda: 32 = 2a la5 palabra
● bus de direcciones: 16 bits
● lo que sobra es tag

1 2 4 8 16 32 64 128 256 512 1024

0123 4 5 6 7 8 9 10
||||||||||||||||
palabra5
linea8
tag3

1) realiza control de calidad sobre sus vinos de primera seleccion, la normativa dice
que la botella de vino se encuentra en su apogeo para el consumo, si la fecha de
envasado tiene entre 3 y 12 años. La bodega almacena información sobre sus
productos en cadena de 16 bits, donde el Byte más significativo representa el tipo de
vino y el byte menos significativo la cantidad de años han pasado desde que fue
envasado.
● vino tinto - 01111001
● vino blanco - 11111010 FA 05
● vino rosa - 10010110 96
vino blanco: FA05
info de producto en R4
devuelve 1 en R0 si el vino está apogeo
0 en R0 si no esta apogeo

data:
96VinoRosa
mayor = 3 /*salvar 3 veces los 3 valores*/
menor = 12

MOV R3, R4
MOV R2, R4
MOV R1, R4
● 10010110
f e d c b a 00000000

RutinaVino MOV R0, 0x0000

MOV R2, R4
MOV R3, R4
MOV R5, R4
AND R2, 0xFF00 /*se asegura que el vino rosa*/
CMP R2, 0x9600
JE elVinoEsRosado
JMP fin
 elVinoEsRosado: AND R3, 0x00FF
CMP R3, 0x0003
JGE comprobarAniejamiento
JMP fin
comprobarAniejamiento AND R5, 0x00FF
CMP R5, 0x000C
JLE esAniejo
JMP fin
esAniejo MOV R0, 0x0001
fin RET

2) longitud se encuentra en R0 y comienza en la celda 0x25D0

guarde en R1 la cantidad total de vinos rosados en su apogeo

ESTRUCTURA ARREGLO
índice /*dice dónde empieza*/
contador /**/
longitud
condición de fin
resuelve el programa si no se cumple condicion de fin
fin

MOV R7, R0 /*longitud*/

MOV R2, 0x25D0 /* indice */
MOV R3, 0x0000 /*contador*/
VinosEnApogeo:CMP R7, 0x0000
JE fin
MOV R4, [R2]
CALL RutinaVino
ADD R3, R0
SUB R7,0x0001 /*disminuye en 1 la cantidad de veces que va a tener que recorrer*/
ADD R2, 0x0001 /*incrementa la celda de memoria en 1(indice)*/
JMP VinosEnApogeo
fin: RET
PARCIAL 1
 1) implementar una rutina superficieDelTrapecio que dado el tamaño de la base
menor (b) en R0, la base mayor (B) en R1 y en la altura (h) en R2 calcule la
superficie de trapecio. la fórmula es Sup =h - (b+B) /2

a) documentar rutina superficieDelTrapecio y almacena resultado en R3

b) no implementar la rutina superficieDelTrapecio que cumple con la
documentacion
Requiere en R6 el valor a imprimir en pantalla
retorna -
Modifica R3

superficieDelTrapecio
a)
R3 = R2 - (R0 + R1) / 2

ADD R0, R1
DIV R0, 0x0010
SUB R2, R0
MOV R3, R2
RET

b)
MOV R0, [0x1FE0]
MOV R1, [0x1FE2]
MOV R2, [0x1FE3]
CALL superficieDelTrapecio /*main*/
MOV R6, R3
CALL imprimirSuperficie
RET

0x1FE0, 0x1FE2, 0x1FE3 se encuentra almacenado la base menor, la base mayor y la

altura para calcular la superficie de un Trapecio, implementar un rutina main que utilizando
superficieDelTrapecio e imprimirSuperficie impra el valor SUP
3) mapa: PC = 00F0
dirección rutina

00F0 7208

00F1 7777

00F2 7778

….

7777 000F

7778 0004

a)
0111 0010 0000 1000
0111 0111 0111 0111
0111 0111 0111 1000

DIV [0x7777], [0x7778]

b) búsqueda de instrucción(bi): 3 accesos a memoria

búsqueda de operandos(bo): 2 operandos, fue 2 veces a buscar a memoria
almacenamiento de resultado: 1 acceso en memoria

4)
rutinaA: SUB R1, R2
CALL rutinaB
RET

returinaB: DIV R1, [0xCC12]

RET

programa: MOV R1, 0x3448

MOV R2, 0xE010
CALL rutinaA

● programa se encuentra ensamblado a partir de la celda 0xB0B0

● rutinaA se encuentra ensamblada a partir de la celda 0xCD07
● rutinaB se encuentra ensamblado a partir de la celda 0x123F
● la pila inicialmente tiene apilado a dirección 0001, es decir, SP apunta a FFEE
● la celda 0xCC12 contiene el valor 0x0101

¿Cómo varía la pila durante la ejecución del programa program? complete el cuadro
usualmente utilizado

rutinaA 0111 100 001 100 010 7862

1011 000000 000000 B000
0001 0010 0011 1111 123F
1100 0000 0000 0000 C000
 rutinaB 0111 100 001 001000 7848
1100 1100 0001 0010 CC12
1100 0000 0000 0000 C000

programa 0001 100 001 000000 1840

0011 0100 0100 1000 3448
0001 100 010 000000 1840
1110 0000 0001 0000 E010
1011 000000 000000 B000
1100 1101 0000 0111 CD07

pc ir pc2 opera modo modo opera operan pila sp pc3

ción destin orige ndo do
o n destin origen
o

0xB0B0 1840 0xB0B2 MOV registr inmed R1 0x3448 {0001} FFEE 0xB0B2
3448 o iato

0xB0B2 1840 0xB0B4 MOV registr inmed R2 0xE010 {0001} FFEE 0xB0B4
E010 o iato

0xB0B4 B000 0xB0B6 CALL - inmed - 0xCD0 {0001 FFED 0xCD07

CD07 iato 7 0xB0B6
}

0xCD07 7862 0xCD08 SUB registr regist R1 R2 {0001 FFED 0xCD08

o ro 0xB0B6
}

0xCD08 B000 0xCD0A CALL - inmed - 123F {0001 FFEC 123F

123F iato 0xB0B6
0xCD0
A}

0x123F 7848 0x1241 DIV registr direct R1 [0xCC1 {0001 FFEC 0x1241
CC12 o o 2] 0xB0B6
0xCD0
A}

0x1241 C000 0x1242 RET - - - - {0001 FFED 0xCD0A

0xB0B6
}

0xCD0A C000 0xCD0B RET - - - - {0001 FFEE 0xB0B6

}
5)
a) considere un sistema Exc(exceso)(12/*cantidad de bits*/,128/*el delta*/) y
responda las siguientes preguntas
● ¿Cuál es el valor máximo representable del sistema?
● ¿Qué cadena representa el nro -83?
b) considere un sistema SM(8,3(3bits para numero con coma)) y responda las
siguientes preguntas
● ¿Cuál es el rango del sistema?
● interpretar la siguiente cadena 01011100

rango de exceso: números más grandes es todo 1 y el mínimo es todo 0

INTERPRETACIÓN EXCESO

111111111111
Ibss12 (111111111111) =
1.2^11 + 1.2^10 + 1.2^9 + 1.2^8+
1.2^7+1.2^6+1.2^5+1.2^4+1.2^3+1.2^2+1.2^1+1.2^0
=4.095 - 128(delta) = 3.967

-83 + 128(delta) = 45

“se le suma el delta cuando hay que representar y se resta delta cuando hay que
interpretar”

45/2=
1 22/2
0 11/2
1 5/2
1 2/2
0 1 Representación de -83= 000000101101
SM se interpreta igual que en BSS solo que se deja de lado el primer bit para ver si
 es positivo(0) o negativo(1)

c) considere un sistema SM(8,3(3bits para numero con coma)) y responda las

siguientes preguntas
● ¿Cuál es el rango del sistema?
● interpretar la siguiente cadena 01011100
SM8
SMMMMFFF F=1.2^-1+1.2^-2+1.2^-3 =0,875
0 y todos 1
01111111max 1.2^3+1.2^2+1.2^1.2^0(15) + 1.2^-1+1.2^-2+1.2^-3 → 15 + 0.875= 15,875
11111111min -1(1.2^3+1.2^2+1.2^1.2^0 + 1.2^-1+1.2^-2+1.2^-3) = -15,875
16bits bus de direcciones= 2^4
memoria caché con 16 líneas= 2^4
bloques de celda 16 = 2^4
cache inicial vacía
tag= 8 = 2^4
 MOV R1, 0x0001
ciclo: CMP R1,0x0000
JE FIN
MUL R5, [0xABCD]
SUB R1, 0x0001
JMP cliclo
Fin: RET

0001 100 001001000 1848

0000 0000 0000 0001 0001
0110 100 001 001000 6848
0000 0000 0000 0000 0000
1111 0001 0000 0110 F106
0000 100 101 001000 0948
1010 1011 1100 1101 ABCD
0011 100 001 000000 3840
0000 0000 0000 0001 0001
1010 000000 000000 A000
0110 1000 0100 1000 6848
1100 0000 0000 0000 C000

0xDEC0 0001 100 001001000 1848

0xDEC1 0000 0000 0000 0001 0001

0xDEC2 0110 100 001 001000 6848

0xDEC3 0000 0000 0000 0000 0000

0xDEC4 1111 0001 0000 0110 F106

0xDEC5 0000 100 101 001000 0948

0xDEC6 1010 1011 1100 1101 ABCD

0xDEC7 0011 100 001 000000 3840

0xDEC8 0000 0000 0000 0001 0001

0xDEC9 1010 000000 000000 A000

0xDECA 0110 1000 0100 1000 6848

0xDECB 1100 0000 0000 0000 C000

 Dirección tag línea palabra f/a

0xDEC0 DE C 0 f

0xDEC1 DE C 1 A

0xDEC2 DE C 2 A

0xDEC3 DE C 3 A

0xDEC4 DE C 4 A

0xDEC5 DE C 5 A

0xDEC6 DE C 6 A

0xDEC7 DE C 7 A

0xDEC8 DE C 8 A

0xDEC9 DE C 9 A

0xDECA DE C A A

0xDEC2 DE C 2 A

0xDEC3 DE C 3 A

0xDEC4 DE C 4 A

0xDECB DE C B A
fallo con desalojo: misma línea diferente tag
fallo normal: diferente tag

ejercicio practica MAPEO DIRECTO:

memoria de 64 celdas de un Byte =2^6 direcciones de 6bits
memoria caché de 4 líneas =2^2 2 bits para direccionar la línea
8 bloques de celdas por línea =2^3 3 bits para palabra
calcular la cantidad de bits que se destinan a tag, línea y palabra
el tag es siempre lo que sobra

6 - 2 - 3 = 1 bit para TAG

ejercicio practica MAPEO ASOCIATIVO

Memoria principal de 256 celdas = 2^8 direcciones de 8bits
memoria caché con
a)bloques de 4 celdas = 2^2 = 2 bits para palabra
b)8 lineas =2^3=8 bits para direccionar la línea /*la línea no es importante en asociativo*/
c)correspondencia asociativa= él esto es para tag

8 bits -2 bits de palabra = bits de tag

8 - 2= 6 bits
tag(6 bits) palabra(2bits)
ejercicio practica MAPEO ASOCIATIVA POR CONJUNTO
¿cuántos bits son para tag, conjunto y palabra?
memoria principal 32 celdas = 2^5 5direcciones de bits
memoria caché con:
a) bloques de 4 celdas = 2^2= 2 bits para palabra
b)4 lineas = 2^2 = 2bits para línea } se juntan las 2
c) correspondencia asociativa por conjuntos, con conjuntos de 2 lineas } =4/2=2= 1bit
conjunto

tag= 5-2-1 =2 bits

tag(2) conjunto (1bit) palabra (2bits)

16direcciones
tag 8bits
lineas 4bits
bloques de celda 16 = 4

Tasa de Acierto: a/n

Tasa de Fallos: f/n
n: cantidad de acceso
T= n(ta×tc + tf(TC+tm))

450= 1000(0,93 . 0,3s + 0,07(0,3+tm))

450/1000 = (0,93 . 0,3s + 0,07(0,3+tm))

0,45= 0,279 + 0,07(0,3+tm)

0,45 - 0,279 = 0,07(0,3+tm)
0,171= 0,07.(0,3+tm)
0,171/0,07=0,3+tm
2,442857143 - 0,3 =tm
2,142857143

0xABOE

deje en R0 la suma de sus deudas (Es decir de todos los valores del arreglo que son negativos)
R1 la suma de sus ventas (Es decir, de todos los valores que son positivos)
cuando el inicide es 0000 es el fin
contadores R0 y R1

MOV R2, 0xABOE /*inicio */

MOV R0,0x0000
MOV R1, 0x0000
CMP [R2], 0x0000
JE Ingresos
ADD [R2], 0x0001
CMP [R2], 0x0000
JNEG Egresos

Ingresos MOV R1, R2

Egresos MOV R0, R2

MOV R2, 0xAB0E

MOV R0, 0X0000 d
MOV R1, 0X0000 v
volver CMP [R2], 0x0000
JE fin
CALL sumarDeudaOVenta
ADD R2, 0x0001
JMP volver
Fin: RET

sumarDeudaOVenta CMP [R2], 0x0000

JNEG esDeuda
ADD R1, [R2]
JMP fin
esDeuda ADD R0, [R2]
Fin RET
 PARCIAL 3

1) circuito:
a) C pulsado y A o B en reposo
b) A, B y C pulsado

2) pila
main: ADD R1, R0
CALL rutinaA
RET

rutinaA: DIV R1, 0x0002

RET

programa:
MOV R1, 0x10AC
MOV R0, 0x0019
CALL main
● rutinaA está ensamblada a partir de la celda 0x010B
● main está ensamblada a partir de la celda 0x020B
● el programa es ensamblado a partir de la celda 0x030B
 ● PC=0x030B
● la pila está vacía

main:
0010 100 001 100 000 0x020B 2860
1011 000000 000000 0x020C B000
0000 0001 0000 1011 0x020D 010B
1100 000000 000000 0x020E C000

rutinaA
0111 100 001 000000 0x010B 7840
0000 0000 0000 0010 0x010C 0002
1100 000000 000000 0x010D C000

programa:
0001 100 001 000000 0x030B 1840
0001 0000 1010 1100 0x030C 10AC
0001 100 000 000000 0x030D 1800
0000 0000 0001 1001 0x030E 0019
1011 000000 000000 0x030F C000
0000 0010 0000 1011 0x0301 020B

pc ir pc2 operación modo modo operan operando pila sp pc3

destino origen do origen
destin
o

0x030B 0x1840 0x030D MOV Registro Inmedia R1 0x10AC - FFEF 0x030D

0x10AC to

0x030D 0x1800 0x030F MOV Registro Inmedia R0 0x0010 - FFEF 0x030F

0x0019 to

0x030F C000 0x0302 CALL - inmediat - 0x020B {0x0302} FFEE 0x020B

020B o

0x020B 2860 0x020C ADD Registro Registro R1 R0 {0x0302} FFEE 0x020C

0x020C B000 0x020E CALL - inmediat - 0x010B {0x0302, FFED 0x010B

010B o 0x020E}

0x010B 7840 0x010D DIV Registro Inmedia R1 0x002 {0x0302, FFED 0x010D
0002 to 0x020E}

0x010D C000 0x010E RET - - - - {0x0302} FFEE 0x020E

0x020E C000 0x020F RET - - - - - FFEF 0x0302

3) SM
a)1010
b)010111101 = 189
c)-15,9375

4) cache
MOV R7, 0x0001
ciclo: CMP R7, 0x0000
JE FIN
MUL R5, [0xABCD]
SUB R7, 0x0001
JMP ciclo
FIN: RET

0001 100 111 000000 0XF0CC 09C0

0000 0000 0000 0001 0XF0CD 0001
0110 100 111 000000 0XF0CE 69C0
0000 0000 0000 0000 0XF0CF
1111 0001 0000 0110 0XF0C0 F106
0000 100 101 001000 0XF0C1 0948
1010 1011 1100 1101 0XF0C2 FBCD
0011 100 111 000000 0XF0C3 29C0
0000 0000 0000 0001 0XF0C4 0001
1010 000000 000000 0XF0C5 F000
1111 0000 1100 1110 0XF0C6 F0CE
1100 000000 000000 0XF0C7 C000

Dirección TAG LÍNEA PALABRA F/A

0XF0CC F0 C C F

0XF0CD F0 C D A

0XF0CE F0 C E A

0XF0CF F0 C F A

0XF0C0 F0 C 0 A

0XF0C1 F0 C 1 A

0XF0C2 F0 C 2 A

0XF0C3 F0 C 3 A

0XF0C4 F0 C 4 A

0XF0C5 F0 C 5 A

0XF0C6 F0 C E A

0XF0CE F0 C E A

0XF0CF F0 C F A

0XF0C0 F0 C 0 A

0XF0C7 F0 C 7 A

a) Ta= 14/15 /*a/n*/

 b) MUL R5, [0xABCD] = 0000 100 101 001000 1010 1011 1100 1101
c) JE FIN = 1111 0001 0000 011

5)
escribir una rutina superPar a partir de su documentación
REQUIERE una cadena a analizar en R0
MODIFICA ??
RETORNA un “1” en R1 si en la cadena en R0 los bits de sus posiciones pares estan en 0
retorna un 0 en caso contrario

Ayuda: En la cadena sus posiciones pares son las que resaltan:

Entonces la cadena es superPar. También lo es para la cadena

6)
Dado un arreglo que comienza en la celda 7A71 y que termina con un elemento de valor
FFFF, escribir una rutina que retorne en R1, la cantidad de elementos del arreglo son para
superPar