Tema 3: Unidad de Entrada/Salida. Formulario

---

0. Conversiones útiles

Magnitud	Relación
Período y frecuencia	$t = 1/f$
Tiempos	1 s $= 10^3$ ms $= 10^6$ µs $= 10^9$ ns
Pasar un tiempo a ciclos de CPU	$\text{ciclos} = t / t_{ciclo}$
Pasar ciclos a tiempo	$t = \text{ciclos} \cdot t_{ciclo}$
Prefijos binarios	1 Ki $= 2^{10}$, 1 Mi $= 2^{20}$, 1 Gi $= 2^{30}$
Prefijos decimales	1 k $= 10^3$, 1 M $= 10^6$, 1 G $= 10^9$

Ejemplo: CPU a 4 GHz: $t_{ciclo} = 0.25$ ns. Un bus a 1 GHz ($t_{bus} = 1$ ns) dura $1/0.25 = 4$ ciclos de CPU. Una búsqueda de 4 ms son $4 \cdot 10^6 / 0.25 = 16 \cdot 10^6$ ciclos.

---

1. Espacio de direcciones de E/S

1.1 E/S localizada en memoria

$N_D = 2^n = N_{DM} + N_{DP} \qquad\Longrightarrow\qquad N_{DP} = 2^n - N_{DM}$

Variable	Significado
$n$	Líneas de dirección
$N_D$	Direcciones totales
$N_{DM}$	Direcciones ocupadas por la memoria
$N_{DP}$	Direcciones que quedan para periféricos

Uso: memoria y E/S comparten el espacio. Ejemplo: 24 líneas y 12 MiB: $N_{DP} = 16 \cdot 2^{20} - 12 \cdot 2^{20} = 2^{22}$.

1.2 E/S aislada

$N_{DM} = N_{DP} = 2^n$

Uso: líneas de control separadas para memoria y E/S. La memoria no interviene en el cálculo. Ejemplo: 32 líneas: $N_{DP} = 2^{32}$, sea cual sea la memoria.

1.3 Número máximo de periféricos

$N_{\text{periféricos}} = \frac{N_{DP}}{d}$

Variable	Significado
$d$	Direcciones (puertos) que ocupa cada periférico

Ejemplo: $N_{DP} = 2^{22}$ y $d = 4$: $2^{20} = 1\,048\,576$ periféricos. Con puertos de 16 bits: $2^{16}/4 = 2^{14} = 16\,384$.

1.4 Tamaño de un rango de direcciones

$N = \text{dir}_{\text{final}} - \text{dir}_{\text{inicial}} + 1$

Ejemplo: hueco PCI de 0xC000_0000 a 0xFFFF_FFFF: $1\,073\,741\,824$ direcciones $= 1$ GiB (unidad direccionable: byte).

---

2. E/S controlada por programa

2.1 Fases de una lectura de un bloque

$t_{inicio} = N_{reg} \cdot t_{bus} \qquad t_{bloque} = \frac{S_{bloque}}{v_{disco}} \qquad t_{listo} = t_{inicio} + t_{búsqueda} + t_{bloque}$

Variable	Significado
$N_{reg}$	Registros que escribe la CPU para lanzar la orden (2 con programa e interrupciones, 3 con DMA o PE/S en los ejemplos)
$t_{bus}$	Duración de una operación de bus
$t_{búsqueda}$	Tiempo que tarda el disco en localizar el bloque
$S_{bloque}$	Tamaño del bloque
$v_{disco}$	Velocidad sostenida del disco
$t_{listo}$	Instante en que el dato está disponible

Ejemplo: $t_{inicio} = 8$, $t_{búsqueda} = 16\,000\,000$ y $t_{bloque} = 26\,041.66$ ciclos: $t_{listo} = 16\,026\,049.66$ ciclos.

Detección: con espera activa, la CPU solo ve el estado al acabar un ciclo de bus. Se redondea al siguiente múltiplo de $t_{bus}$ en ciclos (16 026 052 en el ejemplo).

2.2 Copia de un bloque por la CPU

$N_{pb} = \frac{S_{bloque}}{S_{palabra}} \qquad t_{copia} = 2 \cdot N_{pb} \cdot t_{bus}$

Variable	Significado
$N_{pb}$	Palabras por bloque
$S_{palabra}$	Tamaño de la palabra que mueve el bus
2	Cada palabra requiere leer del periférico y escribir en memoria

Ejemplo: 4 KiB y palabras de 8 B: $N_{pb} = 512$; $t_{copia} = 2 \cdot 512 \cdot 4 = 4096$ ciclos.

2.3 Porcentaje de CPU en espera activa

$P_{espera} = \frac{t_{espera}}{T_{total}} \cdot 100\ \% \qquad T_{total} = T + t_{copia}$

Ejemplo: $16\,026\,050 / 16\,030\,148 \approx 99.97\ \%$.

2.4 Lectura de una ráfaga de bloques contiguos

$T_{total} = T + t_{copia} + (N_b - 1)(T_2 + t_{copia}) \qquad T_2 = 2t_{bus} + t_{bloque}\ (\text{redondeado al ciclo de bus})$

$N_b = \frac{S_{total}}{S_{bloque}} \qquad v_{media} = \frac{S_{total}}{T_{total}}$

Variable	Significado
$N_b$	Número de bloques
$T$	Fin de la espera del primer bloque (con búsqueda)
$T_2$	Espera de cada bloque siguiente (sin búsqueda)

Ejemplo: 100 MiB: $N_b = 25\,600$; $T_{total} = 787\,788\,800$ ciclos $\approx 0.197$ s; $v_{media} \approx 508$ MiB/s.

---

3. Interrupciones

3.1 Sobrecarga de interrupciones periódicas

$t_{int} = 2\,t_{cc} + t_{RSI} \qquad \text{Sobrecarga} = \frac{f_{int} \cdot t_{int}}{1\text{ s}} \cdot 100\ \%$

Variable	Significado
$t_{cc}$	Tiempo de un cambio de contexto (hay dos: entrada y salida)
$t_{RSI}$	Duración de la rutina de servicio
$f_{int}$	Interrupciones por segundo (frecuencia del tic)

Ejemplo: 100 Hz, $t_{cc} = 1$ µs, $t_{RSI} = 300$ ns: $100 \cdot 2.3\text{ µs} = 230$ µs, es decir 0.023 %. Con 1000 Hz y $t_{int} = 3$ µs: 0.3 %.

3.2 Frecuencia máxima para una sobrecarga dada

$f_{max} = \frac{p \cdot 1\text{ s}}{t_{int}}$

Variable	Significado
$p$	Sobrecarga máxima admitida, en tanto por uno

Ejemplo: $p = 0.01$ y $t_{int} = 3$ µs: $f_{max} = 10\,000/3 \approx 3333$ Hz.

3.3 Energía: interrupciones frente a espera activa

$t_{activo} = \frac{N_{instr} \cdot CPI}{f} \qquad E_{int} = t_{activo} \cdot k + t_{sleep} \cdot 1 \qquad E_{act} = (t_{activo} + t_{sleep}) \cdot k$

$\text{Ahorro} = \frac{E_{act} - E_{int}}{E_{act}} \cdot 100\ \% \qquad \text{Duración relativa de la batería} = \frac{E_{act}}{E_{int}}$

Variable	Significado
ue	Unidad de energía: consumo de 1 s en bajo consumo
$k$	Cuántas veces más consume el modo normal (ue/s)
$t_{sleep}$	Tiempo dormido por periodo
$N_{instr}$	Instrucciones ejecutadas por periodo

Ejemplo: 8 MHz, 400 instrucciones, $t_{sleep} = 0.5$ s, $k = 5000$: $t_{activo} = 50$ µs, $E_{int} = 0.75$ ue, $E_{act} = 2500.25$ ue; ahorro 99.97 %; la batería dura unas 3334 veces más.

3.4 Enmascaramiento individual

$RE_j = PI_j \cdot M_j \qquad PI = RE_1 + RE_2 + \cdots + RE_n$

Variable	Significado
$PI_j$	Petición por la línea $j$
$M_j$	Bit de máscara (1 = permitida, 0 = bloqueada)
$RE_j$	Petición efectiva (pasa el filtro)
$PI$	Señal única hacia la CPU

Uso: pasar la máscara a binario, quedarse con las peticiones con $M_j = 1$ y, de ellas, atender la más prioritaria. Ejemplo: máscara $5A_{16} = 0101\,1010_2$ con peticiones en PI1, PI3 y PI5: solo $M_5 = 1$, así que se atiende PI5.

3.5 Enmascaramiento por nivel

$\text{Se atiende si } C > A$

Variable	Significado
$C$	Nivel de prioridad de la petición (lo asigna el codificador)
$A$	Nivel de prioridad de ejecución de la CPU

Uso: una RSI eleva $A$ a su nivel al entrar y lo restaura al salir. Ejemplo: $C = 9 - j$ y se atiende PI5 ($A = 4$). Llegan PI2 (7), PI4 (5), PI6 (3), PI7 (2). Orden: PI2, PI4, fin de PI5, PI6, PI7.

3.6 Coste de una interrupción y ancho de banda

$t_I = t_{RI} + t_{SI} \qquad BW_{max} = \frac{B}{t_I}$

Variable	Significado
$t_{RI}$	Tiempo de reconocimiento de la interrupción
$t_{SI}$	Tiempo de ejecución de la RSI
$B$	Bytes transferidos por interrupción

Ejemplo: $B = 256$ B, $t_{RI} = 50$ ns, $t_{SI} = 100$ ns: $BW = 256/150\text{ ns} = 1.71$ GB/s.

3.7 Instrucciones máximas de la RSI para un ancho de banda

$t_T = \frac{B}{BW} \qquad t_{SI} = t_T - t_{RI} \qquad v_e = \frac{f}{CPI} \qquad N = t_{SI} \cdot v_e$

Variable	Significado
$t_T$	Tiempo disponible entre interrupciones
$v_e$	Velocidad de ejecución (instrucciones/s)
$CPI$	Ciclos por instrucción
$N$	Instrucciones máximas de la RSI

Ejemplo: $B = 512$ B, 800 MB/s, $t_{RI} = 80$ ns, 2 GHz, CPI = 4: $t_T = 640$ ns, $t_{SI} = 560$ ns, $v_e = 0.5 \cdot 10^9$, $N = 280$.

3.8 Identificación por encuesta

$t_{atención}(k) = t_{RI} + k \cdot t_{consulta} + t_{RSI} \qquad t_{atención}^{\text{líneas/MSI}} = t_{RI} + t_{RSI}$

Variable	Significado
$k$	Posición del periférico en el orden de encuesta
$t_{consulta}$	Tiempo de consultar un periférico

Ejemplo: $t_{RI} = 60$ ns, $t_{consulta} = 40$ ns, $t_{RSI} = 300$ ns, 6 periféricos: mejor caso 400 ns, peor caso 600 ns; con múltiples líneas o MSI, 360 ns.

3.9 Fracción de CPU consumida por un periférico que interrumpe

$P_{CPU} = f_{int} \cdot t_{atención} \cdot 100\ \%$

Ejemplo: interrupción cada 1 µs ($10^6$ por segundo): con encuesta (600 ns), 60 %; con múltiples líneas (360 ns), 36 %.

3.10 Lectura de un bloque con interrupciones

$t_{int} = 2t_{cc} + t_e + t_{copia} \qquad T_{total} = T + t_{int} \qquad P_{CPU} = \frac{t_{inicio} + t_{int}}{T_{total}} \cdot 100\ \%$

Variable	Significado
$t_e$	Ejecución de las instrucciones propias de la RSI
$T$	Instante en que se atiende la interrupción (siguiente ciclo de CPU tras el dato listo)

Ejemplo: $t_{int} = 8000 + 100 + 4096 = 12\,196$ ciclos; $T_{total} = 16\,038\,246$; $P_{CPU} = 12\,204/16\,038\,246 = 0.076\ \%$.

3.11 Ráfaga de bloques con interrupciones

$T_F = T + (N_b - 1)\left(t_{int} - t_{cc} + \lceil t_{bloque} \rceil\right) + t_{int}$

Uso: la RSI pide el bloque siguiente justo antes del cambio de contexto de salida (se cumple $t_{bloque} > t_{cc}$, sin solapamiento). Ejemplo: $T_F = 871\,954\,008$ ciclos $\approx 0.218$ s; $v_{media} \approx 459$ MiB/s.

---

4. DMA

4.1 Tiempo de CPU asociado a un DMA

$T_{DMA} = T_{DMA}(\text{inicio}) + T_{DMA}(\text{bus}) + T_{DMA}(\text{final})$

Término	Significado
inicio	Instrucciones de inicialización del controlador
bus	Tiempo de CPU detenida por haber cedido el bus
final	RSI de la interrupción de fin de transferencia

4.2 Lectura de un bloque con DMA

$t_{int} = 2t_{cc} + t_e \qquad T_{total} = T + t_{copia} + t_{int} \qquad T_{CPU} = t_{inicio} + t_{int}$

Ejemplo: $t_{int} = 8100$ ciclos (la copia la hace el DMA); $T_{total} = 16\,026\,056 + 4096 + 8100 = 16\,038\,252$; CPU $= 8112$ ciclos, es decir 0.05 %.

4.3 CPU total en una ráfaga: DMA frente a interrupciones

$T_{CPU} = N_b \cdot t_{int} + t_{inicio} \qquad \text{Mejora} = \frac{T_{CPU,INT} - T_{CPU,DMA}}{T_{CPU,INT}} \cdot 100\ \%$

Ejemplo: $25\,600 \cdot 8100 + 12 = 207\,360\,012$ frente a $25\,600 \cdot 12\,196 + 8 = 312\,217\,608$: 33.6 % menos de CPU.

4.4 Propagación y transmisión en un bus serie

$t_p = \frac{d}{c} \qquad t_t = \frac{\text{bits}}{BW_{teórico}} \qquad T = 2t_p + t_t \qquad BW_{ef} = \frac{\text{bits}}{T}$

Variable	Significado
$d$	Distancia al dispositivo
$c$	Velocidad de la luz, $3 \cdot 10^8$ m/s
$t_p$	Tiempo de propagación (se cuenta ida y vuelta: datos y confirmación)
$t_t$	Tiempo de transmisión de los datos

Ejemplo: 15 cm, 16 Gb/s. Byte a byte: $T = 1.5$ ns, $BW_{ef} = 5.33$ Gb/s (33 %). Ráfaga de 4 KiB: $T = 2049$ ns, $BW_{ef} = 15.99$ Gb/s (99.95 %).

4.5 DMA por robo de ciclos

$N = \frac{S_{bloque}}{W_{bus}} \qquad T = (c_{instr} + 1) \cdot N \cdot t_c \qquad P_{bus,E/S} = \frac{1}{c_{instr} + 1} \qquad P_{CPU} = 1 - P_{bus,E/S}$

Variable	Significado
$W_{bus}$	Bytes por transferencia del bus
$c_{instr}$	Ciclos de una instrucción
$t_c$	Período de reloj
$+1$	El ciclo robado por cada palabra

Ejemplo: 4 KiB con 4 B por ciclo: $N = 1024$; 5 ciclos por instrucción: $T = 6 \cdot 1024 \cdot 1\text{ ns} = 6.144$ µs; bus 16.7 %; CPU 83.3 %.

4.6 DMA transparente

$N_{instr} = \frac{N}{k} \qquad T = (N_{instr} \cdot c_{instr} - \text{ciclos no usados al inicio y al final}) \cdot t_c \qquad P_{bus,E/S} = \frac{N}{T/t_c}$

Variable	Significado
$k$	Transferencias por instrucción (ciclos en que la CPU no usa el bus)

Ejemplo: $k = 2$: $512$ instrucciones, $2560 - 2 = 2558$ ciclos, $T = 2.558$ µs; bus $1024/2558 \approx 40\ \%$; CPU 100 %.

---

5. Procesadores de E/S y canales

5.1 Velocidad máxima del canal

$\text{Selector: } v_T = \max\{v_{T1}, v_{T2}, \ldots\} \qquad\qquad \text{Multiplexor: } v_T = v_{T1} + v_{T2} + \cdots$

Ejemplo: dos dispositivos de 50 MB/s y dos de 20 MB/s: selector 50 MB/s; multiplexor 140 MB/s.

5.2 Tiempo por byte, ocupación del bus y velocidad efectiva

$t_{canal} = \frac{1\text{ B}}{v_T} \qquad t_T = \max\{t_{bus},\ t_{canal}\} \qquad P = \frac{t_{bus}}{t_T} \cdot 100\ \% \qquad v_{ef} = \frac{1\text{ B}}{t_T}$

Variable	Significado
$t_{bus}$	Tiempo que el bus del sistema está ocupado por cada byte
$t_{canal}$	Tiempo del canal por byte
$t_T$	Tiempo real por byte (manda el más lento)
$P$	Ocupación del bus (100 % significa saturado)

Ejemplo: 4 SSD de 200 MB/s y 4 cintas de 40 MB/s, $t_{bus} = 2$ ns.

• Selector: $t_{canal} = 5$ ns, $P = 40\ \%$, $v_{ef} = 200$ MB/s.
• Multiplexor: $v_T = 960$ MB/s, $t_{canal} = 1.04$ ns, $t_T = 2$ ns, $P = 100\ \%$, $v_{ef} = 500$ MB/s.
• Para no saturar: $t_{bus} \leq 1.04$ ns.

5.3 Lectura con PE/S

$t_{copia} = \frac{S}{v_{disco}} \qquad T_F = T + t_{copia} + t_{int} \qquad T_{CPU} = t_{inicio} + t_{int}$

Uso: el PE/S lee y escribe por buses distintos a la vez, así que la copia va al ritmo del disco y la CPU solo interviene una vez. Ejemplo: 100 MiB a 600 MiB/s: $t_{copia} \approx 666\,666\,667$ ciclos, $T_F = 682\,700\,823$ ciclos $\approx 0.171$ s; $v_{media} \approx 585$ MiB/s.

---

6. E/S de gráficos

6.1 Tamaño de un fotograma y tiempo de bus

$N_{px} = H \cdot V \qquad S_{frame} = N_{px} \cdot \frac{b_{px}}{8} \qquad N_{transf} = \frac{S_{frame}}{W_{bus}} \qquad t_{frame} = N_{transf} \cdot t_{bus}$

Variable	Significado
$H \times V$	Resolución horizontal por vertical
$b_{px}$	Profundidad de color (bits por píxel)
$W_{bus}$	Bytes por transferencia del bus

Ejemplo: Full HD a 32 bits: $2\,073\,600$ px, $8\,294\,400$ B, $1\,036\,800$ transferencias, $1.037$ ms.

6.2 Ocupación del bus con memoria compartida

$P_{CPU,E/S} = \frac{t_{frame} \cdot fps}{1\text{ s}} \qquad P_{pantalla} = \frac{t_{frame} \cdot f_{refresco}}{1\text{ s}} \qquad P_{bus} = P_{CPU,E/S} + P_{pantalla}$

Variable	Significado
$fps$	Fotogramas que escribe la CPU por segundo
$f_{refresco}$	Veces por segundo que el controlador lee la imagen (aunque no cambie)

Ejemplo: Full HD a 60 fps y 60 Hz: $6.22\ \% + 6.22\ \% = 12.44\ \%$ del bus.

6.3 Uso de CPU calculando píxeles

$t_{cálculo} = N_{px} \cdot N_{instr/px} \cdot t_{instr} \qquad P_{CPU} = \frac{t_{cálculo} \cdot fps}{1\text{ s}} + P_{CPU,E/S}$

Ejemplo: Full HD, 20 instrucciones de 0.25 ns por píxel: $t_{cálculo} = 10.37$ ms; a 60 fps, 62.2 %; con la escritura, 68.4 %.

6.4 Uso de CPU con GPU

$S_{órdenes} = N_{órd} \cdot S_{órd} \qquad t_{tx} = \frac{S_{órdenes}}{BW_{PCIe}} \qquad t_{constr} = N_{órd} \cdot c_{órd} \cdot t_{ciclo}$

$P_{CPU} = \frac{(t_{tx} + t_{constr}) \cdot fps}{1\text{ s}} \cdot 100\ \%$

Variable	Significado
$N_{órd}$	Órdenes de dibujo por fotograma
$S_{órd}$	Tamaño de cada orden
$BW_{PCIe}$	Ancho de banda efectivo del bus PCIe
$c_{órd}$	Ciclos para construir cada orden

Ejemplo: 100 000 órdenes de 8 B, 30 GB/s, 10 ciclos de 0.25 ns, 60 fps: $t_{tx} = 26.7$ µs (0.16 %), $t_{constr} = 0.25$ ms (1.5 %), total 1.66 %.

---

Tabla resumen rápida

Concepto	Fórmula
E/S localizada	$N_{DP} = 2^n - N_{DM}$
E/S aislada	$N_{DP} = 2^n$
Periféricos	$N_{DP}/d$
Copia por la CPU	$t_{copia} = 2 N_{pb} t_{bus}$
Sobrecarga periódica	$f_{int}(2t_{cc} + t_{RSI})$
Enmascaramiento individual	$RE_j = PI_j M_j$, $PI = \sum RE_j$
Enmascaramiento por nivel	atender si $C > A$
Coste de una interrupción	$t_I = t_{RI} + t_{SI}$
Ancho de banda con interrupciones	$BW = B/t_I$
Instrucciones de la RSI	$N = (B/BW - t_{RI}) \cdot f/CPI$
Encuesta	$t_{RI} + k\,t_{consulta} + t_{RSI}$
DMA	$T_{DMA} =$ inicio $+$ bus $+$ final
Bus serie	$T = 2d/c + \text{bits}/BW$
Robo de ciclos	$T = (c_{instr}+1) N t_c$
Canal selector	$v_T = \max v_{Ti}$
Canal multiplexor	$v_T = \sum v_{Ti}$
Ocupación del bus del canal	$P = t_{bus}/\max\{t_{bus}, 1/v_T\}$
Fotograma	$S = H \cdot V \cdot b_{px}/8$