Wuolah Free ResumenTeoriaEOC

ResumenTeoriaEOC.
pdf
pgarc
Estructura y Organización de Computadores
2º Grado en Ingeniería Informática
Escuela Politécnica Superior

Universidad de Alcalá
Reservados todos los derechos.

No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
Estructura y Organización de
Computadores
Resumen de teorı́a y ejemplos
Pablo Garcı́a Garcı́a
Universidad de Alcalá
Junio de 2021
Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 1 / 139

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
a64b0469ff35958ef4ab887a898bd50bdfbbe91a-5125782
Índice
1 Tema 1 - Introducción, historia y rendimiento
2 Tema 2 - Codificación
3 Tema 3 - La ruta de datos
4 Tema 4 - El repertorio de instrucciones
5 Tema 5 - La unidad de control
6 Tema 6 - Memorias
7 Tema 7 - Entrada/Salida
8 Apéndice (fórmulas y equivalencias)

Presentación
Este es el resumen de la parte teórica que hice durante el curso 2020-2021

y que me ayudó a aprobar la asignatura. Espero que sea de ayuda.
No aseguro que no haya ningún error, al ser un documento tan grande
siempre se puede escapar algo.
Resumen y dibujos realizados por Pablo Garcı́a Garcı́a

Imágenes de Rafael Rico López

Tema 1 - Introducción, historia y rendimiento
Computador: es una máquina destinada a procesar información,

tomar decisiones, y hacer operaciones (calculadora).
Leibniz se preguntó si podrı́a haber una máquina que dijera si
ciertas proposiciones matemáticas eran correctas, por ejemplo,
∀x ∈ R → x 2 > 0
Existen diferentes tipos de autómatas, finitos, y la máquina de
Turing, que era como una cinta que leı́a sı́mbolos y en función de
estos se desplazaba hacia un lado o hacia otro. δ(q, r ) → (p, w , q)
Se dice que cualquier máquina que realice varias funciones de
transición como la de Turing, es una máquina de Turing universal.
(Computador de propósito general).

Los ordenadores resuelven problemas de decisión, búsqueda, recuento, u
optimización.
Complejidad: función de recursos necesarios, tiempo y espacio.
f (x) = O(g (x))
Complejidades sublineales
Lineal O(n)
Logarı́tmica O(log n)
√
Radical O( n)
Complejidades supralineales
N logarı́tmica O(n log n)
Polinómica O(n2 )
Exponencial O(2n )

Para los problemas de complejidad exponencial no existe un algoritmo

definido y se dice que son de Tipo NP, y el resto son de Tipo P (existe
un algoritmo definido).
Proceso de la computación:
1 Problema
2 Algoritmo
3 Lenguaje formal
4 Compilador
5 Binario
6 Ejecutar

Niveles de descripción:
Fı́sico (transistores)
Sistema (sumadores y puertas lógicas)
Organización
Repertorio
Sistema operativo
Aplicación
Transistores
Existen dos grandes tipos, los BJT y los MOSFET, los BJT son más
rápidos, pero los MOSFET ocupan menos espacio. Hoy en dı́a las puertas
lógicas se construyen con BJT, que dan lugar a RTL, DTL, ECL (la más
rápida, 0,5 ns retardo), y TTL. Todas están hechas a base de transistores
y resistencias. Los MOSFET dan lugar a las NMOS y CMOS, destacando
la CMOS, ya que no usa resistencias, y por tanto solo gasta energı́a
cuando conmuta.
Arquitectura de Von Neumann (1945)

Hay cuatro grandes bloques, la memoria, la ALU, la unidad de con-
trol y los periféricos. La memoria se conecta con la ALU mediente el
bus de datos y a la unidad de control mediante el bus de instrucciones.
También están interconectados la ALU con la unidad de control, y la me-
moria con los periféricos.
Dentro de la unidad de control está el contador de programa, y en la
memoria se almacena el programa en instrucciones máquina.
Máquinas de flujo de datos

Las operaciones se lanzan cuando están los datos disponibles, no
hay contador de programa.
Se usan grafos de flujo de datos.
Algunos lenguajes fueron VAL, SISAL...

Tiempos y ciclos
t = ciclos · τ
R ∝ t1p
procesoscompletados
Productividad = tiempo
Los ciclos pueden ser activos o inactivos. Hay varios tiempos:
Tiempo de CPU: tiempo real de ejecución. ciclosCPU · τ
Tiempo de usuario: por ejemplo, tiempo que tarda un usuario en
introducir un dato solicitado.
Tiempo de sistema: tiempo S.O. dando servicio al proceso.
ciclossys · τ
Tiempo de pared: tiempo desde que se ejecuta hasta que se
devuelve un resultado. tw = tCPU + tsys + tespera
Donde ciclosi = ciclosactivos + ciclosinacticos

Ciclos por instrucción CPI
CPI: ciclos por instrucción
CPIi : ciclos para i instrucciones
CPIset : promedio de ciclos
n
X
CPIi · ri
i=1 ciclosp
CPIp = n =
X rp
ri
i=1
Donde rp es el recuento (número de instrucciones a ejecutar), que

depende del algoritmo, el lenguaje de programación, el compilador...
Ahora podemos definir el tiempo de programa:

tp = ciclos · τ = rp · CPIp · τ

MIPS
Cada CPI de un MIPS diferente
instrucciones ciclos −6 f · 10−6
MIPS = · · 10 =
ciclo s CPI
Mejoras
Ley de Amdahl: la mejora obtenida en el rendimiento de un sistema
debido a la alteración de uno de sus componentes está limitada por la
fracción de tiempo que se utiliza dicho componente.
am : factor de mejora
fm : fracción de tiempo

fm
Tmejora = T mejora · (1 − fm ) +
am

Mejoras
Speed-Up
tmejora tmaqA rpsin · CPIpsin · τsin MIPSsin ciclossin

S= = = = =
tmejora tmaqB rpcon · CPIpcon · τcon MIPScon cicloscon
Si S > 1: ha mejorado
Si S < 1: ha empeorado
Si S = 1: indiferente, no ha cambiado

Ejemplo de problema de rendimiento
Un procesador trabaja a 500Mhz. El CPI medio es de 1.45
ciclos/instrucción. El tiempo de pared es de 0.5s, el tiempo de CPU es de
0.3s y el de sistema de 0.18s. Calcular sus ciclos y el recuento. Ahora se
reduce el recuento en un 8 %, calcular el nuevo tiempo de ejecución y el
speed-up.
cw = tw · f = 0,5 · 500 · 106 = 250 · 106 ciclos
cCPU = tCPU · f = 0,3 · 500 · 106 = 150 · 106 ciclos
csys = tsys · f = 0,18 · 500 · 106 = 0,18 · 500 · 106 = 90 · 106 ciclos
cCPU 150 · 106

rp = = = 103,44 · 106 instrucciones
CPIp 1,45
Como el recuento, que desconocemos, se reduce en un 8 %, es lo mismo
que quedarnos con su 92 %: tp′ = 0,92 · rp · CPIp · τ
Por tanto el speed-up lo podemos calcular como:
tsin rp · CPIp · τ 1
S= = = = 1,086 > 1(mejora)
tcon 0,92 · rp · CPIp · τ 0,92

Tema 2 - Codificación
Teorema fundamental de la numeración

Sea V un número con parte entera [V] y parte decimal, o mantisa, {V}
expresado en un sistema posicional de base b, se puede expresar como:
p−1
X p−1
X −1
X
V = di · b i = di · b i + di · b i = [V ] + {V }
i=−q i=0 i=−q
Siendo p y q el número de dı́gitos de la parte entera y fraccionaria.

Codificación de un entero a una base b

El algoritmo consiste en dividir el entero [V ] entre la base b
sucesivamente hasta llegar a un cociente menor que b. Los restos de cada
división, tomando el último como el de mayor peso y ası́ hasta el primero,
será el número codificado.
Ejemplo: codificar 18310 en binario → 101101112

183 ÷ 2 → C = 91; R = 1
91 ÷ 2 → C = 45; R = 1
45 ÷ 2 → C = 22; R = 1
22 ÷ 2 → C = 11; R = 0
11 ÷ 2 → C = 5; R = 1
5 ÷ 2 → C = 2; R = 1
2 ÷ 2 → C = 1; R = 0
1 ÷ 2 → C = 0; R = 1

Codificación de una mantisa a base 2

El algoritmo consiste en multiplicar el número por 2. Si la parte entera del
resultado es 0 anotamos 0, si es 1 anotamos 1 y volvemos a multiplicar la
mantisa de este resultado por 2 tantas veces como precisión queramos.
Ejemplo: codificar 0,14310 en binario

0,143 · 2 = 0,286 → 0
0,216 · 2 = 0,432 → 0
0,432 · 2 = 0,864 → 0
0,864 · 2 = 1,728 → 1
0,728 · 2 = 1,456 → 1
0,14310 = 0,000112
Para codificar, por ejemplo, 183,14310 a binario, combinamos los dos

últimos algoritmos.

Signo-Magnitud
El sistema signo-magnitud funciona de la siguiente manera. Si
tenemos un número n y lo queremos representar con b bits en
signo-magnitud, tenemos que reservarnos el MSB, es decir,
disponemos de b-1 bits para representar |n|. En estos b-1 bits
codificamos el valor absoluto de n, y ahora MSB=1 si b < 0, y
MSB=0 si b > 0.
Rango SM: [−(2n−1 − 1), 2n−1 − 1]
Ejemplo: codificar −9610 en SM

Utilizando los algoritmos anteriores:
9610 = 011000002
Si estuviéramos buscando 96 ya estarı́a, pero queremos -96, luego

MSB:
−9610 = 111000002
Complemento a 1
El sistema complemento a 1 funciona de la siguiente manera. Si
complemento a 1, primero codificamos |n|, y si n < 0 negamos bit
a bit.
Rango C1: [−(2n−1 − 1), 2n−1 − 1]
Ejemplo: codificar −9610 en C1

9610 = 011000002

bi :
−9610 = 100111112

Complemento a 2
El sistema complemento a 2 funciona de la siguiente manera. Si
complemento a 2, primero codificamos |n|, y si n < 0, después del
primer 1 de menor peso, negamos bit a bit, o negamos todo y
sumamos 1.
Rango C2: [−2n−1 , 2n−1 − 1]
Ejemplo: codificar −9610 en C2

9610 = 011000002

bi desde b6 :
−9610 = 101000002

Exceso a 2n−1
El sistema exceso a 2n−1 funciona de la siguiente manera. Si
exceso a 2n−1 , primero hallamos su valor en complemento a 2
sobre b bits, y después MSB
Rango EX 2n−1 : [−2n−1 , 2n−1 − 1]
Ejemplo: codificar −9610 en EX 2n−1

Pasamos a C2:
−9610 = 101000002
Como queremos el EX 2n−1 , MSB:
−9610 = 001000002

Coma flotante
Primero calculamos cuál será el valor a codificar para el exponente en b bits (parte entera). Esta es ⌊log2 |n|⌋ + ε
en base 10.
Ahora
calculamos cuál será
el j
valor a codificar para la mantisa en b’ bits. Esta es:
′ n · 2b ′ −β . Donde ε = 2 si la mantisa va en C2, C1 o EX 2n−1 , y ε = 1 en
k
n · 2b −β =
2⌊log2 |n|⌋+ε 2E
SM. Además, β = 1 en SM y β = 0 en caso contrario.
−12,407110 coma flotante, mantisa de 10 bits SM y exponente 6 bit

EX 2n−1
E = ⌊log2 |12,4071|⌋ + 1 = 3 + 1 = 410

Convirtiendo el exponente al sistema pedido E = 1001002

12,4071 10−1
M= 4
·2 = ⌊397,0272⌋ = 39710
2
Convirtiendo la mantisa al sistema pedido M = 0110001101
Finalmente:
12,407110 = 100100,01100011012
Coma fija
Primero se calcula el valor a codificar, que será el producto entre el
número y la posición de la coma, redondeados hacia abajo, y ahora ya sı́
codificamos en el sistema pedido sobre los bits deseados.
Ejemplo: −57,86410 coma fija 10 bits, C2, coma en 23

Calculamos el valor a codificar:
⌊−57,864 · 23 ⌋ = ⌊−462,912⌋ = −46310
Utilizando el algoritmo de codificación a complemento a 2 y

colocando la coma en 23 :
−57,86410 = 1000110,0012
Con una precisión de 23

IEEE 754 Simple precisión

Es un caso particular de coma flotante con un exponente de 8 bits
expresado en EX 2n−1 − 1, una mantisa de 23 bits en SM, y ε = 0.
Ejemplo: −2,759 · 1012 simple precisión IEEE 754
E = ⌊log2 | − 2,759 · 1012 |⌋ = 4110

→ 41 + 28−1 − 1 = 101010002
12
−2,759 · 10

23
M= · 2 = ⌊−2136141,755⌋ =
241
−213614210 → 1010000010011000010011102
−2,759 · 1012
10 = 10101000,1010000010011000010011102

Tema 3 - La ruta de datos
Operadores de bit: el resultado i-ésimo solo depende de los operandos
i-ésimos. Son rápidos.
Operadores lógicos
AND
OR
NOT
XOR
La especificación de alguno de estos es, por ejemplo:
NOT (x, n) = NOT Xi → ri = Xi
AND(x, y , n) = Xi AND Yi = ri
Con coste A(n) = O(n) y retardo R(n) = O(cte)

Operadores de bit
Desplazamientos


 in = (s · t) · xn−1
x ≡ dato




t ≡ l ógico/aritmético

SHIFT (x, t, s, l, n)

 s ≡ izquierda/derecha
l ≡ longitud




n ≡ númerobits


Operadores de bit
Rotaciones
Son como desplazamientos, pero como si estuvieran en cı́rculo. Hay dos
tipos de rotaciones, directas (imagen de la izquierda), o por biestables
(derecha).

Operadores de bit
Desplazamientos - Sı́ntesis 1
Para su construcción se utilizan puertas OR y AND, junto con un
controlador de señales de control. Tiene un coste de A(n) = O(n2 ), y un
retardo de R(n) = O(cte). Se ve claramente un problema de fan-in.

Operadores de bit
Para su construcción se utilizan multiplexores 2 a 1 (con sus respectivas
señales de control). Tiene un coste de A(n) = O(n · log2 (n)), y un
retardo de R(n) = O(log2 (n)).

Operadores de bit
Solo es válida para desplazamientos unitarios. Para su construcción se
utilizan puertas lógicas AND, OR, y NOT. Tiene un coste de
A(n) = O(n), y un retardo de R(n) = O(cte).

Operadores de bit
Detectores
Cero

1 si Xi = 0 ∀ i ∈ [0, n − 1]
CERO(x, n) =
0 si Xi = 1 ∃ i ∈ [0, n − 1]
Se puede implementar de dos formas distintas, pero ambas con

fan-in:
CERO(x, n) = Xn−1 AND Xn−2 AND . . . AND X0
CERO(x, n) = Xn−1 OR Xn−2 OR . . . OR X0

Operadores de bit
Detectores
Paridad
PARIDAD(x, n) = Xn−1 ⊕ Xn−2 ⊕ . . . ⊕ X0
Signo
Este depende del sistema de representación en el que estemos
trabajando, por ejemplo, en C2:

n > 0 si Xn−1 = 0
SIGNO − C2(n) =
n < 0 si Xn−1 = 1

Operadores de signo
Conmutación
Complemento a 2: consiste en complementar bit a bit y sumar 1

Xi + 1
NEG − C2(x, n) =
Oflow si dn−1 = 1 ∧ di = 0 ∀ i ∈ [0, n − 2]
Ası́ se implementa la conmutación de C2, con A(n) = R(n) = O(n):

Operadores de signo
Conmutación
Complemento a 1: consiste en complementar el bit a bit
NEG − C1(x, n) = Xi ∀ i ∈ [0, n − 1]
Este sistema nunca causa overflow.
Exceso a 2n−1 : consiste en complementar todos los bits y sumar 1,
tal y como hacı́amos en complemento a 2
NEG − EX 2n−1 (x, n) = Xi + 1 ∀ i ∈ [0, n − 1]
Signo-Magnitud: consiste en complementar el MSB
NEG − SM(x, n) = Xn−1 Se implementa ası́:

Operadores de signo
Cambios de sistema de representación
C2 ↔ EX 2n−1 → MSB
Nunca se produce overflow. La implementación es la misma que la
de conmutación de SM de la anterior diapositiva.
SM ↔ C2
 n−1
 2 + NEG − C2 si n<0
igual si n>0
overflow si Xn−1 = 1 ∧ Xi = 0 ∀ i ∈ [0, n − 2] C2


Operadores de signo
Extensión
Da lugar cunado representamos un número n con b bits, pero
necesitamos representarlo con m bits (m > b).
Signo-Magnitud: se copia el MSB a la primera posición, los demás
en su respectiva posición, y los huecos restantes se rellenan con 0.
Exceso 2n−1 : como en SM, pero en vez de rellenar con ceros, se
rellena con MSB.
Complemento a 2: como en SM, pero en vez de rellenar con
ceros, se rellena con el MSB.
Estos son dos ejemplos, en SM y en EX 2n−1 :

Suma binaria
Dados los números X e Y :
X → Xn−1 Xn−2 . . . X1 X0
Y → Yn−1 Yn−2 . . . Y1 Y0
Su suma es:
n−1
X
S= (Xi + Yi ) · 2i
i=0
Donde el término (Xi + Yi ) genera un acarreo Ci · 2 + Si . La forma de

operar esto rápidamente es con el llamado Half-Adder, que tiene como
entradas dos bits, y como salidas la suma de los dos bits y el acarreo que
se genera.

Suma binaria
Podemos observar que la suma s = X ⊕ Y , y que el acarreo que se
genera c = X AND Y
X Y s c
0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1

Suma binaria
Para sumar dos números sumaremos bit a bit, y el acarreo se lo sumamos
al siguiente bit. Eso se puede implementar con Half-Adders.
Pn 2
Necesitaremos k=1 k = n 2+n Half-Adders en total, ya que siguiendo la
lógica de sumar bit a bit y el acarreo al siguiente peso (tal y como
sumarı́amos a mano en papel), pondrı́amos en fila n sumadores, y si
conectamos el acarreo con el siguiente, en la fila n-ésima obtenemos uno
de los bits reales del resultado de la suma (el de menor peso posible), y
reducimos un sumador. Este es un ejemplo de como sumarı́amos dos
números de 6 bits con A(n) = O(n2 ) y R(n) = O(n)

Suma binaria
Otra forma de realizar la suma binaria es con los conocidos Full-Adder,
sumadores que además de devolver la suma y el acarreo, también reciben
un acarreo entrante, con la que podemos reducir el número de
Half-Adders.
X Y CIN COUT S
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1
S = X ⊕ Y ⊕ CIN = X · Y · CIN + X · Y · CIN + X · Y · CIN + X · Y · CIN

COUT = X · Y + X · CIN + Y · CIN = X · Y + (X ⊕ Y ) · CIN

Suma binaria
Podemos implementar la suma binaria con Full-Adders de la siguente
manera, con un coste igual al retardo O(n)
Que normalmente se expresa de forma abreviada como:

Suma binaria
Con este último método de suma, se pueden construir
sumadores-restadores aprovechando la propiedad X − Y = X + (−Y ),
pudiendo expresar −Y en diferentes sistemas. Recordemos que estamos
dando una suma o resta en binario puro, luego este serı́a el
Sumador-Restador (BIN − C2)
Si R < 0 se produce overflow = Cn−1 ⊕ S/R

Suma binaria
Entonces, también podemos constriur el Sumador-Restador (BIN − C1).
Es importante recordar que además de las ecuaciones de overflow que
estamos indicando, podemos darnos cuenta de que está habiendo si
sumamos dos positivos y sale negativo, sumamos dos negativos y sale
positivo, etc...
Si X < Y se produce overflow = COUT ⊕ S/R

Suma binaria
El Sumador-Restador (BIN − EX 2n−1 ). Es exactamente igual al de C2,
es más, el resultado se devuelve directamente en C2 a pesar de haber
dado los datos en EX 2n−1 , por lo que con MSB lo devolvemos a
EX 2n−1 .
Podemos ver que si hacemos (2n−1 + X ) + (2n−1 + Y ) = 2n + X + Y , se
genera un acarreo de 2n . Si restamos, (2n−1 + X ) − (2n−1 + Y ) = X − Y ,
vemos que no existe acerreo al restar.

Suma - resta coma flotante

El Sumador-Restador de coma flotante ”piensa” de la siguiente forma:
(0,5 · 22 ) + (0,5 · 23 ) = 23 · (0,25 + 0,5) = 0,75 · 23 , es decir, opera
sacando factor común al exponente (parte entera) más grande.
Fase de operación: todo comienza con un selector que recibe la
mantisa y el exponente del número A (MA , EA ), y los de B
(MB , EB ); del que sale el exponente mayor de los dos (Emayor ), ası́
como la mantisa (Mmayor ), la menor (Mmenor ), y la diferencia de
exponentes (EA − EB ). Ahora a Mmenor se le hace un
desplazamiento a la derecha de tantos bits como (EA − EB )
indique, pero para no perder los bits de hace una extensión y se
guardan ahı́. Esta fase finaliza son la suma o resta de (Mmayor ) con
(Mmenor ), que junto con (Emayor ) dan lugar a Eresultado y Mresultado .

Suma - resta coma flotante

Fase de normalización: para calcular el exponente final (Efinal ), se
hace la resta entre Eresultado y el número de 0’s a la izquierda de
Mresultado . Para obtener la mantisa final (Mfinal ) se cuenta el
número de 0’s a la izquierda que tiene Mresultado y se hace un
desplazamiento a la izquierda de este tamaño recuperando los
bits desplazados a la derecha en la fase de operación, que se
habı́an guardado en la extensión.
Fase de redondeo: ya solo queda ajustar Mfinal mediante redondeo
para obtener el resultado final, esto se puede hacer de varias formas
distintas.
Truncación: error por defecto
Redondeo al más próximo: hardware complejo
LSB a 1: sencillo y reparte errores (se utilizará este)

Esquema del sumador-restador de coma flotante

Comparadores
Sin signo: destaca el comparador de 1 bit
Con signo: se basa en hacer la resta en complemento a 2, y con
diferentes indicios del resultado se pueden construir sus ecuaciones
lógicas, destacando:
MAYORQUE(X , Y , n) = rn−1 ⊕ des

Anticipación de acarreo
Generación: en la etapa i se genera acarreo o no.
gi = Xi · Yi
Propagación: pasa o no a la etapa i + 1 el acarreo de la etapa i − 1
pi = Xi ⊕ Yi
Si = pi ⊕ Ci−1
Ci = gi + pi · Ci−1
Esto da lugar a sumadores CLA

Sumador CLA (Carry Lookahead Adder)
Debido al fan-in, solo se recomienda para 4 o menos bits. Tiene un coste
de A(n) = O(n2 ), y un retardo de R(n) = O(cte). Aclarar que Ci llegan
i + 2 puertas AND.

Sumador CLA por bloques

G = 1 si el bloque genera acarreo, y P = 1 si propaga acarreo.
Gik = Gj+1,k + Pj+1,k · Gij
Pik = Pij · Pj+1,k

Cj = Gij + Pij · Ci−1

Sumador CLA por bloques
Ejemplo de sumador CLA por bloques de 2 bits. Se puede aumentar el
número de bits combinando varios de estos. Tiene retardo
R(n) = O(log2 (n)), y coste A(n) = O(n · log2 (n))

Sumador RCA-CLA hı́brido

Ejemplo de sumador RCA-CLA hı́brido. El número de bloque RCA se
calcula como kn . Tiene un retardo de R(n, k) = O(log2 ( kn ) + 2k), y un
coste de A(n, k) = O( kn · log2 ( kn ) + n)

Sumador CSK (salto de acarreo)

Ejemplo de sumador CSK. Tiene un retardo de
R(n, k) = O(4k + 2 · ( kn − 2)), y un coste de A(n, k) = O(n). ¿Cuál es el
k óptimo? Será aquel k que anule la primera derivada parcial de R
respecto de k.
r
∂R ∂ n n
= 0; 4k + 2 · − 2 = 0; k =
∂k ∂k k 2

Sumador CSLA (sumador de acarreo)
Ejemplo de sumador CSLA de tamaño k homogéneo. Tiene un
retardo de R(n, k) = O(2k + 2 · ( kn − 2) + Rmax ), y un coste de
A(n, k) = O(n). ¿Cuál es el k óptimo? Será aquel k que anule la
primera derivada parcial de R respecto de k.
∂R ∂ n √
= 0; 2k + 2 · − 2 + Rmax = 0; k = n
∂k ∂k k

Multiplicaciones (sumas-desplazamientos sin signo)
A = 1210 = 11002 , B = 1010 = 10102 → Haciendo la multiplicación a
papel como la de toda la vida, A · B = 011110002 = 12010 . Este
algoritmo se conoce como el de sumas-desplazamientos. Si cada
operando tiene un tamaño n, el resultado se expresa en un tamaño 2n
para evitar overflow. Se puede implementar con el siguiente circuito:

Multiplicaciones (sumas-restas sin signo)

Conociendo las series geométricas:
n−1
X b p − b n−1 · b
i bp − bn bn − bp
m(b) = b = = = ; m(2) = 2n − 2p
1−b 1−b b−1
i=p
Imaginamos que tenemos un número B = 001111102 , que lo podemos

expresar como 26 − 21 , de forma que si lo queremos multiplicar por un
número A, A · B = A · (26 − 21 ) = A · 26 − A · 21 , donde A · 2n se puede
interpretar como desplazar A n posiciones.

Ejemplo: 18 · 4 mediante sumas-restas
A = 1810 = 0100102
B = 410 = 0001002
A · B = A · (−22 + 23 ) = −A · 22 + A · 23
−A = NEG − C2(A, 6) = 101110
−A · 22 = 111110111000
A · 23 = 000010010000
S = 000001001000 = 23 + 26 = 8 + 64 = 7210 = 18 · 4

Este algoritmo se implementa ası́:

Multiplicaciones (sumas-desplazamientos con signo)

El algoritmo es el mismo, pero dependiendo de los sistemas de
representación se hacen las llamadas Correcciones de Booth:
Binario puro: nada cambia
C2:
A > 0 · B < 0: durante el proceso se van extendiendo los
0’s, y R = R ∗ + NEG − C2(A, n) · 2n
A < 0 · B > 0:
Opción 1: extender 1’s o 0’s según el signo
Opción 2: durante el proceso se van extendiendo los 0’s,
y R = R ∗ + NEG − C2(B, n) · 2n
C1: A > 0 · B < 0: extender los 0’s, y
R = R ∗ + NEG − C1(A · 2n , 2n)

Ejemplo: 001010C2,6 · 111010C2,6 mediante sumas-desplazamientos
R ∗ = 001001000100
−A = NEG − C2(A, 6) = 110110
−A · 26 = 110110000000
S = R ∗ + (−A · 26 ) = 111111000100

Multiplicaciones (sumas-restas con signo)

Funcionan exactamente igual que en binario puro, pero en este caso si
B < 0, la cadena final de 1’s no se cierra, ya que al extender el signo
nunca acaban los 1’s. Hemos de tener en cuenta que si el número es
negativo, al desplazar los bits se añaden 1’s
Ejemplo: 001010C2,6 · 111010C2,6 mediante sumas-restas
B = 111010 = −21 + 22 − 23
A · B = A · (−21 + 22 − 23 ) = −2A + 22 A − 23 A
−A = NEG − C2(A, 6) = 110110
−2A + 22 A − 23 A = 111111101100 + 000000101000 + 111110110000 =
= 111111000100 = −6010

Divisiones (restauración)
Se realizan como las divisiones de siempre. Para probar si cabe se resta el
divisor, si la resta es positiva (MSB = 0) significa que cabe, 1 al cociente
y baja el siguiente. Si la resta es negativa (MSB = 1), 0 al cociente,
volvemos al dividendo parcial anterior bajando el siguiente. Ejemplo:

Divisiones (sin restauración)

Se realizan como las divisiones de siempre. Para probar si cabe se resta el
divisor, si la resta es positiva (MSB = 0) significa que cabe, 1 al cociente
y baja el siguiente. Si la resta es negativa (MSB = 1), 0 al cociente, baja
el siguiente y se suma el divisor. Ejemplo:

Tema 4 - El repertorio de instrucciones
El repertorio de instrucciones es uno de los niveles de descripción de un

computador, que se sitúa entre el de organización y el de
sistema operativo. Para estudiarlo mejor podemos intentar responder a
las siguientes preguntas:
Cuestiones del repertorio de instrucciones
¿Qué es?
¿Es el repertorio un lenguaje de programación?
¿Qué hace y cómo funciona?
¿Con qué lo hace?
¿Cómo se codifica?
Algunos estudios

¿Qué es el repertorio de instrucciones?

Se puede decir que es:
Un conjunto de operaciones
Un conjunto de operandos
Una serie de registros
Un modelo de memoria
Una forma de codificar
Una serie de estados
En general, es la arquitectura software, la especificación de la
máquina. Algunos ejemplos son: ARM, RISC-V.

¿Es el repertorio de instrucciones un lenguaje de programación?

Sı́ lo es, ya que cumple el Teorema de la Programación Estructurada
de Böhm-Jacopini, que enuncia lo siguiente:
”Cualquier tarea computable se puede llevar a cabo con 3 tipos de
estructuras”:
Secuencias
Estructuras de selección → if-else
Estructuras de iteración → for-while
Para esto necesitaremos:
Saltos condicionales
Modificar porciones de memoria

Máquina de Minsky
Era una máquina que tenı́a dos registros ilimitados, el registro a contenı́a
un n ∈ Z, y el registro b = 0. A partir de esta máquina se demuestra que
cualquier instrucción se puede llevar a cabo con:
Incrementar
Decrementar y saltar si 0
Computadores OISC
Es entonces cuando aparecen los computadores OISC (one-instruction
set computer ), ordenadores de una sola instrucción que hacı́an:
Suma y saltar si ≤ 0
Incrementar y saltar si = V
Restar y saltar si n < 0


Eficacia de las ideas anteriores
Pero, ¿son eficaces las ideas anteriores?. Sı́ y solo si hay instrucciones de:
Transferencia: copiar datos. No generan estados.
move, load, store, exchange, push, pop...
Proceso: modifican porciones de memoria y escriben en el registro
de estado.
Aritméticas: add, sub, mul, div, fadd...
Lógicas: and, not, or, xor...
Comparación con signo: cmpeq, cmpl, cmpleq...
Comparación sin signo: cmpul, cmpuleq...

Eficacia de las ideas anteriores
Bifurcación: leen los registros de estado.
Condicionales: evalúan una condición decidiendo si se toma o
no.
Lógicas: siempre se toman. jmp, goto, call, ret...
Si no hay registro de estado, la condición se evalúa en el momento del
salto y se le pasa un registro y un destino.
Otras: se ocupan del modo de funcionamiento del microprocesador,
el manejos del estado...
Normalmente operaciones complejas que incluyen otras más
sencillas (loop).
También guardar todos los registros en memoria (savereg).
Sirven para reducir el salto semántico (semantic gap), que
no es más que poder ver a simple vista qué hace el programa.

Tipos de condiciones
Simples:
Intrı́nseca al dato: cero, signo, paridad...
Relativa al dato y la operación: acarreo,
desbordamiento...
Complejas: ejemplo sf=of and zf=0
¿Cómo funcionan las subrutinas?

Las subrutinas nos facilitan la programación modular, es decir, una
mejor vista del código, una mejor depuración, un mejor mantenimiento...
Esquema de una subrutina:


¿Cómo funcionan las subrutinas?
Para que funcionen correctamente se necesita ”anotar”:
Dirección de retorno
Argumentos
Variables locales
Devolver un valor
Lo que supone tener que utilizar un espacio de memoria. Además, se
recomienda el uso de métodos recursivos, pero han de ser reentrantes,
es decir, que para cada llamada tengan su propio espacio de memoria.
Esto se puede conseguir con una pila o una ventana de registros.


¿Cómo funciona la pila de una subrutina?
1 El llamador pasa los argumentos, se hace un call, que implica
pasar el control a la subrutina y guardar en la cima de la pila la
dirección de retorno (dir-return).
2 El llamado salva el framepointer en la cima de la pila. Se
declaran las variables locales y se ejecuta la subrutina.
3 Se ajusta el puntero de la cima de la pila y ahora se puede apuntar
a oldBP (se recupera BP).
4 Retornar supone cargar en el PC la dirección de retorno y ajustar la
cima de la pila. Se limpia la pila para evitar futuros
desbordamientos.

¿Cómo funciona la pila de una subrutina?
La utilidad del local pointer es calcular dónde están las cosas, por
ejemplo:
[BP]-3=arg1
[BP]-4=arg2
[BP]+1=local2
Aquı́ un ejemplo de la pila de subrutina de la que estamos hablando:

Ventana de registros de una subrutina
Son una serie de registros en los que se van guardando las variables
globales, los argumentos, las variables locales, las salidas; de las
diferentes funciones, que se van solapando.
Tiene como ventaja que es más rápida que la pila, y como desventaja que
pueden acabarse los registros, pero se puede solucionar guardando en la
pila y sobreescribiendo los registros. Aquı́ un ejemplo de la ventana de
registros de la que estamos hablando:

¿Con qué lo hace? Lo hace con operandos, ya bien sean variables o
constantes que invocamos mediante diferentes modos de
direccionamiento, y que están en memoria o en un almacenamiento
temporal.
Modos de direccionamiento
Inmediato: dato en la propia instrucción. mov al, 15h
Directos:
Absolutos
A memoria
A registros
Relativos a un registro y un desplazamiento.
Indirectos: apuntan a punteros.
Implı́citos: dados por la propia operación.

¿Con qué lo hace? - Operandos
Almacenamientos temporales
Hay tres máquinas diferentes a destacar, que funcionan de diferente
manera y se programan de formas distintas. Veamos cómo funcionan con
una suma.
Máquina de acumulador (de 1 dirección)

El resultado se vuelve a pasar como operando.
load M1; Acc ← [M1]
add x; Acc ← Acc+[x]
store M2; [M2] ← Acc

Máquina de pila (de 0 direcciones)

Los dos operandos están en la cima de una pila y el resultado se escribe
en la cima.
push M1; cima ← [M1]
add; cima ← cima+(cima-1)
pop M2; [M2] ← cima

Máquina de banco de registros de propósito general (2 o 3 direcciones)

Se pueden seleccionar los registros mediante señales de control.
load r1, M1; r1 ← [M1]
load r2, M2; r2 ← [M2]
add r1, r2, r3; r3 ← r1+r2
store r3, M2; [M2] ← r3
Se suele decir que la de registros es la mejor ya que no accede a memoria, pero esos datos de los registros han de
salir de memoria, entonces, ¿por qué es mejor?. Porque el programador y el compilador van a intentar mantener las
variables en los registros el mayor tiempo posible optimizando los compiladores.

Codificación
Si tenemos un conjunto A de operaciones, tal que |A| = n, y un
conjunto B de operandos, tal que |B| = m; para la codificación
necesitaremos log2 (n) + log2 (m). Una instrucción tiene el siguiente
aspecto:
Es importante que toda la información sea autocontenida (no puede

apoyarse en otra), y también se recomienda la ortogonalidad: cualquier
operación se puede realizar con cualquier operando y modo de
direccionamiento (solo lo ha cumplido VAX). No todas las operaciones
tienen un solo código: add → 000000; add → 100000-000
Criterios para diseñar repertorios
Regularidad (ortogonalidad)
Minimizar la representación
Reducir el número de palabras accedidas a memoria
Favorecer el tiempo de vida del repertorio

Pautas para minimizar repertorios
Dijo Huffman en 1952: si tenemos los mensajes 1, 2, 3, . . . , n donde P(n)
es la probabilidad de querer enviar el mensaje n, y L(n) su longitud:
n
X
P(1) > P(2) > P(3) > . . . > P(n) → P(i) = 1
i=1
n
X
L(1) < L(2) < L(3) < . . . < L(n) → L(i) · P(i) = tam
i=1
El mensaje 1 quedará como 0, el 2 como 10, el 3 como 110, el 4 como

1110...
De esta forma las operaciones frecuentes empezarán por 0, las menos
frecuentes por 10, las algo menos frecuentes por 110, etc...
Trep = n · fp + (n + m) · (1 − fp )

Algunos estudios
Instrucciones-ejecución
El 4 % de las instrucciones del repertorio son responsables del 80 % de
la ejecución.
El 12 % de las instrucciones del repertorio son responsables del 90 % de
la ejecución.
En el caso de máquinas Intel para un porcentaje muy bajo de
instrucciones, la responsabilidad es aún mucho mayor.
RISC o CISC
Hay máquinas RISC, que tienen un repertorio reducido (registro-registro,
instrucciones de proceso en 1 ciclo, y optimizan el compilador); y
máquinas CISC, que son las que tienen un repertorio grande.
Hoy en dı́a utilizamos muchas instrucciones, por lo que habları́amos de
CISC, pero lo que se hace el traducir el CISC a RISC para que todo sea
mejor.

Algunos estudios
Tipos de estudios
Hay estudios estáticos, que son aquellos que se realizan leyendo el
archivo ejecutable (.exe) ; y estudios dinámicos que se realizan en
tiempo de ejecución, siendo estos últimos los más comunes.
Subrutinas
El número medio de variables locales tı́picas coincide con el de
argumentos tı́picos, siendo 3. Y también coinciden la media de
argumentos máximos con las variables locales máximas siendo 6.

Algunos estudios
Porcentaje de uso de tipos de operaciones
P(Transferencia) = 0,5; P(Bifurcaci ón) = 0,2; P(Proceso) = 0,3
P(Condicional|Bifurcaci ón) = 0,75; P(Incondicional|Bifurcaci ón) = 0,25
Porcentaje de uso de modos de direccionamiento
P(Indirecto) < 0,03; P(Relativoreg + dsplz) = 0,6;

P(Comaflotante|Inmediatos) = 0,2;
P(Enteros|Inmediatos) = 0,4; P(Comparaciones|Enteros|Inmediatos) = 0,8

Tema 5 - La unidad de control
Problema → algoritmo → formalizar → imagen ejecutable → estática
(disco duro) y dinámica (procesador) → fases de ejecución →
operaciones → señales de control
Fases de ejecución
1 Búsqueda o fetch: se copia al registro de instrucciones (RI) la
instrucción a la que apunta el contador de programa (PC).
2 Decodificación: se piensa qué se tiene que hacer con las
instrucciones que ya están cargadas.
3 Leer operandos
4 Realizar la operación
5 Escribir resultados
Hemos de ir actualizando el PC, ya bien sea de tamaño fijo (se actualiza
en paralelo cuando se puede), o de tamaño variable (después de la fase
de decodificación, como es el caso de Intel).

Operaciones elementales
Las fases de leer operandos, realizar la operación, y escribir los
resultados se pueden descomponer en operaciones elementales
de transferencia (mover info), y de proceso (transformar info).
En las máquinas los registros se nombran como L y su guardado
se activa con un flanco de bajada ocupando 21 ciclo de reloj.
También aparecen los buffer-triestado, denotados por T, y como
su nombre dice tienen 3 estados: estado 0, copia un 0; estado 1,
copia un 1; estado de alta impedancia (Z), si llega un electrón
ve una resistencia ∞ y no pasa evitando ası́ ruido en los buses.
Ejemplo de operaciones elementales (C + D → A)

Operaciones con la máquina de pizarra
Fase de búsqueda: apuntar con PC a la instrucción y llevarla a RI:
1 CP → DIR: establecer camino con TACP y salvar info con
LDIR. 1 ciclo.
2 [CP] → RI: establecer camino con TMEM, R/W , IO/M
y salvar info con LRI. 2 ciclos.
Fase de decodificación: ocupa 1 ciclo y de momento dejaremos
un ciclo en blanco.
Actualización del PC (todo en el mismo ciclo):
1 Transferir cierto desplazamiento con DIT
2 Se suma el desplazamiento con el PC con TR/SM
3 Guardamos el PC actualizado con LCP
En total tardamos 5 ciclos en prepararnos para ejecutar una
instrucción
Máquina de pizarra y ejemplo de como se ejecuta mov r3,

[r12+desplazamiento]

Diseño de la unidad de control
Existen 2 tipos de unidades de control
U.C cableadas: son las que están hechas con circuitos secuenciales
clásicos.
+Mı́nimo → barato
+Rápido
−Difı́cil de depurar
U.C almacenadas: guardan un cronograma en una memoria ROM
de control
+Fácil de depurar → ahorrar tiempo
+Compatibilidad binaria
−Lento (implica leer memoria)
Antiguamente se utilizaban ambas dependiendo del computador, pero
hoy en dı́a todas son cableadas.

Microprogramación
Requisitos de la microprogramación
Ser capaz de retener todas las palabras de control del repertorio
Ser capaz de hacer corresponder el código de operación con el
microprograma
Ser capaz de seguir la secuencia de microinstrucciones hasta el final
Tamaño
T1 = k · (⌈c1 · n⌉ + s · ⌈log2 k⌉)

Donde k son las palabras de control, c1 el nivel de compresión, n el
número de señales de control diferentes, y
s(implı́cito) = 0; s(explı́cito) = 1

Microprogramación - Secuenciamiento explı́cito
Consiste en incluir en cada microinstrucción la dirección de la
siguiente, las señales de control, y un bit llamado de fin que indica
si es o no la última microinstrucción.
+Reutiliza palabras de control
−Tamaño añadido por el puntero

Microprogramación - Secuenciamiento implı́cito
Consiste en tener ordenadas secuencialmente todas las
microinstrucciones. Ya no es necesario almacenar direcciones ya
que tenemos un contador de microprograma. Con la ayuda de una
ROM encontramos la primera instrucción
+Al no tener puntero es más pequeño
−Se van a repetir más palabras de control

Microprogramación - Compresión
En una máquina, en un instante, solo puede estar activo un
buffer-triestado, entonces si tenemos n b-t, tenemos n + 1 combinaciones
diferentes de estados de los buffer, n (se activa el n-ésimo), +1 no hay
ninguno activo.
Tendremos entonces un código tal que 0000 . . . 010 . . . 00, que podemos
comprimir. Se suele hablar de dos formas de programación:
Microprogramación vertical: se codifica y comprime en un factor
c ∈ (0, 1]
Microprogramación horizontal: nada cambia, todo se queda
igual. c = 1

Nanoprogramación
Consiste en dividir la programación en dos niveles. En el primero de
ellos, supongamos que tenemos secuenciamiento explı́cito. Lo que vamos
a hacer es sustituir las palabras de control por punteros a un
segundo nivel, que es un repositorio donde se almacenan todas estas.
Deben cumplirse estas condiciones:
Hay cierta reutilización de las palabras de control, y solo algunas pocas
de las palabras de control tienen significado real.
T2 = k · (⌈log2 v ⌉ + s · ⌈log2 k⌉) + ⌈c2 · n⌉ · v
v = ⌈ρ · k⌉
Donde ρ es la tasa de palabras diferentes

Este es un esquema comparativo de microprogramación (programación en
1 nivel) frente a nanoprogramación (programación en 2 niveles)

Ejemplo de microprogramación VS nanoprogramación

Usando secuenciamiento explı́cito se tienen 100 señales de control
diferentes, 830 microinstrucciones necesarias para implementar todas las
instrucciones del repertorio, pero solo 32 de ellas son diferentes. ¿Qué es
mejor, microprogramación o nanoprogramación?
El número de celdas que se necesitan para trabajar con un único nivel
(microprogramación) (s vale 1 al estar tratando con secuenciamiento
explı́cito, y cn = 1 al no haber compresión (horizontal)) es:
T1 = 830 · (⌈1 · 100⌉ + 1 · ⌈log2 830⌉) = 91300
El número de celdas que se necesitan para trabajar con dos niveles es:
T2 = 830 · (⌈log2 554⌉ + 1 · ⌈log2 830⌉) + ⌈1 · 100⌉ · 554 = 72000
Como T2 < T1 , es mejor la nanoprogramación.

Tema 6 - Memorias
Toda memoria consta de un bus de direcciones (continente), un bus de
datos (contenido), y ciertas señales de control como ME, IO/M, R/W
Propiedades
Velocidad
Capacidad de transferencia (ancho de banda)
Volatilidad (se pierde la información o no)
Necesidad de recuperación o reinscripción (se puede ir la carga de
los condensadores)

Tema 6 - Memorias
Parámetros
Capacidad: palabras · longitudpalabra
Organización: 128Kx8, 64x16, etc...
Capacidad de direccionamiento: n lı́neas de direcciones → 2n
posiciones de memoria
Tiempo de escritura (te ): tiempo que pasa desde que se presenta
la información hasta que realmente se escribe.
Tiempo de lectura (tl ): tiempo que pasa desde que se solicita la
lectura hasta que se sirve.
te +tl
Tiempo de acceso (ta ): ta = 2
Tiempo de ciclo (tc ): tiempo desde que se hace un acceso hasta

que se puede hacer el siguiente, incluyendo la reinscripción en caso
necesario.
longitudpalabra
Velocidad de transferencia (Vt ): Vt = tc

Tema 6 - Memorias
Destacan memorias RAM (Random Access Memory) que son de lectura

y escritura, y memorias ROM (Readable Only Memory) solo de lectura
Memorias SRAM (RAM estática)

Están hechas con biestables (R-S, J-K, etc...), lo que conlleva que dentro
de estos haya transistores BJT.
+Rápida (∼ 10ns)
+Sencilla, no necesita reinscripción
−Al estar hecha con BJT consume bastante
−Ocupa gran área de silicio lo que repercute en un mayor coste

Tema 6 - Memorias
Memorias DRAM (RAM dinámica)

Están hechas con transistores MOSFET y condensadores. Funcionan
viendo si el condensador está o no cargado, y si hay que cargarlo o no.
+Ocupa poco
+Consume poco al ser MOSFET
−Lenta (∼ 60ns)
−Necesita reinscripción (los condensadores pueden descargarse)
−No hay perı́metro suficiente para colocar todos los pines del bus
de datos, hay que multiplexarlos en dos golpes, lo que supone una
reducción de velocidad

Tema 6 - Memorias
¿Cómo se pueden aumentar las prestaciones de las memorias?
Usar DDR (Double Data Rate), es decir, hacer que además de
funcionar en flanco de bajada, también funcionen en flanco de
subida.
Solapar las etapas de acceso = segmentar las operaciones de
acceso a memoria:
SSRAM (sı́ncrona)
SDRAM (sı́ncrona)
FPM (Fast Page Memory)
EDO (Extended Data Out)
Estos serı́an los cronogramas de memorias convencionales, después
veremos los de las mencionadas en esta diapositiva

Tema 6 - Memorias
Ahora comparemos con el de una memoria FPM cómo se obtendrı́an 3

datos A, B, y C suponiendo que están en el mismo bloque o página
Ahora comparemos con el de una memoria EDO cómo se obtendrı́an 3

datos A, B, y C suponiendo que están en el mismo bloque o página

Tema 6 - Memorias
Organizaciones alternativas de memoria

CAM (memoria asociativa por conjuntos): memorias sin punteros
o direcciones. Se da un código que se busca en la matriz de
búsqueda comparando columnas, se pasa a la matriz de datos que
devuelve otro código. Es útil para tablas de correspondencia.
Memoria multipuerta: tiene una velocidad superior y más
puertas, pero si desde puertas diferentes se accede a la misma
posición de memoria, se produce un conflicto. Se puede solucionar
con hardware pero reduce la velocidad. La VRAM es un ejemplo de
memoria multipuerta de 2 puertas, una que entrega el frame actual
y otra el siguiente.
n · longitudpalabra
Vt =
tc

Tema 6 - Memorias
Jerarquı́a de memoria
Las memorias no pueden ser grandes, rápidas, y baratas a la vez, es
aquı́ donde entra la jerarquı́a de memoria, que consiste en utilizar varias
tecnologı́as de forma que el microprocesador vea tanta memoria como
la más grande y tan rápida como la más veloz, colocándolas en este
orden:

Tema 6 - Memorias
Principio de localidad
El principio de localidad enuncia que no todo el mapa de memoria
es equiprobable, el proceso favorece ciertas posiciones de memoria.
Localidad temporal: si referencio una posición de memoria, pronto
volveré a hacerlo. Por ejemplo, si estoy ejecutando un bucle while,
en las sucesivas iteraciones estoy pasando por las mismas posiciones
de memoria leyendo las instrucciones que hay dentro de este.
Localidad espacial: si referencio x, referenciaré x + 1, x + 2 . . ..
Por ejemplo, cuando se iteran todos los elementos de un array con
un bucle for, ya que cada elemento está ”al lado” del otro.

Tema 6 - Memorias
Aciertos y fallos
Cuando la caché pide datos a la memoria principal se puede producir
hit o miss, de forma que el tiempo medio de acceso se calcula como
tm = ta + (1 − h) · p
Donde ta es el tiempo de acierto, p la penalización que depende del

tiempo de transferencia, el tiempo de acceso a memoria principal, entre
otras cuestiones; y h la tasa de acierto.
Criterios a tener en cuenta en el diseño

Búsquedas en caché
En caso de no encontrar → algoritmo de reemplazo
Transferencias de los bloques → coherencia

Tema 6 - Memorias
Ejemplo de problema de aciertos y fallos
Un ordenador dispone de una caché con un ta = 20ns por palabra, y una memoria principal con un ta = 100ns por
palabra. Se usa la polı́tica de escritura directa. Mediante programas de prueba se observa que el 53 % de las
referencias a memoria son de instrucciones y de las que son a datos, 8 de lectura y 2 de escritura. La tasa de
aciertos es del 98 %, ¿cuánto tiempo se tarda en acceder a memoria?
Sabemos que el tiempo medio es ta = P(L) · tl + P(E ) · te , entonces primero calcularemos las probabilidades. La
probabilidad de leer es que lea una instrucción más la de que referencie un dato y lo lea:
P(L) = P(I ) + P(I ∩ l) = 0,53 + 0,47 · 0,8
Y la probabilidad de escribir es la de estar trabajando con datos y tener que escribir uno:
P(E ) = P(I ∩ e) = 0,47 · 0,2
El tiempo de escritura es te = 100 · 10−9 porque nos lo dice la escritura directa (escribe a la velocidad de la más
lenta), y la de lectura se calcula con:
−9 −9 −9
tm = tn1 + (1 − h) · tn2 ; tl = 20 · 10 + (1 − 0,98) · 100 · 10 = 22 · 10
−9 −9 −9
ta = (0,53 + 0,47 · 0,8) · (22 · 10 ) + (0,47 · 0,2) · 100 · 10 = 29,332 · 10 s

Tema 6 - Memorias
La caché es una memoria que se coloca entre el µP y la memoria
principal, de tal forma que cuando por el bus de direcciones llega una
etiqueta y una palabra, se mira si está la etiqueta, y con la palabra se
direcciona la posición de memoria. Tenemos 3 formas de organizar la
caché:
Correspondencia directa
A cada bloque de memoria principal le corresponde una lı́nea de
caché donde alojarse. La etiqueta se divide en etiqueta y lı́nea. El
proceso de búsqueda consiste en comparar la etiqueta y acceder a
memoria principal.
+Tiempobusqueda = 0 = Tiemporeemplazo
+Sistema sencillo
−Posibles conflictos sobre una lı́nea
−Tasa de aciertos baja

Tema 6 - Memorias
Este es el esquema de correspondencia directa
Tamaños
tamañoprincipal
B=
tamañobloque
tamañocaché
N=
tamañobloque

Tema 6 - Memorias
Totalmente asociativa
Es una de las formas de remediar los inconvenientes de la
correspondencia directa. Consiste en dejar libertad a la memoria
principal en asociarse a las lı́neas de caché que convengan en cada
momento. La etiqueta también se subdivide en etiqueta y palabra.
−Como puede estar en cualquiera no sabemos dónde está, hay que
hacer una búsqueda
longitudetiqueta = log2 (B)
longitudpalabra = log2 (longitudB )
tamañomatrizbúsqueda = N · longitudetiqueta
tamañomatrizdatos = N · log2 (N)
tamañototal = N · (log2 B + log2 N)

Tema 6 - Memorias
Asociativa por conjuntos

Nos quedamos con lo mejor de la correspondencia directa y la
totalmente asociativa. Consiste en agrupar las lı́neas en conjuntos de
tamaño 2n , y ahora se llaman vı́as. Hay que buscar dentro de cada
conjunto, luego hay tiempo de búsqueda y de reemplazo. El campo se
divide en etiqueta, conjunto, y palabra
N
C=
V
longitudpalabra = log2 (longitudB )
longitudconjunto = log2 (C )

B
longitudetiqueta = log2
C

Tema 6 - Memorias
Asociativa por conjuntos
tamañomatrizbúsqueda/conjunto = V · longitudetiqueta
tamañomatrizdatos/conjunto = V · log2 (V )
B ·V

tamañototal = V · C · log2 + log2 (V )
N
El esquema es el siguiente:

Tema 6 - Memorias
Comparativa organizaciones de caché

Búsqueda tbúsqueda Reemplazo Tasa de aciertos Coste
CD No − No Baja Bajo
TA Sı́ Alto Sı́ Alta Alto
AC Sı́ Bajo Sı́ Media-alta Medio-bajo
Se puede ver que la más óptima es la asociativa por conjuntos, sin

embargo, la correspondencia directa es bastante interesante al tener bajo
coste y ser tan sencilla, además de que la tasa de aciertos se dice que es
baja pero no tanto realmente.

Tema 6 - Memorias
Algoritmos de reemplazo
Cuando el procesador solicita a caché un dato y no está en caché y lo
tiene que traer de principal, mira a ver si tiene espacio, y en caso de que
esté llena se necesita sacar algo de caché para que pueda entrar este
nuevo, pero ¿cuál sacamos?
Aleatorio: no recomendable, es muy costoso.
FIFO (First Input First Output): el primero que entró sale. Necesita
un contador.
LRU (Less Recent Used): el menos reciente usado. Necesita un
contador. Es el mejor.
Un estudio de Hennesy-Patterson afirma que si la caché > 256 KB, el
método de reemplazo da igual, sin embargo, si es pequeña el mejor es el
LRU.

Tema 6 - Memorias
Cuando accedemos a memoria, P(L) ≃ 23 , y la P(E ) = P(L),
tm = P(L) · tl + P(E ) · te
Polı́ticas de escritura
Escritura directa: escribe en caché y en principal. Asegura siempre
la coherencia.
−Aumenta el tráfico de memoria
−Trabaja a la velocidad de la más lenta (principal)
Postescritura: escribe en caché siempre, excepto en principal
cuando hay reemplazo, que lo indica el dirty-bit
+Menor tráfico de memoria
+Trabaja a la velocidad de la más rápida
−Aumenta la penalización
Si hay fallo en escritura, en caso de estar usando postescritura se ubica
en escritura, y si estábamos con escritura directa no.

Tema 7 - Entrada/Salida
Necesitamos relacionar el computador (sı́ncrono y codificado) con el
mundo exterior (analógico y ası́ncrono). Esto lo podemos lograr
mediante periféricos de comunicación hombre-máquina,
máquina-máquina, de almacenamiento masivo, etc. Pero, ¿cómo los
gestionamos?

Módulo E/S
Sus funciones son:
1 Asignar el mapa de memoria de E/S a cada periférico
Mapas de memoria disjuntos (Intel): no se sabe si es
de memoria o de E/S, se soluciona con la señal IO/M
E/S mapeada en memoria (Motorola): en el mapa de
memoria hay un rango de posiciones que son de E/S
Mapa E/S doble: el dispositivo que accedo en cada
puerto depende del tipo de acceso, la secuencia, cómo
esté programado...
2 Implementar la sincronización

Tenemos 3 formas diferentes de realizar la E/S:
E/S programada, sondeo o polling

Tanto la disponibilidad y la transferencia son responsabilidad de la CPU.
La CPU ejecuta una tarea principal, pero además, gobierna los periféricos
cada cierto tiempo τ . Les va preguntando si necesitan algo.
+Sistema sencillo
+No necesita soporte hardware
−Se pierde un tiempo fijo cada τ

E/S interrupción
La disponibilidad es responsabilidad del periférico, y la transferencia de la
CPU. Mientras se ejecuta la tarea principal, si los periféricos necesitan
interrumpir la tarea lo hacen y se activa una subrutina. ¿Qué sucede
realmente?
1 El periférico realiza la solicitud
2 El procesador finaliza la ejecución en curso → latencia de
interrupción
3 El procesador comprueba si hay otras interrupciones y elige a quién
atender
4 Salva el contexto
5 Transfiere el control a la rutina de servicio
6 La rutina realiza configuraciones necesarias previas
7 Efectúa la transferencia
8 Devuelve el control
A su vez, la E/S se puede implementar de diferentes formas, con una
señal Int, varias de estas, el mecanismo llamado Daisy-Chain, un
controlador PIC...
(lint + trutina + tdato · b) · n
t(n, b) =
b
Conviene poner al final a los más avariciosos para que los que lo son
menos también puedan solicitar.

E/S acceso directo a memoria (DMA)
Tanto la disponibilidad y la transferencia son responsabilidad del
periférico. El controlador DMA gestiona los buses ya que el periférico no
puede leer ni escribir en memoria directamente, ya que estos buses los
gestiona la CPU, ası́ que este controlador es la solución. ¿Qué sucede
realmente?
1 El periférico envı́a la solicitud (hold)
2 El procesador termina lo que está haciendo → latencia
3 El procesador emite reconocimiento sin salvar el contexto
4 Programar el controlador DMA → ejecutar una interrupción
5 Se produce la E/S con ayuda del controlador
6 Indica el final a la CPU → ejecutar una interrupción
Solo es interesante para bloques grandes debido a las dos interrupciones
que se producen.

A su vez tenemos 3 tipos de DMA a la hora de producirse la E/S:
Robo de ciclo - DMA

Se alterna la E/S con la ejecución de la tarea principal.
t(n) = ldma + tprog + ttrans · n + CPI · n
Donde n es el número de bytes que movemos.

Ráfaga - DMA
Solo se atiende a la E/S, se detiene la tarea principal.
(ldma + tprog + ttrans · b) · n

t(n, b) =
b
Donde n es el número de bytes que movemos, y b de cuántos en cuántos
los movemos.

Transparente - DMA
Igual que en robo de ciclo pero mientras se produce la E/S, se
ejecutan instrucciones de la tarea principal que no afecten a los buses
(además de las que se producen en los tiempos de ejecución de principal),
normalmente las instrucciones que no son de carga-almacenamiento
jt k
trans
r =n· 1+ ·p
CPI

Almacenamiento masivo - Discos duros

Funcionan mediante cabezas, platos, y campos magnéticos
~ Los discos duros convencionales giran a ω1 = 7200
modulados (I ∝ dB).
rpm, mientras que existen otros de ω2 = 10000 rpm.
El proceso de lectura escritura es el siguiente:
1 Mover las cabezas a un radio r
2 Esperar a que gire y se coloque debajo
3 Transferencia de información

Almacenamiento masivo - Discos duros

El tiempo que se tarda en transferir un dato es:
T = tbúsqueda + tretardorotacional + ttransferencia
Donde
θ
tretardorotacional =
ω
b
ttransferencia =
Vt
Se considera que en el peor de los casos θ = 0,5, es decir, que el dato
esté en el lado opuesto del plato.
Desfragmentación: juntar los sectores que contienen un mismo archivo.

Fórmulas importantes
Función de transición (Turing), q y p son estados, r y w sı́mbolos, y d

el sentido en el que desplazarse.
δ(q, r ) → (p, w , d)
Tiempo
t = ciclos · τ
Productividad
procesoscompletados
p=
tiempo
Tiempo de pared (tw )
tw = tcpu + tsys + tespera

CPI
n
X
CPIi · ri
i=1 ciclosp
CPIp = n =
X rp
ri
i=1
Tiempo de programa (tp )
tp = rp · CPIp · τ
MIPS
−6
instrucciones ciclos f · 10
MIPS = · · 10−6 =
ciclo segundo CPI
Ley de Amdahl para el Speed-Up
1
S= fm
(1 − fm ) + am

Speed-Up
tmejora
S=
tmejora
Teorema fundamental de la numeración
p−1
X p−1
X −1
X
V = di · b i = di · b i + di · b i = [V ] + {V }
i=−q i=0 i=−q
Exponente en coma flotante
E = ⌊log2 |n|⌋ + ε
Mantisa en coma flotante

jn ′
k
M = E · 2b −β
2
Número en coma fija
n = ⌊n · pcoma ⌋

Generación de acarreo
gi = Xi · Yi
Propagación de acarreo
pi = Xi ⊕ Yi
Celdas de memoria ROM de control en un nivel
T1 = k · (⌈c1 · n⌉ + s · ⌈log2 k⌉)
Celdas de memoria ROM de control en dos niveles
T2 = k · (⌈log2 v ⌉ + s · ⌈log2 k⌉) + ⌈c2 · n⌉ · v
v = ⌈ρ · k⌉

Lı́neas de dirección de una pastilla AxB bits
direcciones = log2 (A)
Lı́neas de datos de una pastilla AxB bits
datos = B
Capacidad de una pastilla AxB bits
2direcciones · 2log2 (datos) = 2direcciones+log2 (datos) = 2log2 (A)+log2 (B)
Tiempo de ciclo
tciclo = tacceso + trestauraci ón
Accesos por segundo
△t
Accesos =
tc

Bloque
direcci ón
bloque =
tamañobloque
Lı́nea
lı́nea = bloque mód númerolineas
Velocidad de transferencia
Anchopalabra
Vt =
tc
Número de bloques
tamaño memoria principal
B=
tamaño bloque
Número de lı́neas
tamaño memoria caché
N=
tamaño bloque

Forma totalmente asociativa
Longitudetiqueta = log2 (B)
Longitudpalabra = log2 (LongitudB )

Tamañomatrizbúsqueda = N · longitudetiqueta
Tamañomatrizdatos = N · log2 (N)
Tamañototal = N · (log2 B + log2 N)

Forma asociativa por conjuntos

N
Conjuntos =
V
Longitudpalabra = log2 (longitudB )
Longitudconjunto = log2 (C )

B
Longitudetiqueta = log2
C
Tamañomatrizbúsqueda/conjunto = V · longitudetiqueta
Tamañomatrizdatos/conjunto = V · log2 (V )
B ·V

tamañototal = V · C log2 + log2 (V )
N

Tiempo medio
t = tn1 + (1 − h) · tn2
Tiempo medio de acceso
ta = P(L) · tl + P(E ) · te
Tiempo de interrupción
(lint + trutina + tdato · b) · n

t(n, b) = [ciclos]
b
Tiempo DMA en robo de ciclo
t(n) = ldma + tprog + ttrans · n + CPI · n [ciclos]
Tiempo DMA en ráfaga
(ldma + tprog + ttrans · b) · n

t(n, b) = [ciclos]
b

Instrucciones en DMA modo transparente
jt k
trans
r =n· 1+ ·p
CPI
Velocidad para modo de vı́deo AxB
Vt = A · B · b · f
Memoria en KB para un frame

p·d
F =
213
Tiempo de transferencia de un disco duro
T = tbúsqueda + tretardo rotacional + ttransferencia

θ
trrotacional =
ω
b
ttransferencia =
Vt
Equivalencias importantes
Exponencial de base 2 en forma de serie geométrica

n−1
n
X
i 1 − 2n−1 · 2
2 =1+ 2 =1+ = 1 − (1 − 2n ) = 1 − 1 + 2n = 2n
1−2
i=0
Relación BIN − C2

BIN (Z , n) si Z ≥0
C2(Z , n) = C2(Z , n) = BIN (2n +Z , n)
BIN (2n − |Z |, n) si Z <0
Relación BIN − C1

BIN (Z , n) si Z ≥0
C1(Z , n) =
BIN (2n − 1 − |Z |, n) si Z <0

Relación BIN − EX − 2n−1
EX − 2n−1 (Z , n) = BIN (Z + 2n−1 , n)
Relación BIN −decimal

n−1
X
VAL − BIN (Z , n) = d i · 2i
i=0
Relación SM−decimal
n−2
X
VAL − SM(Z , n) = (−1)dn−1 · d i · 2i
i=0

Relación C1−decimal
n−2
X
VAL − C1(Z , n) = di · 2i − dn−1 · 2n−1 + dn−1
i=0
Relación C2−decimal
n−2
X
VAL − C2(Z , n) = di · 2i − dn−1 · 2n−1
i=0
Relación EX − 2n−1 −decimal

n−2
X
VAL − EX − 2n−1 (Z , n) = di · 2i − dn−1 · 2n−1
i=0


Wuolah Free ResumenTeoriaEOC

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Wuolah Free ResumenTeoriaEOC

Cargado por

Copyright:

Formatos disponibles

ResumenTeoriaEOC.

Estructura y Organización de Computadores

2º Grado en Ingeniería Informática

Escuela Politécnica Superior

Reservados todos los derechos.

Pablo Garcı́a Garcı́a

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 1 / 139

1 Tema 1 - Introducción, historia y rendimiento

3 Tema 3 - La ruta de datos

4 Tema 4 - El repertorio de instrucciones

5 Tema 5 - La unidad de control

8 Apéndice (fórmulas y equivalencias)

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 2 / 139

Este es el resumen de la parte teórica que hice durante el curso 2020-2021

Resumen y dibujos realizados por Pablo Garcı́a Garcı́a

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 3 / 139

Computador: es una máquina destinada a procesar información,

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 4 / 139

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 5 / 139

Para los problemas de complejidad exponencial no existe un algoritmo

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 6 / 139

Arquitectura de Von Neumann (1945)

Máquinas de flujo de datos

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 8 / 139

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 9 / 139

Donde rp es el recuento (número de instrucciones a ejecutar), que

Ahora podemos definir el tiempo de programa:

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 10 / 139

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 11 / 139

tmejora tmaqA rpsin · CPIpsin · τsin MIPSsin ciclossin

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 12 / 139

cCPU 150 · 106

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 13 / 139

Teorema fundamental de la numeración

Siendo p y q el número de dı́gitos de la parte entera y fraccionaria.

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 14 / 139

Codificación de un entero a una base b

Ejemplo: codificar 18310 en binario → 101101112

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 15 / 139

Codificación de una mantisa a base 2

Ejemplo: codificar 0,14310 en binario

Para codificar, por ejemplo, 183,14310 a binario, combinamos los dos

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 16 / 139

Ejemplo: codificar −9610 en SM

Si estuviéramos buscando 96 ya estarı́a, pero queremos -96, luego

Ejemplo: codificar −9610 en C1

Si estuviéramos buscando 96 ya estarı́a, pero queremos -96, luego

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 18 / 139

Ejemplo: codificar −9610 en C2

Si estuviéramos buscando 96 ya estarı́a, pero queremos -96, luego

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 19 / 139

Ejemplo: codificar −9610 en EX 2n−1

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 20 / 139

−12,407110 coma flotante, mantisa de 10 bits SM y exponente 6 bit

E = ⌊log2 |12,4071|⌋ + 1 = 3 + 1 = 410

Ejemplo: −57,86410 coma fija 10 bits, C2, coma en 23

⌊−57,864 · 23 ⌋ = ⌊−462,912⌋ = −46310

Utilizando el algoritmo de codificación a complemento a 2 y

Con una precisión de 23

Pablo Garcı́a Garcı́a Estructura y Organización de Computadores 22 / 139

IEEE 754 Simple precisión

Ejemplo: −2,759 · 1012 simple precisión IEEE 754

E = ⌊log2 | − 2,759 · 1012 |⌋ = 4110