REPASO – PC

CONTENIDO
Resumiendo la dinámica: ...................................................................................................... 6
Ejemplo simple de cómo interactúan: .................................................................................. 7
1. Visión general: ¿Qué es el ciclo de instrucción? ............................................................... 7
2. Ciclo de lectura (Fetch Cycle) ............................................................................................ 8
Fase 1. Lectura de la instrucción ....................................................................................... 8
Fase 2. Lectura de la fuente ................................................................................................ 8
3. Ciclo de ejecución (Execute Cycle) .................................................................................... 8
Fase 3. Ejecución de la instrucción .................................................................................... 8
Fase 4. Comprobación de interrupciones .......................................................................... 8
4. Estados del ciclo de instrucción.......................................................................................... 8
5. Resumen global del proceso ............................................................................................... 9
6. Consejos para tu repaso...................................................................................................... 9
Conclusión ............................................................................................................................ 9
1. Estructura general de un Sistema Operativo.................................................................. 10
Componentes principales: ................................................................................................ 10
2. Kernel ................................................................................................................................. 11
3. Shell y modo arranque ...................................................................................................... 11
3.1. Shell ............................................................................................................................. 11
3.2. Modo arranque (Boot) ............................................................................................... 11
4. Etapas del modo arranque ............................................................................................... 12
5. Cómo se relacionan todos estos elementos ...................................................................... 12
Conclusión .......................................................................................................................... 13
1. Tipos de Procesos .............................................................................................................. 13
2. Estados de un Proceso ....................................................................................................... 14
3. Control de Procesos........................................................................................................... 14
4. Implementación de Procesos ............................................................................................ 14
5. Niveles de Ejecución de Procesos (Prioridades) ............................................................. 15
Cómo se relacionan todos estos conceptos ...................................................................... 15
1. Características de la Planificación de Procesos .............................................................. 16
1.1. Equidad ....................................................................................................................... 16
1.2. Prioridad ..................................................................................................................... 16
1.3. Políticas de Planificación ........................................................................................... 17
1.4. Preferenciales (Preemptive)....................................................................................... 17
 1.5. No preferenciales (No Preemptive) ........................................................................... 17
1.6. Tiempo Compartido (Time Sharing) ........................................................................ 18
1.7. Retroalimentación (Feedback) .................................................................................. 18
1.8. Interrupciones............................................................................................................. 18
1.9. Contexto de Cambio (Context Switch) ..................................................................... 19
2. Algoritmos de Planificación de Procesos ......................................................................... 19
2.1. Round Robin (RR) ..................................................................................................... 19
2.2. FIFO (First-In, First-Out) ......................................................................................... 20
2.3. SJF (Shortest Job First) ............................................................................................. 20
2.4. Planificación por Prioridad ....................................................................................... 20
2.5. Colas Multinivel.......................................................................................................... 20
2.6. Lottery Scheduling ..................................................................................................... 21
2.7. Algoritmo de Retroalimentación (Multi-level Feedback Queues) ......................... 21
2.8. SPN (Shortest Process Next) ...................................................................................... 21
2.9. SRT (Shortest Remaining Time) ............................................................................... 22
2.10. NPP (Non Preemptive Priority) .............................................................................. 22
3. Resumen y Conclusiones................................................................................................... 22
1. ¿Qué es un Bloqueo Mutuo (Interbloqueo)?................................................................... 23
Ejemplo rápido (vida cotidiana) ...................................................................................... 23
2. Condiciones de un Bloqueo Mutuo .................................................................................. 23
3. Situaciones de Bloqueo Mutuo ......................................................................................... 24
4. Grafo de Recursos (Grafo de Asignación de Recursos) ................................................. 24
4.1. Grafo de asignación de recursos con interbloqueo.................................................. 24
4.2. Grafo de asignación de recursos sin interbloqueo ................................................... 25
5. Principios Generales de Concurrencia ............................................................................ 25
6. ¿Cómo Evitar Bloqueos Mutuos? .................................................................................... 26
Ejemplo de Evitación ........................................................................................................ 26
Conclusión.............................................................................................................................. 27
1. Primera generación (1945 – 1955): Tubos de vacío ............................................................ 27
2. Segunda generación (1955 – 1965): Transistores y Sistemas Batch ................................... 27
3. Tercera generación (1965 – 1980): Circuitos integrados y multiprogramación ................. 28
4. Cuarta generación (1980 – actualidad): Computadoras personales................................... 28
5. Quinta generación (1990 – actualidad): Dispositivos móviles ............................................ 29
Evolución Resumida ................................................................................................................ 29
Conclusión ........................................................................................................................... 29
1. ¿Qué es el Algoritmo del Banquero? .................................................................................. 30
 Idea principal: ...................................................................................................................... 30
2. Estructuras de datos principales ......................................................................................... 30
3. Estados y Secuencias Seguras ............................................................................................. 31
3.1. Estado seguro ............................................................................................................... 31
4. Paso a paso del Algoritmo del Banquero ............................................................................ 31
4.1. Algoritmo para comprobar el estado seguro (Safety Algorithm)................................. 31
4.2. Algoritmo de solicitud de recursos (Resource-Request Algorithm) ............................. 32
5. Ejemplo sencillo (con valores numéricos) ........................................................................... 32
5.1. Comprobamos estado seguro ...................................................................................... 33
5.2. Petición de un proceso ................................................................................................. 33
6. ¿Cómo “llega a cero” la asignación? ................................................................................... 33
7. Resumen Visual ................................................................................................................... 34
8. Conclusiones y Consejos ..................................................................................................... 34
Resumen Final ..................................................................................................................... 34
1. ¿Qué es la Monoprogramación? ......................................................................................... 35
Características clave ............................................................................................................ 35
2. Ejemplos de Monoprogramación en la Vida Real ............................................................... 36
3. Ejemplos de Monoprogramación en Informática ............................................................... 36
4. ¿Cómo se Gestiona la Memoria y la CPU en Monoprogramación? .................................... 36
5. Comparación con la Multiprogramación............................................................................. 37
6. Ventajas y Desventajas de la Monoprogramación.............................................................. 37
Ventajas ............................................................................................................................... 37
Desventajas ......................................................................................................................... 37
7. Ejemplo Práctico (Flujo de Monoprogramación) ................................................................ 38
8. Analogía Resumida .............................................................................................................. 38
Conclusión ............................................................................................................................... 38
1. Intercambio de procesos (Swapping) .................................................................................. 38
1.1. ¿Qué es? ....................................................................................................................... 38
1.2. Caso presentado: “No hay intercambio” ..................................................................... 39
2. Paginación de Memoria ...................................................................................................... 39
2.1. ¿Qué es la paginación? ................................................................................................. 39
2.2. Caso presentado: “No se divide la memoria en unidades pequeñas” ......................... 39
3. Multiprogramación ............................................................................................................. 39
3.1. Definición ..................................................................................................................... 39
3.2. Características principales ............................................................................................ 40
4. Relación entre los conceptos .............................................................................................. 40
 5. Ejemplo Ilustrativo .............................................................................................................. 41
Conclusión ............................................................................................................................... 41
1. ¿Qué son las Particiones Fijas? ........................................................................................... 42
Características principales:.................................................................................................. 42
2. ¿Cómo funcionan las Particiones Fijas? .............................................................................. 42
3. Ventajas de las Particiones Fijas.......................................................................................... 42
4. Desventajas de las Particiones Fijas .................................................................................... 43
5. Ejemplos de Uso .................................................................................................................. 43
6. Particiones Fijas vs. Particiones Dinámicas ......................................................................... 43
7. Ejemplo Práctico.................................................................................................................. 44
Flujo de ejecución ............................................................................................................... 44
8. Resumen .............................................................................................................................. 44
1. Intercambio (Swapping) y Gestión de la Memoria Virtual .................................................. 45
1.1. ¿Qué es el intercambio?............................................................................................... 45
1.2. ¿Por qué la memoria se trata como un “todo”? .......................................................... 45
2. Paginación y Segmentación................................................................................................. 45
2.1. Paginación .................................................................................................................... 45
2.2. Segmentación ............................................................................................................... 45
3. Falta de Página (Page Fault) ................................................................................................ 46
3.1. ¿Qué es? ....................................................................................................................... 46
3.2. Consecuencias .............................................................................................................. 46
4. Política de Reemplazo ......................................................................................................... 46
4.1. ¿Qué es? ....................................................................................................................... 46
4.2. Algoritmos frecuentes .................................................................................................. 46
5. Resumen de cómo funciona todo en conjunto ................................................................... 47
6. Ejemplo Práctico (Escenario Paso a Paso) ........................................................................... 47
Conclusión ........................................................................................................................... 47
1. Dirección de Memoria ............................................................................................................. 48
1.1. Definición ..................................................................................................................... 48
1.2. Importancia .................................................................................................................. 48
1.3. Ejemplo tecnológico ..................................................................................................... 48
1.4. Ejemplo de la vida real ................................................................................................. 48
2. Tipos de Dirección de Memoria .............................................................................................. 49
3. Memoria Virtual ...................................................................................................................... 49
3.1. Definición ..................................................................................................................... 49
3.2. Objetivos ...................................................................................................................... 49
 3.3. Ejemplo tecnológico ..................................................................................................... 49
3.4. Ejemplo de la vida real ................................................................................................. 49
3.5. Características clave de la Memoria Virtual ..................................................................... 50
4. Paginación ............................................................................................................................... 50
4.1. Definición ..................................................................................................................... 50
4.2. Ejemplo tecnológico ..................................................................................................... 50
4.3. Ejemplo de la vida real ................................................................................................. 50
4.4. Tipos de Paginación .......................................................................................................... 51
5. Algoritmos de Reemplazo de Páginas ..................................................................................... 51
6. Aplicaciones y Ejemplos Generales ......................................................................................... 52
7. Analogías de la Vida Real para Comprender Paginación y Memoria Virtual .......................... 52
8. Conclusión ............................................................................................................................... 53
1. FIFO (First-In, First-Out)........................................................................................................... 53
1.1. Definición ......................................................................................................................... 53
1.2. Ejemplo ilustrativo ........................................................................................................... 53
1.3. Analogía de la vida real ................................................................................................ 54
2. LRU (Least Recently Used)....................................................................................................... 54
2.1. Definición ......................................................................................................................... 54
2.2. Ejemplo ilustrativo ........................................................................................................... 54
2.3. Analogía de la vida real ................................................................................................ 55
3. LFU (Least Frequently Used) ................................................................................................... 55
3.1. Definición ......................................................................................................................... 55
3.2. Ejemplo sencillo ............................................................................................................... 55
3.3. Analogía de la vida real ................................................................................................ 56
4. NUR o NRU (Not Used Recently / Not Recently Used) ............................................................ 56
4.1. Definición ......................................................................................................................... 56
4.2. Ejemplo básico ................................................................................................................. 56
4.3. Analogía de la vida real ................................................................................................ 56
5. Algoritmo de Reloj (Clock) ....................................................................................................... 57
5.1. Definición ......................................................................................................................... 57
5.2. Funcionamiento resumido ............................................................................................... 57
5.3. Ejemplo simplificado ........................................................................................................ 57
5.4. Analogía de la vida real ................................................................................................ 57
6. MFU (Most Frequently Used) .................................................................................................. 57
6.1. Definición ......................................................................................................................... 57
6.2. Ejemplo corto ................................................................................................................... 57
 6.3. Analogía de la vida real .................................................................................................... 58
7. Comparación y Consideraciones ............................................................................................. 58
8. Ejemplo Completo con Reference String ................................................................................ 58
Conclusión ............................................................................................................................... 59
1. Definición de Segmentación................................................................................................ 60
2. Ejemplo Tecnológico Básico ................................................................................................ 60
3. Ejemplo de la Vida Real ....................................................................................................... 60
4. Ventajas y Desventajas........................................................................................................ 61
Ventajas ............................................................................................................................... 61
Desventajas ......................................................................................................................... 61
5. Segmentación Paginada (Visión General) ........................................................................... 61
Resumen .............................................................................................................................. 61
1. Segmentación: Definición y Objetivo .................................................................................. 62
Ejemplo de Segmentación en Memoria .............................................................................. 62
2. Tipos de Segmentación ....................................................................................................... 63
2.1. Segmentación de Memoria .......................................................................................... 63
2.2. Segmentación de Disco ................................................................................................ 63
2.3. Segmentación de Red ................................................................................................... 64
3. Características de la Segmentación (Memoria) .................................................................. 64
4. Ventajas y Desventajas de la Segmentación ....................................................................... 64
Ventajas ............................................................................................................................... 64
Desventajas ......................................................................................................................... 65
5. Segmentación Paginada ...................................................................................................... 65
6. Ejemplo Práctico para la Memoria de un Proceso .............................................................. 65
Conclusión ............................................................................................................................... 66

¡Exactamente! Has entendido bien el proceso. Una instrucción sucede dentro del
CPU como parte de un ciclo coordinado por el Sistema Operativo (SO), que actúa
como un intermediario clave entre los diferentes componentes.

Resumiendo la dinámica:

1. El Sistema Operativo:
o Es el "intermediario" que organiza el trabajo.
o Decide qué instrucciones ejecutar, cómo usar la RAM y cuándo comunicarse
con el hardware.
2. El CPU (Procesador):
o Es el "ejecutor" que procesa las instrucciones.
o Recibe estas instrucciones del SO y las ejecuta dentro del CPU.
 3. La RAM:
o Es el "almacén temporal".
o Guarda las instrucciones y datos que el CPU necesita para trabajar.
4. El Hardware (como disco duro, pantalla, teclado):
o Es el "mundo físico" con el que interactuamos.
o Se comunica con el CPU a través del SO, que interpreta y traduce las órdenes.

Ejemplo simple de cómo interactúan:

1. Tarea: Quieres abrir un programa (por ejemplo, un navegador web).

2. Paso 1: El SO carga el programa desde el disco duro a la RAM.
3. Paso 2: El CPU toma las instrucciones desde la RAM y las ejecuta.
4. Paso 3: El CPU, siguiendo las instrucciones, envía una señal al hardware (por ejemplo,
a la tarjeta gráfica para mostrar la ventana del navegador).

Conclusión: Una instrucción es el resultado de este trabajo coordinado, donde el SO

interactúa con el CPU, la RAM y el hardware para que todo funcione correctamente.

A continuación encontrarás una explicación detallada de cómo funciona la ejecución

de instrucciones en un procesador (CPU), siguiendo el esquema que describes (ciclo de
lectura y ciclo de ejecución) y mencionando las fases, direcciones y el manejo de
interrupciones. Te ayudará a entender qué hace la CPU en cada paso y cómo se
coordinan los componentes.

1. Visión general: ¿Qué es el ciclo de instrucción?

2. Ciclo de lectura (Fetch Cycle)

3. Ciclo de ejecución (Execute Cycle)

Una vez leída y decodificada la instrucción, comienza el ciclo de ejecución, que
también tiene dos fases:

Fase 3. Ejecución de la instrucción

1. Ejecutar la instrucción:
o La CPU (normalmente la ALU, Unidad Aritmético-Lógica) realiza la
operación.
o Ejemplos: suma, resta, AND, OR, mover datos de un registro a otro,
salto a otra instrucción, etc.
2. Almacenar el resultado (operando de destino):
o Si la instrucción genera un resultado, este se guarda en un registro de la
CPU o en una posición de la memoria (según lo que indique la propia
instrucción).
o Por ejemplo, si la instrucción es ADD R1, R2, R3, el resultado de la
suma de R2 + R3 se almacena en R1.

Fase 4. Comprobación de interrupciones

Después de ejecutar la instrucción, antes de pasar a la siguiente, el procesador

comprueba si se ha producido alguna interrupción (un evento que requiere atención
inmediata, como la llegada de datos desde un periférico o una instrucción ilegal). Si hay
interrupción:

1. Almacena el contador de programa (PC) y la palabra de estado (registro con

banderas, flags, etc.) para no perder el contexto de lo que se estaba ejecutando.
2. Salta a la dirección (vector de interrupción) donde comienza la rutina de
servicio de interrupción (ISR).
3. Ejecuta la rutina de servicio (por ejemplo, atender un teclado o un disco).
4. Recupera el PC y la palabra de estado para volver al punto donde se dejó la
ejecución.

Si no hay interrupciones, la CPU simplemente pasa a leer la siguiente instrucción

(vuelve al Ciclo de Lectura, Fase 1).

4. Estados del ciclo de instrucción

Según tu diagrama, se mencionan básicamente dos grandes estados:

1. LECTURA:
 oComprende las Fases 1 y 2 (Leer instrucción, Descodificar, Actualizar
PC, Lectura de la fuente).
2. EJECUCIÓN:
o Comprende las Fases 3 y 4 (Ejecutar, Almacenar resultado, y
Comprobación de interrupciones).

En algunos textos, se divide aún más, pero en tu esquema queda resumido en esos dos
macro-estados.

5. Resumen global del proceso

1. INICIO: El CPU arranca y empieza leyendo (fetch) la instrucción que señala el
PC.
2. LECTURA:
o Obtiene la instrucción de la memoria.
o Actualiza PC (salvo que haya un salto).
o Determina la ubicación de los operandos.
3. EJECUCIÓN:
o Realiza la operación (suma, salto, carga, etc.).
o Guarda el resultado en la posición correcta (registro o memoria).
o Comprueba si hay interrupciones. Si las hay, salta a atenderlas.
4. FIN: Cuando ya no hay más instrucciones o el programa finaliza, el CPU
detiene su ciclo (o pasa al estado de espera hasta que llegue algo más).

6. Consejos para tu repaso

• Visualiza mentalmente cada fase:
o Fetch: “El CPU va a la memoria y trae la instrucción.”
o Decode: “Entiende qué hacer exactamente con esa instrucción.”
o Read operands: “Reúne los datos necesarios (puede que estén en
registros o en memoria).”
o Execute: “Realiza la operación y guarda el resultado.”
o Interrupt check: “Mira si algo externo requiere atención.”
• Recuerda los modos de direccionamiento (inmediato, directo, indirecto,
relativo) y cómo afectan a la lectura de operandos.
• Interrupciones: es fundamental saber que una interrupción suspende la
ejecución normal del programa para atender un evento urgente o importante.
Después, la CPU regresa donde se quedó.

Conclusión

El ciclo de instrucción (lectura y ejecución) define el comportamiento básico de

cualquier procesador. En tu examen, entender qué pasa en cada fase y por qué es
clave para explicar cómo la CPU transforma una instrucción en acciones reales
(operaciones lógicas, aritméticas o de control). Además, el manejo de interrupciones
es vital para que la computadora responda a eventos externos sin perder la secuencia
original del programa.

Con este desglose detallado, tendrás una visión clara y estructurada de cómo ocurre la
ejecución de instrucciones dentro del CPU. ¡Éxitos en tu examen!

A continuación, encontrarás una explicación clara y estructurada de cada uno de los

componentes y conceptos que mencionas, para que puedas repasar y entender cómo se
relacionan dentro de un sistema operativo.

1. Estructura general de un Sistema Operativo

Un Sistema Operativo (SO) está compuesto por varios módulos o gestores, cada uno
encargado de manejar un aspecto diferente (procesos, memoria, dispositivos, etc.). Estos
módulos se comunican con el Kernel, el núcleo del sistema operativo, para coordinar el
uso de los recursos.

Componentes principales:

1. Kernel:
o Es la parte central del SO.
o Administra recursos (hardware y software).
o Gestiona procesos, memoria, dispositivos y archivos.
2. Gestor de Procesos:
o Maneja la creación, ejecución y finalización de procesos.
o Se encarga de la planificación (qué proceso usa el CPU y cuándo).
3. Gestor de Memoria:
o Asigna espacios en la RAM a los procesos.
o Implementa memoria virtual si la RAM se agota.
4. Gestor de Archivos:
o Organiza y controla el acceso a los datos en los discos (sistemas de
archivos).
5. Gestor de Dispositivos:
o Maneja la comunicación con periféricos (impresoras, teclados, discos,
etc.).
o Usa controladores (drivers) para traducir peticiones del SO al lenguaje
del hardware.
6. Interfaz de Usuario:
o Puede ser gráfica (GUI) o línea de comandos (CLI).
o Permite que el usuario interactúe con el sistema operativo.
7. Gestor de Red:
o Se encarga de la conectividad a redes, protocolos de comunicación
(TCP/IP).
o Administra la comunicación con otros dispositivos o servidores.
8. Gestor de Seguridad:
 oControla los accesos, permisos y la protección de los datos.
oManeja la autenticación de usuarios y el cifrado, si es necesario.
9. API (Application Programming Interface):
o Conjunto de funciones y métodos que las aplicaciones pueden usar para
solicitar servicios al sistema operativo.
10. Utilidades del Sistema:
o Programas que vienen con el SO para tareas de mantenimiento o
administración (administrador de discos, herramientas de configuración,
etc.).

2. Kernel
• Definición: Es la parte central de un sistema operativo, responsable de
gestionar los recursos esenciales.
• Funciones principales:
1. Gestión de Procesos: Creación, planificación y finalización.
2. Gestión de Memoria: Asigna y libera espacios de la RAM.
3. Gestión de Dispositivos: Coordina controladores y comunicación con
periféricos.
4. Gestión de Archivos: Controla cómo se leen y escriben los datos en los
sistemas de archivos.

El Kernel es la “capa” que se comunica directamente con el hardware y, a la vez,

provee servicios a los demás módulos (gestores) y a las aplicaciones.

3. Shell y modo arranque

3.1. Shell

• Definición: Una interfaz que permite la interacción entre el usuario y el sistema

operativo.
• Tipos:
o Línea de comandos (CLI): El usuario escribe instrucciones en texto
(como Bash en Linux o CMD en Windows).
o Shell gráfico (GUI): Interfaz de ventanas, íconos y menús (ej.
Explorador de Windows, GNOME en Linux).
• Función:
o Interpretar y ejecutar los comandos del usuario, llamando al Kernel para
realizar las tareas solicitadas.

3.2. Modo arranque (Boot)

• Definición: Estado en el que se encuentra un dispositivo cuando se enciende e

inicia el sistema operativo.
 • Objetivo: Cargar los componentes esenciales del SO en la memoria y dejar el
sistema listo para su uso.

4. Etapas del modo arranque

1. POST (Power-On Self Test):
o El sistema verifica que el hardware funcione correctamente (memoria,
CPU, dispositivos esenciales).
2. Carga del BIOS/UEFI:
o BIOS (sistemas antiguos) o UEFI (más modernos) localizan los
dispositivos de arranque y configuran parámetros básicos.
3. Selección del dispositivo de arranque:
o El BIOS/UEFI determina de dónde se cargará el sistema operativo (disco
duro, USB, red, etc.).
4. Cargador de arranque (Bootloader):
o Programa especial (ej. GRUB en Linux, Boot Manager en Windows) que
se encarga de localizar y cargar el Kernel del SO.
5. Carga del Kernel:
o El Kernel se copia a la memoria RAM.
o Se inicia la secuencia para configurar los dispositivos y servicios básicos.
6. Inicialización del sistema operativo:
o El Kernel arranca servicios y demonios (programas que corren en
segundo plano).
o Configura la gestión de memoria, archivos, red, etc.
7. Inicio de sesión:
o El usuario es invitado a ingresar sus credenciales (usuario/contraseña) o,
en el caso de un arranque automático, se presenta el escritorio o la línea
de comandos.

5. Cómo se relacionan todos estos elementos

• Kernel: El núcleo que orquesta todo.
• Shell: La capa con la cual los usuarios se comunican (escribe comandos o usa
interfaz gráfica).
• Gestores (procesos, memoria, archivos, dispositivos, etc.): Módulos que se
apoyan en el Kernel para controlar cada recurso.
• Modo arranque: Es el proceso inicial que permite cargar el Kernel y así
empezar a usar el sistema operativo.

Ejemplo breve:

1. Al encender el PC, se ejecuta el modo arranque (POST, cargador de arranque,

carga de Kernel).
2. El Kernel toma control y activa los gestores (memoria, procesos, dispositivos).
3. Se habilita la Interfaz de Usuario (Shell, GUI).
 4. El usuario ingresa un comando, que va a través del Shell hasta el Kernel.
5. El Kernel solicita a los gestores (por ejemplo, el gestor de archivos) que
cumplan la orden.
6. El gestor de archivos escribe o lee datos en el disco, retornando resultados al
usuario.

Conclusión

Esta estructura garantiza que cada parte del sistema operativo tenga un propósito
definido: el Kernel coordina al hardware, los gestores manejan recursos específicos, el
Shell facilita la comunicación con el usuario y el proceso de arranque pone todo en
marcha. Entender cómo se inicia el sistema y cómo se componen sus partes es
fundamental para saber cómo un dispositivo pasa de estar apagado a estar listo para
ejecutar cualquier aplicación.

A continuación, encontrarás una explicación clara y resumida de cada uno de los

conceptos que describes sobre los tipos de procesos, sus estados, y la forma en que el
sistema operativo (SO) los controla e implementa. Esto te ayudará a repasar para tu
examen o comprensión general.

1. Tipos de Procesos
1. Procesos de Usuario
o Son iniciados por el usuario (por ejemplo, un navegador o editor de
texto).
o Se ejecutan con permisos limitados.
2. Procesos del Sistema
o Propios del sistema operativo (ej: demonios en Linux, servicios en
Windows).
o Se ejecutan con permisos elevados para gestionar tareas de fondo.
3. Procesos en Primer Plano
o Requieren interacción o atención directa del usuario (ej: la ventana
activa).
4. Procesos en Segundo Plano (Background)
o Se ejecutan sin interacción directa del usuario (ej: sincronización de
archivos).
o Pueden correr mientras el usuario hace otras tareas.
5. Procesos en Lote (Batch)
o Se ejecutan secuencialmente, sin necesidad de interacción (ej: scripts de
respaldo nocturno).
o Reciben un conjunto de datos y devuelven un resultado final.
6. Procesos Interactivos
o Requieren comunicación continua con el usuario (ej: videojuegos,
aplicaciones de chat).
7. Procesos de Tarea Larga
 o Tienen una duración extensa o requieren gran uso de recursos (ej:
conversión de video a gran escala).
8. Procesos de Control
o Supervisan o monitorean otros procesos o eventos del sistema (ej:
monitoreo de uso de CPU).
9. Procesos de Comunicación
o Se dedican a intercambiar información con otros procesos o equipos de
red (ej: servidor web).

2. Estados de un Proceso
1. Nuevo (New)
o El proceso está siendo creado, aún no está listo para ejecutarse.
2. Listo (Ready)
o El proceso espera a que la CPU esté disponible para ser ejecutado.
3. Ejecución (Running)
o El proceso se está ejecutando actualmente en la CPU.
4. Bloqueado (Blocked / Waiting)
o El proceso espera la ocurrencia de un evento externo (ej: entrada/salida,
respuesta de un dispositivo).
5. Terminado (Terminated)
o El proceso ha finalizado su ejecución y libera sus recursos asignados.

3. Control de Procesos
• Objetivo: Gestionar y supervisar la ejecución correcta de los procesos,
garantizando un uso eficiente de CPU y memoria.
• Responsabilidad: Del sistema operativo, específicamente de los módulos de
planificación, gestión de memoria, y de entrada/salida.

4. Implementación de Procesos
1. Planificación de CPU
o El SO decide qué proceso obtiene acceso a la CPU, en qué orden y por
cuánto tiempo (ej. algoritmos como Round Robin, SJF, etc.).
2. Asignación de Memoria
o El SO distribuye la memoria RAM entre los procesos y libera espacio
cuando finalizan.
3. Administración de Entrada/Salida (E/S)
o El SO gestiona las operaciones de dispositivos como discos, impresoras,
redes, etc.
4. Prioridades y Políticas
 o Se asigna una prioridad a cada proceso; el SO puede ajustar la
planificación según políticas predefinidas (ej. prioridad alta para
procesos críticos).
5. Manejo de Interrupciones
o Cuando hay una interrupción (hardware o software), el SO detiene
momentáneamente el proceso actual para atender la interrupción y luego
retoma la ejecución.
6. Creación y Finalización de Procesos
o El SO decide cuándo crear un nuevo proceso (por ejemplo, al abrir un
programa) y cuándo finalizarlo (termina o se cierra).
7. Sincronización y Comunicación
o El SO proporciona mecanismos para que los procesos coordinen su
ejecución (semáforos, colas de mensajes) y eviten condiciones de
carrera.

5. Niveles de Ejecución de Procesos (Prioridades)

1. Tiempo Real
o Máxima prioridad.
o Se usa para tareas críticas que deben responder muy rápido (ej. sistemas
de control industrial).
2. Alta Prioridad
o Se ejecutan antes que otros procesos, pero por debajo del tiempo real.
o Aseguran rapidez en tareas importantes (ej. antivirus, procesos del
sistema).
3. Normal
o Estado por defecto de la mayoría de procesos de usuario.
o Se ejecutan según las políticas de planificación y disponibilidad de
recursos.
4. Baja Prioridad
o Solo se ejecutan cuando no hay procesos de prioridad superior en espera.
o Aseguran que las tareas urgentes no se vean afectadas por procesos
menos relevantes.
5. En Segundo Plano
o Similar a baja prioridad, pero se refiere a tareas de fondo que no
interfieren con la interacción directa (ej. copias de seguridad
automáticas).
6. Inactivo
o Procesos que han sido suspendidos temporalmente; esperan un recurso
o un evento (ej. un dato de red, fin de una operación de disco).

Cómo se relacionan todos estos conceptos

1. Tipos de procesos describen su rol (usuario, sistema, interactivo, etc.).

2. Estados muestran en qué punto del ciclo de vida se encuentra un proceso.
 3. Control de procesos y implementación indican cómo el SO maneja la
creación, ejecución y finalización.
4. Niveles de ejecución (prioridades) determinan el orden de atención de la CPU
para cada proceso.

Estos elementos combinados permiten al sistema operativo optimizar el rendimiento,

dar una buena experiencia de usuario y garantizar estabilidad en la ejecución de
múltiples tareas.

Conclusión: Entender los tipos, estados, control e implementación de los procesos,

así como los niveles de ejecución, es fundamental para manejar la multitarea y el
rendimiento en un sistema operativo. Cada proceso pasa por distintos estados y puede
tener diferentes prioridades, todo ello coordinado por el SO para un uso eficiente de
recursos y una ejecución sin conflictos.

A continuación se presenta una explicación detallada de las características de la

planificación de procesos en los sistemas operativos, junto con ejemplos que te
ayudarán a comprender cómo funcionan en la práctica. Además, se incluyen
descripciones de los principales algoritmos de planificación y casos de uso.

1. Características de la Planificación de Procesos

1.1. Equidad

• Definición: Asignar los recursos (como el CPU) de manera justa para que todos
los procesos tengan la misma oportunidad de avanzar.
• Importancia: Evita que un proceso monopolice la CPU y hace que el sistema
sea balanceado.

Ejemplo:

• En informática: Imagina que tienes un servidor que atiende peticiones de varios

usuarios. La equidad garantiza que todos los usuarios sean atendidos y no solo
uno que envíe muchas solicitudes.
• En la vida diaria: Piensa en una cola de banco donde cada persona recibe
atención en orden y no se permite que alguien se cuele.

1.2. Prioridad

• Definición: Asignar un “nivel de importancia” a los procesos, de modo que los

de prioridad más alta se ejecuten antes.
• Importancia: Permite que tareas críticas (por ejemplo, procesos del sistema) se
realicen con rapidez sin esperar innecesariamente.
Ejemplo:

• En informática: Un antivirus que analiza el sistema para detectar amenazas

puede tener una prioridad alta. Mientras tanto, un juego puede tener una
prioridad normal.
• En la vida diaria: En un hospital, los pacientes graves tienen prioridad sobre los
que presentan síntomas leves.

1.3. Políticas de Planificación

• Definición: Conjunto de reglas o algoritmos que decide el orden en el que los

procesos usan la CPU.
• Ejemplos comunes:
o FIFO (First In, First Out)
o Round Robin
o SJF (Shortest Job First)
o Planificación por Prioridad

Ejemplo:

• En informática: Un sistema operativo puede usar Round Robin para que cada
proceso tenga un “turno” de CPU y evitar esperas muy largas.

1.4. Preferenciales (Preemptive)

• Definición: El sistema operativo puede interrumpir un proceso que se está

ejecutando si llega otro proceso de mayor prioridad o si se cumple un “quantum”
de tiempo.
• Ventaja: Permite que las tareas urgentes se atiendan rápidamente.
• Desventaja: Aumenta el número de cambios de contexto, lo que puede añadir
sobrecarga al sistema.

Ejemplo:

• En informática: Si un proceso de usuario está corriendo pero llega una

interrupción de hardware o un proceso del sistema con prioridad más alta, el SO
pausa el proceso actual y ejecuta el de mayor prioridad.
• En la vida diaria: Un médico que atiende a un paciente, pero si llega una
emergencia con mayor urgencia, se interrumpe la consulta actual para atender la
emergencia.

1.5. No preferenciales (No Preemptive)

 • Definición: Una vez que un proceso empieza a ejecutarse, no puede ser
interrumpido. Finaliza o cede la CPU de forma voluntaria (por E/S o al
terminar).
• Ventaja: Menos sobrecarga de cambios de contexto.
• Desventaja: Un proceso lento puede bloquear la CPU durante mucho tiempo.

Ejemplo:

• En informática: En algunos sistemas embebidos, una tarea no se interrumpe

hasta que termina; útil cuando la tarea debe completarse sí o sí sin
interrupciones.
• En la vida diaria: Una máquina expendedora que no pasa al siguiente cliente
hasta terminar completamente la transacción actual.

1.6. Tiempo Compartido (Time Sharing)

• Definición: El CPU se reparte entre múltiples procesos, dándoles pequeños

“quantums” de tiempo (rebanadas).
• Objetivo: Que varios usuarios o programas se sientan atendidos casi
simultáneamente.

Ejemplo:

• En informática: Varios usuarios conectados a un servidor. Cada sesión recibe

un trozo de CPU, alternándose rápidamente.
• En la vida diaria: Un profesor que atiende a varios alumnos en tutorías cortas,
alternando de uno a otro en periodos breves.

1.7. Retroalimentación (Feedback)

• Definición: Permite que los procesos vayan cambiando de cola de prioridad

según su comportamiento (por ejemplo, si un proceso lleva mucho tiempo sin
terminar, se puede subir de prioridad para evitar inanición).
• Objetivo: Lograr un equilibrio entre la distribución de CPU y la eficiencia
global.

Ejemplo:

• En informática: Una cola multinivel donde los procesos que pasan mucho
tiempo esperando suben de nivel para no quedarse estancados.
• En la vida diaria: Un profesor que da turnos prioritarios a los alumnos que
llevan más tiempo esperando su turno para preguntar dudas.

1.8. Interrupciones
 • Definición: Eventos que detienen momentáneamente el proceso actual para
atender algo más urgente o importante (hardware o software).
• Impacto en Planificación: El SO debe decidir si reanuda el proceso
interrumpido o da paso a otro proceso con mayor prioridad tras manejar la
interrupción.

Ejemplo:

• En informática: Presionar una tecla o mover el mouse puede interrumpir el

proceso en ejecución para actualizar la pantalla.
• En la vida diaria: Una llamada telefónica que interrumpe la lectura de un libro
y, al colgar, decides si retomas la lectura o empiezas otra tarea.

1.9. Contexto de Cambio (Context Switch)

• Definición: Operación de guardar el estado (registros, contador de programa,

etc.) de un proceso que está siendo interrumpido y cargar el de otro proceso que
va a ejecutarse.
• Costo: Hay un tiempo en el que la CPU no realiza trabajo “útil” del proceso sino
que cambia de uno a otro.

Ejemplo:

• En informática: Cambiar el proceso P1 por P2 implica guardar los registros de

P1 y cargar los de P2.
• En la vida diaria: Pasar de estudiar matemáticas a estudiar historia requiere un
momento para cerrar libros y apuntes, y preparar el nuevo material.

2. Algoritmos de Planificación de Procesos

A continuación, se describen los algoritmos más comunes mencionados:

2.1. Round Robin (RR)

• Características:
o Asigna un “quantum” de tiempo fijo a cada proceso.
o Cuando se agota el quantum, pasa al siguiente proceso en la cola.
o Es preemptive.
• Ventaja: Ofrece buena respuesta interactiva; ningún proceso espera
demasiado.
• Ejemplo:
o Varios programas en un SO compartiendo CPU de forma equitativa.
o En la vida real, una pizzería que atiende cada pedido de manera rotativa
durante 2 minutos antes de pasar al siguiente.
2.2. FIFO (First-In, First-Out)

• Características:
o El primer proceso que entra es el primero en ejecutarse.
o Es no preemptive: se ejecuta hasta que el proceso termine.
• Ventaja: Fácil de implementar y entender.
• Desventaja: Un trabajo largo puede bloquear a los demás.
• Ejemplo:
o Varios jobs en un sistema antiguo de batch. El primero que llega a la
cola, se procesa primero.
o En la vida diaria, hacer fila en el supermercado: te atienden en orden de
llegada.

2.3. SJF (Shortest Job First)

• Características:
o Prioriza el proceso con la duración de CPU más corta.
o Si es no preemptive, no interrumpe el proceso en ejecución; si es
preemptive, se conoce como SRTF (Shortest Remaining Time First).
• Ventaja: Minimiza el tiempo de espera promedio.
• Desventaja: Es difícil saber de antemano el tiempo exacto de cada proceso.
• Ejemplo:
o En informática: Seleccionar primero las tareas más cortas para agilizar
el throughput.
o En la vida real: En una tintorería, primero se atiende la prenda que tarda
menos en limpiarse.

2.4. Planificación por Prioridad

• Características:
o Cada proceso tiene un valor de prioridad.
o Se atiende primero al proceso con prioridad más alta (puede ser
preemptive o no).
• Ventaja: Favorece procesos críticos.
• Desventaja: Puede causar inanición de procesos con prioridad baja.
• Ejemplo:
o En informática: Un proceso del sistema (prioridad alta) interrumpe
procesos de usuario (prioridad normal).
o En la vida diaria: Un hospital atiende antes a pacientes críticos.

2.5. Colas Multinivel

 • Características:
o Se dividen los procesos en colas según un criterio (por ejemplo, procesos
de sistema, procesos interactivos, procesos batch).
o Cada cola tiene su propio algoritmo de planificación.
• Ventaja: Permite clasificar y manejar procesos de distinta naturaleza con
parámetros específicos.
• Ejemplo:
o En informática: Una cola de alta prioridad para procesos de sistema
(SJF) y una cola de baja prioridad para procesos de usuario (Round
Robin).

2.6. Lottery Scheduling

• Características:
o Cada proceso recibe “boletos” en función de su prioridad o recursos
requeridos.
o Se hace un sorteo para ver qué proceso gana el uso de CPU en cada
turno.
• Ventaja: Es un método probabilístico que, a la larga, provee equidad y se puede
ajustar asignando más o menos boletos.
• Ejemplo:
o En informática: Un sistema que reparte boletos a cada proceso; uno
recibe 50 boletos y otro 100, aumentando la probabilidad de que el
segundo sea elegido.

2.7. Algoritmo de Retroalimentación (Multi-level Feedback Queues)

• Características:
o Combina colas de prioridades con la posibilidad de que los procesos se
muevan entre colas según su comportamiento.
o Procesos que consumen mucho CPU pueden bajar de prioridad; procesos
que esperan mucho pueden subir de prioridad.
• Ventaja: Ofrece un balance entre equidad y eficiencia, evitando la inanición.
• Ejemplo:
o En informática: Un proceso que se vuelve I/O bound sube de prioridad
al no consumir mucho CPU, mientras que uno CPU-bound (consume
mucha CPU) baja de nivel.

2.8. SPN (Shortest Process Next)

• Características:
o El CPU elige el proceso con el menor tiempo de ejecución pendiente
(similar a SJF).
o Pretende minimizar el tiempo de espera.
 • Ejemplo:
o En informática: Mismo funcionamiento que SJF; prioriza jobs cortos
primero.

2.9. SRT (Shortest Remaining Time)

• Características:
o Versión preemptive de SJF. Si llega un proceso con tiempo de ejecución
más corto que el actual, interrumpe al proceso en curso.
o Ofrece gran capacidad de respuesta.
• Ejemplo:
o En informática: Un proceso largo en ejecución es interrumpido si entra
uno muy corto que puede terminar rápido.

2.10. NPP (Non Preemptive Priority)

• Características:
o Planificación por prioridad, pero no interrumpe el proceso en marcha.
o Una vez que inicia, el proceso corre hasta finalizar.
• Ejemplo:
o En informática: Un sistema batch donde, si eligieron un proceso de
prioridad alta, se ejecuta completamente antes de atender otro.

3. Resumen y Conclusiones
• Las características de planificación (equidad, prioridad, preemptive, no
preemptive, tiempo compartido, retroalimentación, interrupciones, cambio de
contexto) influyen en cómo el sistema operativo decide el uso del CPU.
• La elección del algoritmo (Round Robin, FIFO, SJF, Prioridad, etc.) depende
de las necesidades del sistema:
o SJF/SRTF son buenos para tiempos de espera cortos pero requieren
estimaciones confiables.
o Round Robin ofrece buena respuesta a usuarios interactivos.
o Prioridad favorece tareas críticas, pero puede causar inanición.
o Colas multinivel y Feedback permiten clasificar y reubicar procesos
según su comportamiento, equilibrando necesidades variadas.

Cada política de planificación tiene ventajas y desventajas, y se puede usar

combinaciones para optimizar distintas cargas de trabajo (por ejemplo, un servidor con
procesos interactivos y por lotes simultáneamente).
¡Con esto tienes una visión completa de la planificación de procesos, sus características
y ejemplos prácticos! Estudiar cómo cada algoritmo aborda las necesidades de la CPU,
la memoria y las E/S te ayudará a comprender por qué los sistemas operativos se
comportan de cierta forma en distintos escenarios.

A continuación, encontrarás una explicación detallada sobre los bloqueos mutuos

(interbloqueos) en sistemas concurrentes, las condiciones que deben cumplirse para
que ocurran, cómo se representan mediante grafos de asignación de recursos y los
principios generales de concurrencia que ayudan a evitarlos. Incluiremos ejemplos
prácticos para aclarar estos conceptos.

1. ¿Qué es un Bloqueo Mutuo (Interbloqueo)?

Un bloqueo mutuo o interbloqueo (deadlock) sucede cuando dos o más procesos se
encuentran en una situación en la que cada uno espera que otro libere un recurso.
Como consecuencia, ninguno puede continuar con su ejecución, quedando todos
detenidos de forma permanente.

Ejemplo rápido (vida cotidiana)

• Tráfico en una intersección: Cada vehículo bloquea la vía que el otro necesita
para avanzar y ninguno puede moverse si el otro no se retira primero.

2. Condiciones de un Bloqueo Mutuo

Para que ocurra un interbloqueo, todas las siguientes condiciones deben cumplirse de
manera simultánea:

1. Exclusión mutua
o Al menos un recurso no puede ser compartido; solo un proceso puede
usarlo en un instante dado.
o Ej.: Una impresora que no puede ser usada por dos procesos al mismo
tiempo.
2. Espera y retención (Posesión y espera)
o Un proceso mantiene asignado al menos un recurso y al mismo tiempo
espera a que se libere otro recurso que está en posesión de otro proceso.
o Ej.: Proceso A tiene la impresora y pide acceso al escáner que está
retenido por el Proceso B, mientras B espera la impresora.
3. No asignación forzosa (No preempción)
o Los recursos no se pueden forzar a liberar; es decir, solo el proceso que
posee un recurso puede liberarlo voluntariamente.
o Ej.: No se puede quitar “a la fuerza” la impresora a un proceso que está
imprimiendo, debe terminar su tarea.
4. Ausencia de liberación voluntaria / Espera circular
 o Existe una cadena de procesos donde cada uno espera un recurso que el
siguiente proceso de la cadena posee.
o Ej.: A espera el recurso de B, B espera el recurso de C, C espera el de A,
formando un “ciclo” circular.

Si cualquiera de estas condiciones se rompe, el bloqueo mutuo no puede ocurrir.

3. Situaciones de Bloqueo Mutuo

• Sistemas Operativos: Múltiples procesos compitiendo por recursos de hardware
(disco, memoria).
• Redes: Nodos que compiten por el acceso a canales de comunicación o puertos.
• Bases de Datos: Varias transacciones que bloquean registros o tablas, esperando
la liberación de otras transacciones.
• Programación Multi-hilo: Dos hilos comparten variables globales y cada uno
espera que el otro libere una sección crítica.
• Sistemas de Control: Múltiples procesos en un sistema de automatización que
requieren un mismo sensor o actuador.
• Sistemas de Archivos Compartidos: Varios usuarios acceden a los mismos
archivos en un servidor, bloqueando algunos de ellos.

4. Grafo de Recursos (Grafo de Asignación de

Recursos)
Un grafo de asignación de recursos representa gráficamente qué procesos están
usando (o esperando) qué recursos.

• Nodo Proceso (P): Representa un proceso en ejecución.

• Nodo Recurso (R): Representa un recurso que puede ser asignado ([Link].,
impresora, archivo, memoria).
• Flechas:
o Si la flecha va de un recurso R a un proceso P (R → P), significa que el
recurso está asignado a ese proceso.
o Si la flecha va de un proceso P a un recurso R (P → R), significa que el
proceso está esperando que se le asigne ese recurso.

4.1. Grafo de asignación de recursos con interbloqueo

¿Qué es?
Un grafo con interbloqueo mostrará un ciclo cerrado, donde cada proceso retiene un
recurso y, a su vez, espera otro que está retenido por otro proceso.

Cómo funciona:
 1. Cada proceso P está reteniendo un recurso R que no suelta.
2. Al mismo tiempo, P demanda otro recurso que está en posesión de otro proceso.
3. Se ve un ciclo en el grafo ([Link]., P1 → R2, R2 → P2, P2 → R1, R1 → P1).

Ejemplo:

• P1 tiene la impresora (R1) y pide el escáner (R2).

• P2 tiene el escáner (R2) y pide la impresora (R1).
• Grafo:
o R1 → P1 (asignado), y P1 → R2 (espera)
o R2 → P2 (asignado), y P2 → R1 (espera)
o Se forma un ciclo (P1 - R2 - P2 - R1 - P1).

4.2. Grafo de asignación de recursos sin interbloqueo

¿Qué es?
Un grafo donde, aunque existan asignaciones y esperas, no se forma un ciclo
ininterrumpido de procesos y recursos.

Cómo funciona:

• Puede haber procesos esperando recursos, pero siempre hay un camino o

secuencia para que uno de ellos termine y libere el recurso.
• No se cumple la condición de espera circular.

Ejemplo:

• P1 retiene la impresora (R1) y no pide nada más.

• P2 está esperando la impresora (R1), pero aún no tiene ningún otro recurso.
o Al terminar P1, libera la impresora y P2 la adquiere. No se bloquean
mutuamente.

5. Principios Generales de Concurrencia

Para evitar problemas de bloqueos, inanición y condiciones de carrera, se aplican varios
principios:

1. Exclusión Mutua
o Se garantiza que sólo un proceso/hilo acceda a la vez a un recurso
compartido (ej.: semáforos o monitores).
2. Consistencia de Datos
o Se asegura que las operaciones concurrentes no dejen la información en
un estado inconsistente (ej.: control de transacciones en bases de datos).
3. Coordinación
o Se planifica y regula el acceso a recursos críticos, a menudo usando
algoritmos de sincronización (semáforos, mutex, etc.).
4. Comunicación
 o Mecanismos (mensajes, colas, canales) que permiten a los procesos
compartir información sin bloquearse innecesariamente.
5. Evitar bloqueos mutuos
o Usar estrategias como:
▪ Evitar: Diseñar el sistema para no cumplir al menos una de las 4
condiciones de interbloqueo.
▪ Detectar: Monitorizar con algoritmos que detecten ciclos en el
grafo de recursos.
▪ Recuperar: Si se detecta un ciclo, forzar la finalización o
liberación de recursos.
▪ Prevenir: Planificar la asignación de recursos de forma “segura”
(Banco de Recursos).
6. Evitar condiciones de carrera
o Sincronizar las operaciones para que no haya lecturas/escrituras
simultáneas sobre el mismo dato.
7. Priorización
o Establecer prioridades para que procesos críticos no esperen demasiado y
se evite la inanición.
8. Independencia de Procesos
o Diseñar módulos que no requieran demasiada interacción, minimizando
riesgos de bloqueo.
9. Descomposición
o Dividir tareas grandes en subtareas para una mejor administración y
menos conflictos.
10. Monitoreo y Depuración

• Herramientas de logging y análisis para detectar patrones de bloqueo e

interbloqueo.

6. ¿Cómo Evitar Bloqueos Mutuos?

• Planificación de recursos: Asignar y liberar recursos en un orden estricto que
impida ciclos (por ejemplo, todos piden primero la impresora y luego el
escáner).
• Liberación ordenada: Un proceso debe liberar todos sus recursos si no puede
obtener un recurso adicional.
• Banco de recursos (Algoritmo del Banquero): Verifica si una secuencia de
asignación es “segura” antes de conceder un nuevo recurso.
• Preempción forzosa: En ciertos sistemas, se puede forzar la liberación de un
recurso (si es posible).

Ejemplo de Evitación

• Ejemplo con impresora y escáner:

o Regla: Un proceso debe pedir primero la impresora y solo después el
escáner, y si no puede obtener ambos, libera el primero.
 o Resultado: No se forma el ciclo donde un proceso tiene la impresora y
otro el escáner.

Conclusión
Los bloqueos mutuos ocurren cuando varios procesos se impiden mutuamente
continuar por una mala gestión de recursos compartidos. Para que sucedan, se deben
cumplir simultáneamente las cuatro condiciones clásicas (exclusión mutua, posesión y
espera, no preempción y espera circular). El grafo de asignación de recursos ayuda a
visualizar estas situaciones y detectar ciclos de interbloqueo.

Para evitarlos, los sistemas concurrentes aplican políticas de concurrencia,

sincronización y planeación cuidadosa del uso de recursos, de forma que no se cumplan
las cuatro condiciones a la vez o se puedan romper dinámicamente cuando se detecta un
posible conflicto. De esta manera, se garantiza la estabilidad y eficiencia de las
aplicaciones que requieren acceso simultáneo a recursos compartidos.

A continuación, encontrarás una explicación resumida sobre la evolución de los

sistemas operativos a lo largo de las cinco generaciones que describiste. Verás cómo
avanzaron desde los primeros computadores basados en tubos de vacío hasta los
modernos sistemas para dispositivos móviles.

1. Primera generación (1945 – 1955): Tubos de vacío

1. Características de hardware:
o Las computadoras se basaban en bulbos o tubos de vacío.
o Eran enormes y poco confiables, producían mucho calor y se dañaban con
frecuencia.
o Ejemplo destacado: Colossus de Alan Turing, que usaba 2400 tubos de vacío.
2. Software y usos:
o Programación con cintas de papel perforadas.
o Se utilizaban principalmente para criptografía (descifrar mensajes durante la
Segunda Guerra Mundial).
o No había un “sistema operativo” como tal; era más una ejecución directa de
instrucciones en hardware.
3. Limitaciones:
o Los computadores eran lentos y muy costosos.
o No existía concepto de multiprogramación ni interfaz de usuario.

2. Segunda generación (1955 – 1965): Transistores y

Sistemas Batch
 1. Características de hardware:
o Se reemplazaron tubos de vacío por transistores, reduciendo notablemente el
tamaño y aumentando la fiabilidad.
o IBM comenzó a introducir equipos comerciales más pequeños y potentes.
2. Sistemas Batch (por lotes):
o Los programas se codificaban en tarjetas perforadas.
o Un operador cargaba estas tarjetas en un lector, y el computador ejecutaba los
programas “en lote” (batch), sin interacción con el usuario durante la
ejecución.
o Nace la idea de un sistema operativo muy primitivo que gestionaba la cola de
tareas.
3. Lenguajes de programación:
o Comienzan a aparecer los lenguajes de alto nivel. FORTRAN (FORMULA
TRANSLATING SYSTEM) surge en 1953 como uno de los primeros.

3. Tercera generación (1965 – 1980): Circuitos

integrados y multiprogramación
1. Circuitos integrados:
o El uso de circuitos integrados (chips que integraban múltiples transistores)
reduce aún más el tamaño y aumenta la potencia de cálculo.
o Disminuye el costo y acelera el desarrollo de computadoras.
2. Multiprogramación:
o Permite que varios programas se carguen en memoria al mismo tiempo,
compartiendo el procesador.
o De esta forma, mientras un programa espera (por ejemplo, E/S), otro puede
usar la CPU, aumentando la eficiencia.
3. Sistemas Operativos destacados:
o IBM OS/360: Introducido por IBM, soportaba multiprogramación.
o UNIX: Desarrollado en los laboratorios Bell, se vuelve muy influyente por su
filosofía de modularidad y multitarea.

4. Cuarta generación (1980 – actualidad):

Computadoras personales
1. Microprocesadores y chips:
o Se implementan chips capaces de integrar cientos de miles (y luego millones)
de transistores.
o Esto impulsa la aparición de computadoras personales (PCs) y hace que la
computación sea más accesible al público.
2. Sistemas Operativos populares:
o MS-DOS (Microsoft Disk Operating System), luego evolucionó en Windows.
o Mac OS (Apple) con interfaz gráfica pionera.
o Linux (libre y de código abierto), surge a principios de los 90 y se expande por
comunidades y servidores.
 3. Características:
o Interfaz gráfica (GUI) en el entorno doméstico y de oficina.
o Aparición de redes locales y uso masivo de internet.

5. Quinta generación (1990 – actualidad): Dispositivos

móviles
1. Foco en movilidad:
o Computadoras ultra portátiles y dispositivos como smartphones, tablets, etc.
o Se requiere que los sistemas operativos sean ligeros y optimizados para
baterías y pantallas táctiles.
2. Sistemas Operativos Móviles:
o Android (basado en Linux), iOS (Apple), Windows Phone (ahora en desuso),
BlackBerry OS (histórico), etc.
o Soportan multitarea, conectividad permanente, sensores (GPS, cámara, etc.).
3. Tendencias actuales:
o Convergencia: Sistemas que integran nube, redes sociales y IA.
o Mayor seguridad y privacidad: cifrado de datos, sandboxing de aplicaciones.

Evolución Resumida
• Primera generación: Computadoras con tubos de vacío, sin OS formal, muy grandes y
para tareas específicas.
• Segunda generación: Llegan los transistores y la programación en batch con tarjetas
perforadas.
• Tercera generación: Circuitos integrados, multiprogramación y la aparición de UNIX y
OS/360.
• Cuarta generación: Surge la computadora personal, MS-DOS, Windows, MacOS, Linux
para desktop.
• Quinta generación: Dominio de dispositivos móviles, sistemas como Android, iOS, y
énfasis en portabilidad y conectividad.

Conclusión

Los sistemas operativos han pasado de ser inexistentes (cuando los programadores
tenían acceso directo al hardware) a complejos núcleos que controlan recursos,
proporcionan interfaces amigables y permiten la movilidad en smartphones y otros
dispositivos. Cada generación representa un gran salto en la miniaturización del
hardware y la sofisticación del software, haciendo que la computación sea cada vez más
universal, potente y accesible.

A continuación encontrarás una explicación paso a paso de cómo funciona el

Algoritmo del Banquero (Banker's Algorithm), un método clásico para la asignación
segura de recursos en sistemas operativos que implementan concurrencia y desean
evitar el interbloqueo (deadlock). El objetivo es mostrar no solo la teoría, sino también
cómo se asignan los recursos hasta que “llegan a cero” o se liberan, garantizando
siempre un estado seguro.

1. ¿Qué es el Algoritmo del Banquero?

El Algoritmo del Banquero es un procedimiento que verifica si el sistema puede o no
conceder recursos a los procesos de manera que nunca se produzca un interbloqueo
permanente. Se llama así porque su funcionamiento es análogo a un banquero que no
concede un préstamo (recurso) si la entrega de dicho préstamo puede llevar al banco a
una situación de quiebra (interbloqueo).

Idea principal:

• Antes de asignar recursos que un proceso solicita, el sistema simula la asignación y

comprueba si, con esta asignación, aún existe una secuencia “segura” de ejecución
para todos los procesos.
• Una secuencia segura significa que existe un orden en el que, eventualmente, todos
los procesos pueden obtener los recursos que necesitan, ejecutar y liberar esos
recursos.

2. Estructuras de datos principales

En el algoritmo se manejan cuatro matrices o vectores fundamentales (para n procesos y
m tipos de recursos):

1. Available (Disponible)
o Vector de tamaño m.
o Indica cuántas unidades de cada recurso hay disponibles actualmente en el
sistema.
2. Max
o Matriz de n x m.
o Max[i][j] indica la demanda máxima del proceso i para el recurso j (la
mayor cantidad de ese recurso que podría llegar a pedir).
3. Allocation
o Matriz de n x m.
o Allocation[i][j] indica cuántas unidades del recurso j están asignadas
actualmente al proceso i.
4. Need
o Matriz de n x m.
o Need[i][j] = Max[i][j] - Allocation[i][j].
o Indica cuántas unidades del recurso j todavía necesita el proceso i para poder
terminar.
3. Estados y Secuencias Seguras
3.1. Estado seguro

Un estado se considera seguro si existe al menos una secuencia de ejecución de los

procesos (por ejemplo, P1, P2, ... Pn) de forma que cada proceso pueda:

1. Obtener todos los recursos que todavía necesita (Need),

2. Ejecutar,
3. Liberar los recursos,
4. Y permitir al siguiente proceso en la secuencia hacer lo mismo.

Si el sistema no encuentra al menos una secuencia de este tipo, se dice que el estado es
inseguro, y potencialmente puede ocurrir un interbloqueo.

4. Paso a paso del Algoritmo del Banquero

Se puede dividir en dos partes:

1. Algoritmo para verificar si el sistema está en estado seguro (Safety Algorithm).

2. Algoritmo de solicitud de recursos (Resource-Request Algorithm): cuando un proceso
pide nuevos recursos, se examina si la asignación deja el sistema en un estado seguro.

Veremos ambos a nivel general.

4.1. Algoritmo para comprobar el estado seguro (Safety Algorithm)

Objetivo: Dado un estado (con matrices Allocation, Need y vector Available),

determinar si hay alguna secuencia segura.

1. Crear dos estructuras:

o Work: copia del vector Available.
o Finish[]: array booleano, inicialmente Finish[i] = false para todos los
procesos.
2. Buscar un proceso i tal que:
o Finish[i] == false
o Need[i] <= Work (significa que para cada recurso j, Need[i][j] <=
Work[j]).
Es decir, el proceso i todavía no ha terminado y puede obtener los recursos
que necesita.
3. Si se encuentra tal proceso i, entonces simulamos que i se ejecuta y libera sus
recursos:
 o Work = Work + Allocation[i] (se suman los recursos que i tenía
asignados, porque ya terminó y los liberó).
o Finish[i] = true (marcamos que el proceso terminó).
o Volver al paso 2.
4. Si no se encuentra ningún proceso i que cumpla esas condiciones, finaliza el
algoritmo.
o Si Finish[i] == true para todos los procesos i, entonces el estado es
seguro.
o Si algún Finish[i] == false, el estado es inseguro (no existe secuencia
que permita que todos terminen).

4.2. Algoritmo de solicitud de recursos (Resource-Request Algorithm)

Objetivo: Cuando un proceso Pi hace una solicitud Request[i] (cantidad de cada tipo
de recurso que desea), determinar si es seguro satisfacer esa solicitud.

1. Verificar si Request[i] <= Need[i].

o Si no se cumple, error: el proceso pide más recursos de los que declaró que
podría necesitar.
2. Verificar si Request[i] <= Available.
o Si no se cumple, el proceso debe esperar porque no hay suficientes recursos
disponibles ahora.
3. Asignación tentativa:
o Available = Available - Request[i]
o Allocation[i] = Allocation[i] + Request[i]
o Need[i] = Need[i] - Request[i]
4. Verificación de estado seguro:
o Llamar al Algoritmo de Safety para comprobar si, tras esta asignación
“tentativa”, el sistema sigue estando seguro.
o Si el resultado es seguro: se confirma la asignación y Pi puede usar los
recursos.
o Si el resultado es inseguro: se revierte la asignación (restaurar Available,
Allocation y Need a su estado previo) y Pi se queda esperando.

5. Ejemplo sencillo (con valores numéricos)

Supongamos que hay 1 tipo de recurso con 10 unidades totales. Tenemos 3 procesos:
P0, P1, P2.

• Max:
o P0 puede requerir hasta 7 unidades.
o P1 hasta 5 unidades.
o P2 hasta 3 unidades.
• Allocations actuales:
o P0 ya tiene 0 asignadas (inició, pero no tomó nada).
o P1 tiene 1 asignada.
o P2 tiene 2 asignadas.
 • Entonces:
o Available = 10 - (0+1+2) = 7 (7 unidades disponibles).
o Need[0] = 7 - 0 = 7.
o Need[1] = 5 - 1 = 4.
o Need[2] = 3 - 2 = 1.

5.1. Comprobamos estado seguro

• Work = 7, Finish = [false,false,false].

• Buscamos un proceso con Need <= Work:
o P0 necesita 7 → Igual a Work(7). Se cumple.
o Asumimos que escogemos P0.
o Work = Work + Allocation[0] = 7 + 0 = 7, Finish[0] = true.
• Volvemos a buscar:
o P1 necesita 4, Finish[1] = false, 4 <= Work(7)? Sí.
o Entonces “ejecutamos” P1, libera 1 → Work = 7 + 1 = 8. Finish[1] =
true.
• Volvemos a buscar:
o P2 necesita 1, Finish[2] = false, 1 <= Work(8)? Sí.
o “Ejecutamos” P2, libera 2 → Work = 8 + 2 = 10. Finish[2] = true.
• Todos los procesos llegaron a Finish = true, se encontró una secuencia de
ejecución (P0 → P1 → P2), por lo tanto el estado es seguro.

5.2. Petición de un proceso

Ahora imagina que P0 pide 3 unidades más (Request[0] = 3).

• Chequeamos:
1. Request[0] <= Need[0], es decir, 3 <= 7 → verdadero.
2. Request[0] <= Available, 3 <= 7 → verdadero.
3. Asignación tentativa:
▪ Available = 7 - 3 = 4
▪ Allocation[0] = 0 + 3 = 3
▪ Need[0] = 7 - 3 = 4.
4. Comprobamos de nuevo estado seguro con estos valores.
▪ Si sigue siendo seguro, la asignación se confirma.
▪ Si no, se revierte y P0 debe esperar.

6. ¿Cómo “llega a cero” la asignación?

Un punto importante es entender cómo se liberan recursos y eventualmente se “llega a
cero”:

1. Una vez un proceso tiene todo lo que necesita (lo que indica su Need), puede
ejecutarse y terminar.
2. Al finalizar, libera todos los recursos en Allocation.
3. Esto aumenta el vector Available, haciendo que otros procesos puedan continuar.
 4. Finalmente, cuando todos los procesos han terminado, la asignación total a ellos es 0
(o sea, han devuelto todos los recursos), y Available vuelve a ser igual a la capacidad
total del sistema.

Ejemplo:

• P0 obtiene sus 7 recursos, corre y termina → Allocation[0] pasa a 0 y Available

aumenta en 7.
• Se procede con P1 y así sucesivamente.

7. Resumen Visual
1. Inicia con cierta distribución de recursos.
2. Cada proceso indica su Max (lo máximo que podría llegar a pedir).
3. Cuando pide algo:
1. Verificas si Request <= Need y si Request <= Available.
2. Asignas tentativamente y verificas estado seguro.
3. Si es seguro, se confirma la asignación. Si no, el proceso espera.
4. Cuando el proceso termina, libera sus recursos → Allocation se hace 0 para ese
proceso, y Available sube.
5. Se repite para todos los procesos, asegurando que siempre existe al menos un orden
que evite el interbloqueo.

8. Conclusiones y Consejos
• El Algoritmo del Banquero es esencial para evitar o detectar condiciones de
interbloqueo, garantizando que el sistema no entre en un estado inseguro.
• Paso clave: Verificación de “estado seguro” antes de conceder cada nueva solicitud.
• Llega a cero: Todos los recursos terminan liberándose cuando cada proceso finaliza y
su Allocation se suma de nuevo a Available.
• Funciona bien en sistemas en los que se conoce la demanda máxima de recursos de
cada proceso y el número total de recursos.
• Puede ser pesado computacionalmente en sistemas con muchos procesos y varios
tipos de recursos, porque se hacen múltiples comprobaciones de seguridad.

Resumen Final

El Algoritmo del Banquero simula, a cada solicitud de recursos, si el sistema seguiría

teniendo una secuencia que permita a todos los procesos terminar sin bloquearse
permanentemente. Para ello, maneja las estructuras Available, Max, Allocation y
Need. Otorga recursos de forma “tentativa” y comprueba un estado seguro; si la
comprobación falla, revierte la asignación. Los procesos eventualmente liberan sus
recursos cuando finalizan, haciendo que Allocation “llegue a cero” y aumentando
Available, lo que evita el interbloqueo siempre y cuando el sistema se mantenga en
estados seguros.

A continuación encontrarás una explicación ampliada de lo que es la

monoprogramación, junto con algunos ejemplos de la vida real y de la informática,
para que puedas entender mejor este paradigma. También se contrastará con la
multiprogramación donde sea pertinente, y se incluirán detalles sobre cómo la
memoria y la CPU se administran en un entorno monoprogramado.

1. ¿Qué es la Monoprogramación?
La monoprogramación (también llamada monoprocesamiento o ejecución única) es un
modelo de ejecución en el que solo un programa o proceso se ejecuta en la memoria
principal en un momento dado. Esto significa que:

• No se utiliza conmutación de procesos (o es mínima)

• No se realiza paginación dinámica ni intercambio (swap) como en los sistemas
multitarea.
• Toda la memoria RAM y el tiempo de CPU se dedican exclusivamente al único
programa que esté corriendo.

Características clave

1. Ejecución secuencial: No hay cambio rápido entre procesos; el sistema se centra en

terminar uno antes de comenzar otro.
2. Bajo uso de recursos: Puesto que no se aprovecha la posibilidad de correr varios
procesos en paralelo, a menudo se desperdicia tiempo de CPU (cuando el programa
está esperando E/S).
3. Implementación sencilla: Es más fácil de diseñar y administrar.
4. Menor complejidad del sistema operativo: Al no manejar múltiples procesos de forma
simultánea, no se requieren algoritmos avanzados de planificación o administración de
memoria.
2. Ejemplos de Monoprogramación en la Vida Real
1. Una sola caja en el supermercado:
o Si el supermercado solo tiene una caja abierta, se atiende a un cliente por vez.
Los demás deben esperar hasta que el cajero termine con el cliente actual. No
hay cambio rápido de un cliente a otro.
o Paralelo con la monoprogramación: Solo “un proceso” (cliente) está en
servicio, ocupando todos los “recursos” (el cajero, la caja, la atención).
2. Clase con un solo alumno:
o Un profesor solo tiene un alumno en la clase. Mientras ese alumno está
estudiando, el profesor dedica todo su tiempo a él. No hay reparto entre
varios alumnos.
o Paralelo con la monoprogramación: Todo el recurso (profesor) está asignado
a un único estudiante, no se necesita “conmutar” la enseñanza.

3. Ejemplos de Monoprogramación en Informática

1. Sistemas antiguos (años 50 - 60):
o En la segunda generación de computadoras, muchos sistemas usaban tarjetas
perforadas y ejecutaban los programas en batch (uno a la vez).
o El computador cargaba un programa, lo ejecutaba completamente, y luego
pasaba al siguiente.
2. Microcontroladores simples o firmware:
o Algunos sistemas embebidos (por ejemplo, un circuito para controlar la
iluminación de un dispositivo) ejecutan un único bucle de programa sin
multitarea.
o No hay necesidad de manejar múltiples procesos simultáneamente, ya que se
trata de una función muy dedicada.
3. MS-DOS en sus versiones iniciales:
o Aunque había formas rudimentarias de multitarea, en esencia, MS-DOS corría
un programa a la vez en modo real.
o De hecho, muchas aplicaciones ocupaban completamente el sistema hasta que
finalizaban o el usuario salía de ellas.

4. ¿Cómo se Gestiona la Memoria y la CPU en

Monoprogramación?
1. Memoria contigua:
o El programa se carga en una sección contigua de la memoria principal; puede
ocupar toda la RAM disponible o una parte de ella.
o No existe la necesidad de paginación o segmentación dinámica, puesto que
solo un proceso está activo.
2. CPU:
o Mientras el programa se está ejecutando, la CPU está completamente
disponible para él.
 o Sin embargo, cuando el programa realiza operaciones de entrada/salida (por
ejemplo, leer desde disco), la CPU puede quedar inactiva sin hacer nada (ya
que no hay otros programas a los que cederle el tiempo).
3. Sin intercambio (swapping):
o No se mueve el proceso fuera de la RAM al disco y viceversa, porque no hay
competidores de memoria.
o El proceso permanece cargado hasta que finaliza.

5. Comparación con la Multiprogramación

• Monoprogramación:
o Un programa en ejecución.
o Escaso uso de CPU cuando se espera E/S.
o Simplicidad en la administración de recursos.
o No hay colas de planificación complicadas.
• Multiprogramación:
o Múltiples programas en memoria al mismo tiempo.
o Se aprovecha la CPU mientras un proceso espera E/S, ejecutando otro proceso
que esté listo.
o Se requieren algoritmos de planificación (Round Robin, SJF, etc.) y de gestión
de memoria (paginación, particiones).
o Mayor aprovechamiento y eficiencia del sistema, pero también mayor
complejidad.

6. Ventajas y Desventajas de la Monoprogramación

Ventajas

1. Simplicidad: Muy fácil de implementar y administrar, especialmente en sistemas

operativos pequeños o embebidos.
2. Predicción y control: Como solo se ejecuta un programa, es más sencillo estimar su
rendimiento (no compite con otros).
3. Menor riesgo de interferencias: No hay riesgo de que otro proceso corrupta la
memoria o interfiera de manera no deseada.

Desventajas

1. Bajo rendimiento global: Se desaprovecha la CPU cuando el único programa entra en

operación de E/S.
2. Sin multitarea: No puedes realizar varias tareas de forma simultánea, lo cual reduce la
flexibilidad de uso.
3. Subutilización de recursos: No hay “paralelismo” ni uso eficiente de la RAM si el
programa no necesita toda la memoria disponible.
7. Ejemplo Práctico (Flujo de Monoprogramación)
Imaginemos que en un sistema monoprogramado (antiguo MS-DOS o un
microcontrolador):

1. Inicio: Se enciende el sistema, se carga el programa “A” en memoria.

2. Ejecución: El programa “A” corre; si necesita imprimir en pantalla, la CPU espera a que
termine la operación de E/S.
3. Finalización: Cuando “A” termina, se libera la memoria y el sistema vuelve al prompt
(o reinicia), listo para cargar otro programa “B”.
4. Sin conmutación: En ningún momento el sistema ejecuta “A” y “B” simultáneamente;
uno se ejecuta detrás del otro.

8. Analogía Resumida
• Monoprogramación → Una sola vía por la que pasa un coche a la vez. Ningún otro
coche puede usar la vía hasta que el primero haya salido.
• Multiprogramación → Varias vías o carriles. Si un coche se detiene (espera), otro
carril (u otro espacio) permite avanzar a otros vehículos.

Conclusión
La monoprogramación fue un modelo muy habitual en los primeros sistemas
informáticos y en algunos sistemas embebidos actuales, donde la simplicidad y el
control son más importantes que la eficiencia y la multitarea. Aunque ha sido
ampliamente reemplazada por la multiprogramación en la mayoría de los sistemas
generales (debido a la necesidad de aprovechar al máximo la CPU y la memoria), en
ciertas aplicaciones muy específicas aún se utiliza monoprogramación por su facilidad
de implementación y baja complejidad.

A continuación, encontrarás una explicación clara de los conceptos Intercambio de

procesos, Paginación de memoria y Multiprogramación, junto con sus características
y por qué son relevantes en la gestión y eficiencia de los sistemas operativos.

1. Intercambio de procesos (Swapping)

1.1. ¿Qué es?

El intercambio de procesos (o “swapping”) consiste en sacar temporalmente un

proceso completo de la memoria principal (RAM) y guardarlo en un almacenamiento
secundario (por ejemplo, el disco) para liberar espacio. Luego, cuando se necesite
continuar la ejecución de ese proceso, se carga de nuevo en la RAM.
1.2. Caso presentado: “No hay intercambio”

En el texto se menciona que no se realiza intercambio de procesos. Esto implica que:

• El proceso se mantiene en memoria principal hasta que finaliza.

• No se saca el proceso a disco para dar paso a otro que necesite memoria.

Ejemplo:

• Monoprogramación clásica: Cargas un programa completo en RAM y no sacas nada

hasta que termine.
• Eficiente solo si la tarea es corta o hay mucha memoria disponible, pero limita la
posibilidad de correr varios programas simultáneamente.

2. Paginación de Memoria
2.1. ¿Qué es la paginación?

• Paginación es una técnica de administración de memoria en la que tanto la memoria

principal (RAM) como la memoria virtual (en disco) se dividen en unidades fijas
llamadas páginas (p. ej., 4 KB cada una).
• Permite cargar en la RAM solamente las partes del programa (páginas) necesarias en
un momento dado, evitando fragmentaciones grandes.

2.2. Caso presentado: “No se divide la memoria en unidades pequeñas”

Si no se usa paginación ni se divide la memoria, el programa se carga completo en la

RAM sin cortes:

• No hay “movimientos de página” (no se traen partes del programa por demanda).
• No hay fragmentación interna típica de la paginación, pero puede haber
fragmentación externa si hay huecos de memoria entre programas.

Ejemplo:

• Un sistema muy básico donde cada proceso debe encajar en un bloque de memoria
contigua. Se carga entero, se ejecuta y, tras terminar, libera ese bloque.

3. Multiprogramación
3.1. Definición

La multiprogramación (según Silva y Cura) es la capacidad de cargar y ejecutar

varios programas en la memoria al mismo tiempo, compartiendo eficientemente CPU
y memoria. Aunque la CPU ejecute solo una instrucción a la vez, se da la apariencia de
ejecución simultánea porque se conmuta rápidamente de un proceso a otro.

3.2. Características principales

1. Múltiples programas en memoria

o Se almacenan varios procesos en la RAM.
o Cuando uno espera (por ejemplo, operación de E/S), otro puede usar la CPU,
aumentando la productividad.
2. Conmutación de procesos
o El sistema operativo cambia de un proceso a otro, dando lapsos de CPU cortos
a cada uno.
o Mejora el rendimiento global y la respuesta a los usuarios.
3. Tiempo compartido
o La CPU se asigna a cada proceso por un pequeño quantum (por ejemplo, 50
ms), de modo que todos los procesos avancen de forma intercalada.
4. Gestión de recursos
o El SO administra la asignación de CPU, memoria y dispositivos de E/S para
evitar conflictos.
o Se aplican algoritmos de planificación para decidir qué proceso va primero o
tiene mayor prioridad.
5. Mejora del uso de recursos
o Mientras un proceso está bloqueado (esperando lectura/escritura en disco),
otro proceso en espera puede usar la CPU.
o Evita que el procesador quede inactivo.
6. Protección y seguridad
o Cada proceso se aísla para que no acceda indebidamente a memoria o
recursos de otro.
o Mecanismos de protección evitan la corrupción de datos y promueven la
estabilidad del sistema.

4. Relación entre los conceptos

1. Sin intercambio (swapping) y sin paginación:
o Cada proceso se carga por completo en la RAM y permanece ahí hasta
terminar.
o Esto limita la capacidad de ejecutar múltiples programas simultáneos (aunque
se podría hacer multiprogramación si la RAM es suficiente para varios
programas completos).
o Cuando un proceso termina, se libera la memoria para el siguiente.
2. Multiprogramación sin intercambio ni paginación:
o Es posible en sistemas con mucha RAM o con pocos y pequeños procesos.
o La CPU puede “conmutar” de un proceso a otro sin sacarlos a disco, siempre
que quepan todos a la vez en la RAM.
3. Uso eficiente:
o Multiprogramación mejora la utilización de la CPU, pero sin paginación ni
intercambio, el número de procesos en memoria puede ser limitado.
 o Intercambio y paginación brindan mayor flexibilidad, permitiendo que más
procesos entren y salgan de la memoria según la demanda.

5. Ejemplo Ilustrativo
Escenario:

• Tienes 2 GB de RAM y dos procesos:

o Proceso A (400 MB)
o Proceso B (500 MB)

Sin intercambio ni paginación:

• Cargas ambos procesos completos en los 2 GB (900 MB usados).

• El sistema distribuye la CPU entre A y B en “modo multiprogramación”.
• Cada uno tiene un turno de CPU mientras el otro espera (o se bloquea si necesita E/S).

Ventajas:

• Simplicidad en la administración de memoria (todo el programa entra o no entra).

• Facilidad de conmutar CPU sin manipular la memoria a menudo.

Desventajas:

• Si llega un Proceso C de 1.5 GB, podría no caber en la RAM junto a los otros y no se
intentaría “sacarlos” al disco (porque no hay intercambio) ni dividirlo en páginas (sin
paginación).
• Se pierde oportunidad de tener 3 procesos en ejecución simultáneamente.

Conclusión
• Intercambio de procesos (swapping) y paginación son técnicas para aumentar la
flexibilidad y eficiencia de la memoria.
• Sin estas técnicas, los procesos se mantienen completos en la RAM hasta que finalicen,
lo cual puede funcionar con uno o pocos procesos pequeños.
• La multiprogramación permite que varios programas se compartan la CPU y la
memoria, mejorando el rendimiento del sistema y reduciendo los tiempos de
inactividad de la CPU.
• Aun sin swapping ni paginación, la multiprogramación puede darse, pero es menos
dinámica. Con un uso intensivo de intercambios o paginación, es posible cargar más
programas y administrarlos de forma más eficiente, logrando un aprovechamiento
óptimo de los recursos

A continuación encontrarás una explicación detallada sobre las particiones fijas en la

gestión de memoria de un sistema operativo. Este método es uno de los primeros usados
para organizar y asignar memoria a los procesos.
1. ¿Qué son las Particiones Fijas?
Las particiones fijas consisten en dividir la memoria principal en varias regiones de
tamaño estático (fijas) al momento de arrancar o configurar el sistema operativo. Cada
partición puede albergar un proceso completo siempre que dicho proceso no exceda el
tamaño de la partición asignada.

Características principales:

1. Tamaño constante: Una vez definidas, estas particiones no cambian de tamaño

durante el funcionamiento normal del sistema.
2. Asignación directa: Al iniciarse un proceso, el SO lo ubica en una partición que se
ajuste (o sea mayor) a su tamaño.
3. Organización: Los procesos se agrupan uno por cada partición, sin mezclar dos
procesos en la misma partición.

2. ¿Cómo funcionan las Particiones Fijas?

1. Configuración inicial:
o Al arrancar el sistema o en el momento de instalación/arranque, se definen las
particiones (por ejemplo, 4 particiones de 128 MB cada una).
o Pueden ser todas del mismo tamaño o de tamaños diferentes (por ejemplo, 2
de 128 MB y 2 de 256 MB), dependiendo de las necesidades previstas.
2. Asignación de una partición a un proceso:
o Cuando un proceso quiere ejecutarse, el sistema operativo busca una
partición libre lo suficientemente grande para contenerlo.
o Si el proceso requiere, por ejemplo, 100 MB, se buscará una partición de al
menos 100 MB.
3. Ejecución en esa partición:
o El proceso corre dentro de esa partición. Si se completa, la partición queda
libre de nuevo.
o Si el proceso necesita más memoria de la que se asignó inicialmente, no puede
expandirse porque el tamaño de la partición es fijo.
4. Terminación del proceso:
o Al terminar el proceso, la partición se marca como libre y puede usarse para
otros procesos.

3. Ventajas de las Particiones Fijas

1. Simplicidad de implementación:
o Es fácil de programar y gestionar porque no hay necesidad de algoritmos
complicados para redimensionar o mover procesos.
2. Baja sobrecarga de gestión:
 o El sistema no invierte recursos en reorganizar las particiones; no hay necesidad
de “unir” huecos, ni calcular índices avanzados.
3. Adecuado para entornos pequeños:
o Cuando se conoce de antemano el tamaño aproximado de los procesos y no
se esperan grandes variaciones, puede resultar práctico.

4. Desventajas de las Particiones Fijas

1. Fragmentación Interna:
o Ocurre cuando un proceso no utiliza todo el espacio de su partición asignada.
El espacio sobrante queda inutilizable para otros procesos.
o Ejemplo: Una partición de 256 MB asignada a un proceso de 200 MB
desperdicia 56 MB.
2. Inflexibilidad:
o Si un proceso necesita más memoria de la que ofrece la partición más grande,
no podrá ejecutarse.
o No se puede reasignar o extender la partición en tiempo de ejecución.
3. Uso ineficiente de memoria:
o Es difícil optimizar el tamaño de cada partición para que se ajuste
perfectamente a los procesos, generando huecos y desperdicios.
4. Predicción de necesidades:
o Es necesario “adivinar” los tamaños de particiones para satisfacer la mayoría
de procesos. Cualquier cambio en las necesidades futuras se vuelve
problemático.

5. Ejemplos de Uso
1. Sistemas Antiguos:
o Mainframes y minicomputadoras de los años 60 y 70 usaban particiones fijas al
arrancar.
o Las empresas configuraban, por ejemplo, 2 particiones “pequeñas” y 2
“grandes” según sus aplicaciones típicas.
2. Dispositivos Embebidos Simples:
o Algunos microcontroladores o sistemas con muy poca memoria pueden definir
una división básica para cargar un firmware principal y uno secundario
(aunque cada vez es menos frecuente por la adopción de esquemas más
dinámicos).
3. Laboratorios de enseñanza:
o A veces, en entornos académicos, se enseñan particiones fijas para ilustrar los
conceptos iniciales de administración de memoria sin complicaciones.

6. Particiones Fijas vs. Particiones Dinámicas

 1. Fijas:
o Tamaño establecido en configuración.
o Fragmentación interna, pero no fragmentación externa (no hay huecos
dispersos entre particiones, sino dentro de ellas si están sobredimensionadas).
2. Dinámicas:
o Se crean y ajustan conforme a la necesidad de cada proceso (por ejemplo,
usando particiones variables o segmentos).
o Reducen la fragmentación interna pero pueden sufrir fragmentación externa
(hay huecos en la RAM cuando se liberan segmentos, haciendo difícil
acomodar nuevos procesos).

7. Ejemplo Práctico
Imaginemos un sistema con 1 GB (1024 MB) de RAM, donde se definen 4 particiones
fijas:

• Partición 1: 256 MB
• Partición 2: 256 MB
• Partición 3: 256 MB
• Partición 4: 256 MB

Flujo de ejecución

1. Proceso A (200 MB):

o Se asigna a la Partición 1 de 256 MB.
o Fragmentación interna de 56 MB (inutilizados).
2. Proceso B (270 MB):
o No cabe en una partición de 256 MB, así que no se puede ejecutar en este
sistema.
3. Proceso C (128 MB):
o Se carga en la Partición 2, dejando 128 MB sin uso dentro de esa partición.
4. Proceso A finaliza: Partición 1 libre.

Si posteriormente llega un proceso de 300 MB, tampoco puede ejecutarse en ninguna

partición, aun teniendo memoria libre en total (256+128 = 384 MB en 2 particiones), no
puede ocupar dos particiones a la vez.

8. Resumen
• Las particiones fijas dividen la memoria principal en bloques inmutables, ofreciendo
simplicidad y baja sobrecarga de administración, pero sufriendo de fragmentación
interna y poca flexibilidad a la hora de acomodar procesos grandes.
• Fueron comunes en los sistemas operativos antiguos y, aunque ahora la mayoría de
los SO utilizan métodos más dinámicos (paginación, segmentación, particiones
variables), siguen siendo un excelente ejemplo didáctico para comprender la evolución
de la gestión de memoria en la historia de la computación.
A continuación, encontrarás una explicación más amplia del concepto de intercambio
(o swapping) en el contexto de la memoria virtual, así como las ideas de paginación,
segmentación, falta de página y políticas de reemplazo. Estos elementos se combinan
para que un sistema operativo pueda gestionar de manera eficiente el uso de la RAM y
el almacenamiento secundario (disco).

1. Intercambio (Swapping) y Gestión de la Memoria

Virtual
1.1. ¿Qué es el intercambio?

• Intercambio (o swapping) consiste en mover parte o la totalidad de un proceso desde

la memoria principal (RAM) al almacenamiento secundario (disco) y viceversa.
• El fin es liberar espacio en RAM para que otros procesos puedan ejecutarse cuando la
memoria no es suficiente.

1.2. ¿Por qué la memoria se trata como un “todo”?

• La memoria virtual permite que el sistema operativo y los programas vean un espacio
de direcciones unificado (RAM + disco).
• Cuando la RAM está llena, partes menos usadas de los procesos se “intercambian” al
disco, de modo que en la memoria física solo residan las partes más activas.

Ejemplo:

1. Tienes 3 programas cargados (A, B, C), pero solo hay espacio real en la RAM para 2.
2. El sistema intercambia al disco fragmentos no usados del programa C para que B y A
quepan plenamente.
3. Si C vuelve a necesitarse con intensidad, partes de A o B podrían ser movidas a disco.

2. Paginación y Segmentación
2.1. Paginación

• Paginación divide la memoria (tanto física como virtual) en bloques de tamaño fijo
llamados páginas (por ejemplo, 4 KB).
• Cada parte de un proceso se aloja en páginas, y el sistema operativo mantiene tablas
que indican dónde se encuentran esas páginas (RAM o disco).
• Cuando un proceso requiere una página que no está en RAM, se produce un fallo de
página (page fault) y se trae la página correspondiente del disco.

2.2. Segmentación

• Segmentación organiza la memoria en segmentos de tamaño variable (por ejemplo,

un segmento para el código, otro para datos).
 • Puede combinarse con la paginación (segmentación paginada) para mitigar la
fragmentación y aprovechar lo mejor de ambos mundos.

Ejemplo:

• Un proceso se divide en varios segmentos (código, datos, pila) y, a su vez, cada

segmento se subdivide en páginas de tamaño fijo (paginación).

3. Falta de Página (Page Fault)

3.1. ¿Qué es?

• Un fallo de página ocurre cuando un programa intenta acceder a una dirección de

memoria cuyas páginas no están cargadas en la RAM.
• El sistema operativo detiene la ejecución del proceso momentáneamente y carga la
página requerida desde el disco a la RAM.

3.2. Consecuencias

• Provoca tiempos de acceso mayores (porque leer del disco es más lento que leer de la
RAM).
• Si la memoria RAM está llena, se debe expulsar otra página (ver “política de
reemplazo”) para hacer espacio a la nueva.

Ejemplo:

• Tu proceso necesita la página 12, pero está en el disco. Se genera un page fault y el SO
trae la página 12 a la RAM.
• Si no hay marco libre, la política de reemplazo decide qué página sacar.

4. Política de Reemplazo
4.1. ¿Qué es?

• Es el criterio que determina qué página expulsar de la memoria RAM cuando está
llena y llega un fallo de página.
• Busca minimizar el número de fallos de página futuros o mantener un buen
rendimiento.

4.2. Algoritmos frecuentes

1. FIFO (First In, First Out): Se expulsa la página que lleva más tiempo cargada.
2. LRU (Least Recently Used): Expulsa la página que menos se ha usado recientemente.
3. LFU (Least Frequently Used): Expulsa la página con menos accesos acumulados.
4. Algoritmo de Reloj (Clock): Una implementación eficiente que revisa bit de referencia
para decidir.
Ejemplo:

• Si usas LRU y la página 5 no se ha usado en mucho tiempo, mientras que las páginas 6,
7 y 8 se han usado recientemente, LRU decide sacar la página 5.

5. Resumen de cómo funciona todo en conjunto

1. Memoria virtual: El proceso ve un espacio lógico unificado (RAM + disco).
2. Intercambio/Swapping: Partes del proceso se mueven entre RAM y disco según
demanda.
3. Paginación o Segmentación: Se administra qué partes del proceso van a la RAM y
cuáles quedan fuera (en disco) mediante páginas (tamaño fijo) o segmentos (tamaño
variable).
4. Falta de página: Cuando se requiere una página que no está en RAM, ocurre un page
fault y se trae del disco.
5. Política de reemplazo: Si la RAM está llena, decide qué página expulsar.

6. Ejemplo Práctico (Escenario Paso a Paso)

Supongamos:

• Tienes 3 procesos (A, B, C) corriendo, y la RAM solo tiene espacio para un máximo de 6
páginas.
• Cada proceso necesita 4 páginas en total (A: páginas 1-4, B: páginas 5-8, C: páginas 9-
12).

1. Inicio: El SO carga en la RAM unas cuantas páginas de A y B (total 6).

2. Fallo de página: Proceso C pide la página 9 y no está en RAM → page fault.
3. Política de reemplazo: Se escoge una página menos usada, por ejemplo la página 1 de
A, y se expulsa a disco para meter la página 9 de C.
4. Ejecución: Ahora C corre con su página 9 en RAM. Si necesita más páginas, seguirá
generando fallos de página.
5. Intercambio (Swapping): Si C está inactivo y B necesita crecer, el sistema puede mover
todas las páginas de C al disco (swap out) y liberar RAM para B. Más tarde, si C vuelve a
estar activo, se carga otra vez (swap in).

Este mecanismo optimiza el uso de recursos, permitiendo que varios procesos

compartan la CPU y la RAM de manera dinámica, en lugar de tener cada proceso
esperando a que termine otro.

Conclusión

El intercambio (swapping) se enlaza íntimamente con la gestión de memoria virtual,

donde paginación o segmentación facilitan la carga de partes de un proceso desde el
disco a la RAM según se necesite. Cuando un proceso solicita una página que no está en
la memoria (falta de página), se aplica una política de reemplazo para decidir cuál
página existente en RAM se expulsa, optimizando así la ejecución concurrente de
múltiples programas y el uso eficiente de la memoria.

A continuación, encontrarás una explicación completa sobre direcciones de memoria,

su relación con la memoria virtual y la paginación, con ejemplos tanto tecnológicos
como de la vida real para ayudarte a entender mejor estos conceptos.

1. Dirección de Memoria
1.1. Definición

• Una dirección de memoria es un identificador único que se utiliza para señalar dónde
se almacena un dato o instrucción dentro de la memoria de una computadora.
• Normalmente se representan como números hexadecimales (por ejemplo,
0x7FFFD3A8) debido a que la hexadecimal facilita la lectura y el manejo de valores
binarios largos.

1.2. Importancia

1. Localizar datos: Permite al procesador y al sistema operativo encontrar y manipular la

información almacenada.
2. Ejecución de instrucciones: Cada instrucción del programa reside en una dirección
específica y debe ser “localizada” para ser ejecutada por la CPU.
3. Interacción con hardware: Las direcciones de memoria no solo se usan para la RAM,
sino también para periféricos mapeados en memoria (E/S).

1.3. Ejemplo tecnológico

• Un programa en C puede tener una variable llamada contador. Internamente,

contador se ubica en una dirección de memoria, como 0x7FFFC128, donde se
almacenará su valor. El procesador y la unidad de gestión de memoria (MMU) sabrán a
qué lugar físico de la RAM corresponde.

1.4. Ejemplo de la vida real

• Archivero con cajones numerados: Imagina un archivero con 100 cajones, cada uno
tiene un número (dirección). Para encontrar un documento, necesitas saber en qué
cajón (dirección) está guardado. Del mismo modo, la computadora requiere la
dirección para encontrar o guardar datos.
2. Tipos de Dirección de Memoria
A grandes rasgos, se pueden mencionar:

1. Dirección de Memoria RAM: Apunta a posiciones de la memoria principal (acceso

directo).
2. Dirección de Memoria Virtual: Direcciones lógicas que el sistema operativo mapea a
direcciones físicas (RAM) o almacenamiento secundario.
3. Dirección de Memoria ROM (Read-Only Memory): Puntos donde se almacenan
instrucciones/firmware (por ejemplo, BIOS).
4. Dirección de Memoria de Registro: Hace referencia a los registros internos del CPU
(pequeños espacios de almacenamiento ultra rápidos).
5. Dirección de Memoria de E/S: Direcciones empleadas para interactuar con
dispositivos de entrada/salida.
6. Dirección de Almacenamiento en Disco: Cuando se apunta a sectores o bloques del
disco duro u otro almacenamiento masivo.

3. Memoria Virtual
3.1. Definición

La memoria virtual permite que el sistema operativo y el hardware administren la

memoria de manera abstracta: un programa ve un espacio de direcciones lógico
(virtual) que puede ser mucho mayor que la memoria física real instalada.

3.2. Objetivos

1. Ejecutar programas más grandes que la RAM disponible.

2. Aislar procesos entre sí, mejorando seguridad y estabilidad.
3. Optimizar el uso de la RAM al cargar en memoria física solo las partes realmente
necesarias de cada programa.

3.3. Ejemplo tecnológico

• Un sistema con 4 GB de RAM física puede ofrecer 8 GB o más de memoria virtual.

Cuando un proceso requiere más memoria, partes de su espacio de direcciones se
guardan temporalmente en el disco (swap).

3.4. Ejemplo de la vida real

• Reservación de asientos en un avión: El avión (memoria física) tiene 200 asientos. Sin
embargo, la aerolínea sobrevende (memoria virtual) hasta 220 boletos, asumiendo
que no todos los pasajeros aparecerán. Mientras la demanda efectiva no supere 200
personas al mismo tiempo, todos tendrán asiento. Pero si todos vinieran, habría que
“sacar” a alguien (el sistema realiza swapping), lo que puede generar demora o
reubicaciones.
3.5. Características clave de la Memoria Virtual
1. Abstracción de la memoria física
o Oculta detalles físicos (direcciones reales en RAM) a las aplicaciones.
o Cada proceso cree tener su propio espacio de direcciones.
2. Tamaño potencialmente mayor
o El SO puede asignar direcciones virtuales que exceden la RAM real,
apoyándose en disco duro (swap) cuando sea necesario.
3. Paginación y Segmentación
o Son métodos para dividir la memoria y organizarla de forma eficiente (ver
sección de paginación más adelante).
4. Gestión de memoria bajo demanda
o Se carga en RAM solo lo necesario. El resto se mantiene en disco hasta que se
requiera.
5. Swap (intercambio)
o Mueve datos de la RAM al disco y viceversa para liberar memoria física.
6. Protección y aislamiento
o Evita que un proceso modifique la memoria de otro sin autorización.
7. Mejora del rendimiento
o Al permitir la ejecución simultánea de programas sin que la CPU quede
inactiva por falta de memoria, aumenta la eficiencia global.

4. Paginación
4.1. Definición

La paginación consiste en dividir la memoria (tanto física como virtual) en bloques de

tamaño uniforme llamados páginas (típicamente 4 KB, 8 KB, etc.). Cada página
virtual se mapea a un marco (o frame) de página física.

Beneficios

• Uso eficiente de la memoria.

• Protección: Cada proceso opera en sus propias páginas, evitando colisiones.

4.2. Ejemplo tecnológico

1. Página de 4 KB: Tu sistema operativo divide la RAM en trozos de 4 KB. Si un proceso

requiere 12 KB, se le asignan 3 páginas de 4 KB.
2. Tabla de páginas: El sistema mantiene una tabla que indica qué página virtual
corresponde a qué marco físico.

4.3. Ejemplo de la vida real

• Casilleros en un gimnasio: Imagina que cada casillero mide 1m x 1m (página de

tamaño fijo). Si alguien trae un saco de 3 metros cúbicos, necesitará ocupar 3
casilleros. El administrador (SO) apunta: “El saco de Juan está en casilleros 2, 3 y 4”.
4.4. Tipos de Paginación
1. Paginación pura
o Toda la memoria física se fracciona en páginas de igual tamaño.
o Cada página virtual mapea a un marco físico equivalente.
2. Paginación segmentada
o Se combinan segmentos (lógicas partes del programa) con páginas (tamaño
fijo).
o Aporta flexibilidad en la administración de memoria, pero aumenta la
complejidad de las tablas.
3. Paginación invertida
o Existe una única tabla que describe las páginas físicas, señalando a qué
proceso y página virtual pertenecen.
o Reduce uso de memoria para tablas, aunque la búsqueda puede ser más lenta
si la tabla crece.
4. Paginación multinivel
o La tabla de páginas se divide en niveles (por ej., directorio de páginas y tabla
de páginas), útil cuando el espacio de direcciones virtuales es grande.
o Facilita el manejo de tablas gigantes (p. ej., en sistemas de 64 bits).
5. Paginación por demanda
o No se carga toda la página en RAM hasta que sea realmente necesaria (lazy
loading).
o Reduce el uso de memoria, pero puede aumentar los fallos de página (page
faults).
6. Paginación anticipada
o Se cargan páginas de forma proactiva esperando que pronto se necesiten.
o Intenta minimizar la latencia futura, pero podría cargar datos innecesarios.

5. Algoritmos de Reemplazo de Páginas

Cuando la RAM está llena y llega un “fallo de página”, el sistema debe liberar un
marco, eligiendo qué página expulsar. Existen varios algoritmos:

1. FIFO (First-In, First-Out)

o Expulsa la página que lleva más tiempo cargada.
o Ejemplo de vida real: La “cola” del supermercado: el primero en entrar es el
primero en salir.
2. LRU (Least Recently Used)
o Expulsa la página que no ha sido usada recientemente.
o Ejemplo: Si tienes 3 apps en tu teléfono, cierras la que hace más tiempo no
abres.
3. LFU (Least Frequently Used)
o Expulsa la página con menos accesos acumulados.
o Ejemplo: En una bodega, sacas de tu estante el producto que menos se ha
utilizado en un periodo para hacer espacio.
4. NUR (Not Used Recently)
 o Similar a LRU, pero clasifica páginas en categorías según si han sido
referenciadas o modificadas en un periodo reciente.
5. Algoritmo de Reloj (Clock)
o Usa un puntero circular (como la aguja de un reloj) para marcar páginas y
decidir cuál expulsar.
o Es una implementación eficiente de NUR.
6. MFU (Most Frequently Used)
o Expulsa la página que ha sido más usada (suponiendo que “la más usada
seguirá siendo usada”).
o Menos común, pero útil en ciertos escenarios.

6. Aplicaciones y Ejemplos Generales

1. Sistemas Operativos Modernos (Windows, Linux, macOS)
o Usan memoria virtual y paginación para permitir que múltiples aplicaciones
corran simultáneamente sin pisar la memoria entre sí.
o Implementan algoritmos de reemplazo de páginas (generalmente una variante
de LRU o Clock).
2. Teléfonos Móviles
o Aunque iOS y Android usan técnicas de memoria virtual, manejan de forma
agresiva la liberación de apps en segundo plano porque el swap en disco
(almacenamiento flash) es limitado.
3. Servidor de Bases de Datos
o Se pueden cargar grandes cantidades de datos en memoria para acceso
rápido. Cuando se supera la RAM, se confía en la paginación para mantener la
aplicación funcionando, aunque con menor rendimiento.
4. Videojuegos
o Usan técnicas parecidas para cargar texturas y escenarios, aunque a menudo
implementan sistemas propios de streaming de contenido (similar a una
paginación especializada), para que solo carguen en memoria las partes del
mapa cercanas al jugador.

7. Analogías de la Vida Real para Comprender Paginación y

Memoria Virtual
1. Biblioteca con Estanterías y Bodega:
o La estantería (RAM) es limitada, la bodega (disco) es grande. Se traen libros a
la estantería cuando son consultados. Si la estantería está llena, se devuelve
alguno a la bodega según un criterio (FIFO, LRU, etc.).
2. Hotel con Habitaciones y Reservas:
o Cada habitación es un “frame físico”, y las reservas se refieren a “páginas
virtuales”. Un huésped solo ocupa físicamente una habitación si está presente.
Si llegan más huéspedes de los que caben, el hotel debe decidir a quién
reubicar (swap) o rechazar.
8. Conclusión
La dirección de memoria es la base sobre la cual se construyen conceptos como la
memoria virtual y la paginación. Gracias a estos mecanismos:

• Podemos ejecutar programas que superan la capacidad de RAM disponible.

• Cada proceso goza de un espacio de direcciones aislado y protegido.
• Se optimiza el uso de la memoria y se evita la inactividad de la CPU esperando a que
un proceso libere recursos.

En resumen, los sistemas operativos modernos usan direcciones de memoria virtual y

paginación para lograr un equilibrio entre eficiencia, flexibilidad y protección de
datos, brindándonos la capacidad de ejecutar múltiples aplicaciones simultáneamente y
de forma segura.

A continuación, encontrarás definiciones detalladas de los principales algoritmos de

reemplazo de páginas, acompañadas de ejemplos ilustrativos que muestran cómo se
selecciona la página a expulsar de la memoria. Estos algoritmos son fundamentales en
sistemas operativos que usan memoria virtual y paginación, porque cuando la
memoria física (marcos) está llena y ocurre un “fallo de página” (page fault), el sistema
debe decidir qué página sacar para hacer espacio a la nueva.

1. FIFO (First-In, First-Out)

1.1. Definición
• FIFO expulsa la página que lleva más tiempo en la memoria, es decir, la que fue
cargada primera.
• Se implementa con una cola: la página que entró primero, sale primero.

1.2. Ejemplo ilustrativo

• Supongamos que tenemos 3 marcos de página y una secuencia de referencias a
páginas:
• Referencias = [7, 0, 1, 2, 0, 3, 0, 4]
• Paso a paso (solo mostramos cuándo hay fallos y cuál se expulsa):
1. Referencia a 7: Memoria vacía → se carga 7.
▪ Marcos: [7, -, -]
2. Referencia a 0: Falla → se carga 0.
▪ Marcos: [7, 0, -]
3. Referencia a 1: Falla → se carga 1.
▪ Marcos: [7, 0, 1]
4. Referencia a 2: Falla → la cola indica que la primera en entrar fue 7, se expulsa
7, se carga 2.
▪ Marcos: [2, 0, 1]
5. Referencia a 0: No hay falla (0 ya está).
 ▪ Marcos: [2, 0, 1]
6. Referencia a 3: Falla → la siguiente en la cola es 0 (la que entró antes que 1 y
2), se expulsa 0, se carga 3.
▪ Marcos: [2, 3, 1]
7. Referencia a 0: Falla → la siguiente en la cola es 1 (entró antes que 2 y 3), se
expulsa 1, se carga 0.
▪ Marcos: [2, 3, 0]
8. Referencia a 4: Falla → la siguiente es 2 (entró antes que 3 y 0), se expulsa 2,
se carga 4.
▪ Marcos: [4, 3, 0]
• Ventajas: Fácil de implementar, solo se maneja una cola.
• Desventajas: Puede expulsar páginas muy utilizadas solo porque llevan mucho
tiempo en memoria (no considera “uso reciente”).

1.3. Analogía de la vida real

• Cola en un supermercado: el primer cliente que llegó es el primero en ser atendido.

No se revisa si un cliente tiene pocas o muchas compras, simplemente se sigue el
orden de llegada.

2. LRU (Least Recently Used)

2.1. Definición
• LRU expulsa la página que no se ha usado más recientemente.
• La idea es que las páginas usadas hace mucho tiempo tienen menos probabilidad de
ser necesitadas inmediatamente que las usadas recientemente.

2.2. Ejemplo ilustrativo

Usamos la misma secuencia de referencias [7, 0, 1, 2, 0, 3, 0, 4] y 3 marcos.

1. Referencia 7: Falla, carga 7.

o Marcos: [7, -, -]
o Uso reciente: 7
2. Referencia 0: Falla, carga 0.
o Marcos: [7, 0, -]
o Uso reciente: (7 fue usado antes, 0 ahora)
3. Referencia 1: Falla, carga 1.
o Marcos: [7, 0, 1]
o Uso reciente: 7, 0, 1
4. Referencia 2: Falla, ¿cuál es la menos recientemente usada?
o Uso reciente: la más antigua es 7 (se usó primero, luego 0, luego 1). Se expulsa
7, carga 2.
o Marcos: [2, 0, 1]
5. Referencia 0: No falla (0 está en memoria). Actualizamos uso reciente.
o El más reciente es 0, luego 1, luego 2.
 6. Referencia 3: Falla, la menos usada recientemente es 2 (porque 0 se acaba de usar, 1
está en memoria desde hace poco, 2 fue la anterior en uso). Expulsa 2, entra 3.
o Marcos: [3, 0, 1]
7. Referencia 0: Ya está (no falla). Actualizar uso: 0 es el más reciente, luego 1, luego 3.
8. Referencia 4: Falla, expulsamos la menos usada: 3 (última vez se usó fue en el paso 6).
Carga 4.
o Marcos: [4, 0, 1]

• Ventajas: Se aproxima a un método óptimo en muchos casos, porque asume que lo

que fue usado más recientemente es más probable que se vuelva a usar pronto.
• Desventajas: Difícil de implementar en hardware puro, porque se necesita rastrear el
orden de uso de las páginas.

2.3. Analogía de la vida real

• Tu mochila: Tienes un cupo limitado para libros (3 libros). Guardas los que usaste hace
poco. Si necesitas uno nuevo y tu mochila está llena, sacas aquel que no has
consultado por más tiempo.

3. LFU (Least Frequently Used)

3.1. Definición
• LFU expulsa la página que ha sido usada menos frecuentemente durante un periodo
(cuenta de accesos).
• La idea: si una página se usa poco, es menos probable que se necesite pronto.

3.2. Ejemplo sencillo

• Supongamos se refiere a páginas [A, B, C, D, B, C, C] con 3 marcos.
• Se lleva un contador de cuántas veces se accede a cada página:
o Si la memoria está llena y llega una nueva página, se elimina la que tiene el
contador de accesos más pequeño.

1. Carga A, B, C (fallos en cada una) → contadores: A=1, B=1, C=1.

2. Llega D, hay que sacar una. Todas tienen contador=1; LFU expulsa la “primera” con
menor contador (podría romper empates de forma FIFO o LRU). Supongamos se
expulsa A → cargamos D (D=1), B=1, C=1.
3. Llega B de nuevo: B se usa; su contador pasa a 2 (B=2, C=1, D=1). Sin fallos de página.
4. Llega C, C se usa; su contador = 2 (B=2, C=2, D=1).
5. Llega C otra vez, C=3 (B=2, C=3, D=1).

• Si ahora llega otra página, la que se expulsará es la de uso menos frecuente, que
es D=1.
• Ventajas: Beneficia a las páginas muy usadas, pues se mantendrán en memoria.
 • Desventajas: Una página muy usada en el pasado pero no reciente puede
quedarse con un contador alto y no ser expulsada, aunque ya no se necesite tanto
(puede provocar casos de “una estrella olvidada”).

3.3. Analogía de la vida real

• Restaurante: Tienes un menú con platos. Expulsas del menú (dejas de ofrecer) el plato
con menos ventas (menor frecuencia de compra). Mantienes los platos más populares
(frecuentes) por más tiempo.

4. NUR o NRU (Not Used Recently / Not Recently Used)

4.1. Definición
• NRU clasifica las páginas según dos bits:
o R (Referenced): Indica si la página ha sido leída/usada recientemente.
o M (Modified): Indica si la página ha sido escrita.
• Periódicamente, el sistema “resetea” el bit R. Cuando se necesita reemplazar, se
expulsa preferentemente una página que no fue usada recientemente (R=0) y no fue
modificada (M=0), para minimizar costos de escritura a disco.

4.2. Ejemplo básico

• Suponiendo 4 páginas en memoria con estados:
o P1: R=0, M=0
o P2: R=0, M=1
o P3: R=1, M=0
o P4: R=1, M=1
• NRU agrupa las páginas en clases:
o (R=0, M=0)
o (R=0, M=1)
o (R=1, M=0)
o (R=1, M=1)
• Primero intenta expulsar las de la clase 1 (R=0, M=0), que no se han usado ni
modificado. En este ejemplo, P1 es la candidata.

4.3. Analogía de la vida real

• Biblioteca:
o R=1: El libro ha sido consultado recientemente.
o M=1: El libro ha sido anotado o modificado (necesitas tiempo para guardarlo
cuidadosamente).
o Expulsas primero libros que no se han consultado ni modificado en mucho
tiempo.
5. Algoritmo de Reloj (Clock)

5.1. Definición
• Clock es una implementación eficiente de NRU en la práctica.
• Cada página se representa como un puntero en un anillo (reloj). Cada página tiene un
bit R (referencia). El puntero “camina” por las páginas en círculo.

5.2. Funcionamiento resumido

1. Cuando se necesita espacio, el puntero revisa la página actual:
o Si R=1, significa “fue usada recientemente”, entonces pone R=0 y avanza el
puntero. (No la expulsa esta vez.)
o Si R=0, significa “no ha sido usada recientemente”, se expulsa esa página.
2. El puntero se mueve cíclicamente por los marcos.

5.3. Ejemplo simplificado

• Marcos en un anillo: [P1, P2, P3, P4] con sus bits R.
• Supón que P1=R=1, P2=R=0, P3=R=1, P4=R=0, y necesitamos sacar una página:
1. El puntero está en P1: ve R=1, lo pone en 0, avanza.
2. Llega a P2: R=0, la expulsa de inmediato.

5.4. Analogía de la vida real

• Rueda giratoria con casilleros, cada uno tiene un “indicador” de uso. Si el indicador
está encendido (1), lo apagas (0) y pasas de largo. Al segundo giro, si sigue apagado
(0), lo liberas.

6. MFU (Most Frequently Used)

6.1. Definición
• MFU elige expulsar la página con mayor número de accesos. Se basa en la suposición
de que si una página ha sido accedida mucho, es probable que se requiera menos en el
futuro y que las páginas con menos acceso todavía se necesitan.

6.2. Ejemplo corto

• Si tienes contadores:
o P1=10 accesos, P2=5, P3=8, P4=1
• Con MFU, expulsarías P1 con 10 accesos porque “ya se utilizó mucho, quizás no se
usará pronto”.
• Es un caso opuesto a LFU.
6.3. Analogía de la vida real
• Menú de un restaurante (visión alternativa): Un plato hiperpopular ya saturó el
mercado, se decide quitarlo para darle espacio a uno nuevo. (Aunque, en la práctica,
esto es menos común.)

7. Comparación y Consideraciones
Algoritmo Ventaja Desventaja Escenario Típico

Puede expulsar páginas

FIFO Fácil de implementar muy usadas (no considera Sistemas simples
uso real)

Costoso de implementar SOs modernos con

LRU Buen rendimiento, intuitivo
sin hardware de soporte hardware LRU

Puede “casarse” con

Favorece páginas de uso Cachés de bases de
LFU páginas que fueron
continuo datos
populares pero ya no

Simple de implementar con Sólo da 4 clases, no Unix-like con bits R y

NRU/NUR
bits prioriza muy finamente M

Puede requerir varios

Implementación real
Clock Eficiente, similar a LRU pasos para expulsar la
de NRU
página deseada

Libera páginas que fueron

Puede ser ineficaz si esas
muy usadas (suponiendo Poco frecuente en la
MFU páginas siguen siendo
que no se requerirán práctica
necesarias
pronto)

8. Ejemplo Completo con Reference String

Para ver claramente las diferencias, considera la referencia de páginas:

Secuencia: [1, 2, 3, 2, 1, 4, 2, 3, 1]
Marcos disponibles: 3

Breve resultado (número de fallos de página) usando 3 algoritmos:

1. FIFO:
o Marcos a cada paso, se va expulsando la página que más tiempo lleva dentro.
o Suele dar, por ejemplo, X fallos (haz un conteo preciso si deseas la cifra
exacta).
2. LRU:
 o Expulsa la página menos recientemente usada.
o Tiende a generar menos fallos que FIFO en muchos casos.
3. LFU:
o Llega a expulsar la que tenga menor frecuencia total de uso.

Dependiendo de la secuencia, cada algoritmo puede comportarse mejor o peor. No

existe un algoritmo “universalmente perfecto”; todo depende de los patrones reales de
uso de páginas.

Conclusión
Los algoritmos de reemplazo de páginas son esenciales para gestionar la memoria
virtual cuando la RAM está llena y se necesita liberar espacio. Cada algoritmo propone
una forma distinta de decidir qué página expulsar, buscando un balance entre:

• Eficiencia (reducir fallos de página)

• Facilidad de implementación
• Carga de trabajo (tiempo de CPU usado para tomar la decisión)

En la práctica, muchos sistemas operativos modernos utilizan variantes de LRU y

Clock, combinadas con heurísticas o estadísticas de uso real para optimizar el
rendimiento.
A continuación encontrarás una explicación sencilla sobre segmentación, sus
conceptos clave y algunos ejemplos básicos que te ayudarán a comprender cómo se
utiliza tanto en informática como en la vida real.

1. Definición de Segmentación
La segmentación es una técnica de administración de memoria que divide el espacio
de direcciones de un proceso en bloques lógicos llamados segmentos. Cada segmento
suele representar un tipo de información o código dentro del programa (por ejemplo,
segmento de código, segmento de datos, segmento de pilas).

• Tamaño dinámico: A diferencia de la paginación, los segmentos no tienen un tamaño

fijo.
• Protección y aislamiento: Cada segmento puede definirse con permisos de lectura,
escritura o ejecución, lo que ayuda a proteger la memoria frente a accesos indebidos.
• Direcciones lógicas: Los programas trabajan con direcciones lógicas (segmento +
offset), y el sistema operativo se encarga de mapearlas a direcciones físicas en la RAM.

2. Ejemplo Tecnológico Básico

Imagina un programa en C que maneja diferentes componentes:

1. Segmento de Código: Contiene las instrucciones del programa (funciones).

2. Segmento de Datos: Almacena variables globales y estáticas.
3. Segmento de Pila: Sirve para las variables locales y para el control de llamadas a
funciones (stack).

Cada uno de estos segmentos es de un tamaño distinto:

• El código puede ocupar 10 KB.

• Los datos pueden usar 5 KB.
• La pila (stack) puede ser dinámica y crecer o reducirse según las funciones anidadas.

El sistema operativo maneja una tabla de segmentos donde almacena la ubicación y

permisos de cada uno (código = solo lectura, datos = lectura/escritura, etc.). Así, si el
código intenta escribir en su propio segmento, se genera un error de protección.

3. Ejemplo de la Vida Real

Piensa en un edificio dividido en varias áreas con diferentes propósitos:

• Área A: Oficinas para tareas administrativas.

• Área B: Salas de reuniones.
 • Área C: Un comedor o cafetería.

Cada área es un segmento con un tamaño distinto (el comedor puede ser más grande
que las oficinas, por ejemplo). Además, cada área tiene permisos de acceso distintos: el
personal autorizado entra a oficinas, pero quizá no a la cocina. En informática, la
segmentación sigue la misma lógica: cada “área” (segmento) se maneja como un bloque
independiente con límites y permisos.

4. Ventajas y Desventajas
Ventajas

1. Protección y aislamiento: Cada segmento puede tener permisos específicos.

2. Organización lógica: Agrupa código, datos y pilas en áreas diferentes, lo que facilita la
depuración y mantenimiento.
3. Flexibilidad: Los segmentos pueden crecer o encogerse según las necesidades (aunque
se requiere suficiente espacio contiguo en memoria).

Desventajas

1. Fragmentación externa: Como los segmentos tienen tamaños variables, puede haber
trozos de memoria libres dispersos que no se aprovechan.
2. Complejidad: Administrar varios segmentos y actualizar sus tablas puede ser más
complicado que la paginación pura.

5. Segmentación Paginada (Visión General)

Para reducir la fragmentación externa y combinar las ventajas de la paginación
(tamaño fijo) y la segmentación (agrupación lógica), existe la segmentación paginada.
En este enfoque:

• El espacio de cada segmento (código, datos, etc.) se subdivide en páginas de tamaño

fijo.
• Se usa tanto una tabla de segmentos como una tabla de páginas para un mismo
proceso.

Esto brinda un equilibrio entre organización lógica (segmentos) y administración

eficiente de huecos (paginación).

Resumen

• Segmentación: Divide la memoria en bloques lógicos de distinto tamaño (segmentos).

 • Ejemplo tecnológico: Código, datos y pila de un proceso como segmentos
independientes.
• Ejemplo de la vida real: Dividir un edificio en áreas con distintos permisos y tamaños.
• Beneficios: Mejor organización, protección e identificación de elementos de un
programa.
• Retos: Puede provocar fragmentación externa y manejarse con mayor complejidad
que la paginación simple.

Este enfoque es clave en muchos sistemas operativos para proteger y gestionar la

memoria de forma flexible y segura.

A continuación, encontrarás una explicación detallada de la segmentación (y la

segmentación paginada) con definiciones, ejemplos básicos y puntos clave. Estos te
ayudarán a comprender cómo se gestiona la memoria en un sistema operativo y por
qué este enfoque es relevante en áreas como la administración de archivos en disco o la
organización de redes.

1. Segmentación: Definición y Objetivo

Segmentación es una técnica de administración de memoria en la que el espacio de
direcciones de un proceso se divide en bloques lógicos, llamados segmentos, de
diferente tamaño y con un propósito específico. Cada segmento puede representar,
por ejemplo, la sección de código de un programa, la sección de datos o incluso
archivos completos.

• Tamaño variable: A diferencia de la paginación pura, los segmentos no tienen un

tamaño fijo.
• Protección y aislamiento: Se pueden asignar permisos distintos para cada segmento,
impidiendo que un proceso acceda a segmentos de otros procesos.
• Direcciones lógicas: Para el proceso, cada segmento es una región independiente, y el
sistema operativo se encarga de mapear esas direcciones lógicas a direcciones físicas
en la RAM.

Ejemplo de Segmentación en Memoria

Escenario informático
Imagina un programa con tres grandes partes:

1. Código (instrucciones del programa).

2. Datos (variables globales, constantes, etc.).
3. Pila o stack (para variables locales, retorno de funciones).

En segmentación, cada parte se ubicaría en un segmento propio. Así, si el programa

necesita ampliar su pila por recursión profunda, se puede ajustar ese segmento sin
afectar necesariamente al segmento de datos o al de código. Además, los permisos de
acceso pueden ser diferentes: solo lectura para el código, lectura/escritura para datos,
etc.

Ventajas:

• Una estructura lógica clara: código, datos y pila están separados.

• Ayuda a la protección: el código no sobrescribe datos accidentalmente.

Desventajas:

• Puede provocar fragmentación externa (si un segmento necesita crecer, puede no

haber espacio contiguo suficiente).
• Mayor complejidad en la administración, pues el sistema operativo debe llevar una
tabla de segmentos y vigilar sus tamaños y ubicaciones.

2. Tipos de Segmentación
Aunque normalmente se habla de segmentación en el contexto de la memoria, también
hay segmentación en discos y redes. Cada una se basa en la misma idea de dividir un
recurso grande en secciones lógicas más pequeñas.

2.1. Segmentación de Memoria

• Divide el espacio de memoria física en segmentos de distintos tamaños.

• Cada segmento puede contener código, datos, librerías o cualquier bloque lógico que
el SO quiera aislar.
• Facilita el aislamiento de procesos, ya que cada uno obtiene sus propios segmentos
con permisos configurados.

Ejemplo simple: Un sistema que reserva un segmento de 10 MB para el sistema

operativo, otro de 5 MB para datos compartidos y otro de 2 MB para la cola de
impresión.

2.2. Segmentación de Disco

• Particiona el disco duro en varios volúmenes o particiones (segmentos).

• Cada segmento (partición) puede tener un sistema de archivos distinto o un propósito
específico (por ejemplo, una partición para el sistema operativo, otra para datos
personales, etc.).
• Facilita la organización, la copia de seguridad y la independencia de sistemas
operativos.

Ejemplo simple: Un disco de 500 GB segmentado en:

• Partición 1 (150 GB): Windows

• Partición 2 (100 GB): Linux
• Partición 3 (250 GB): Archivos de respaldo
2.3. Segmentación de Red

• Divide una red en subredes o segmentos más pequeños (subnets).

• Reduce el tráfico local y aumenta la seguridad, ya que cada segmento puede tener
reglas específicas de firewall.
• Permite una administración más sencilla y evita congestión en la red.

Ejemplo simple: Una empresa separa su red en:

• Segmento 1: Área administrativa

• Segmento 2: Departamento de desarrollo
• Segmento 3: Invitados (red Wi-Fi pública)

Cada segmento tiene políticas de acceso distintas.

3. Características de la Segmentación (Memoria)

1. Segmentos
o Regiones lógicas de memoria donde se guardan datos o código de un
programa.
2. Protección y Aislamiento
o Cada segmento puede tener permisos (lectura, escritura, ejecución).
o Evita que un proceso sobrescriba memoria de otro.
3. Direcciones Lógicas y Físicas
o El programa ve “direcciones lógicas” (segmento + offset).
o El SO traduce esto a direcciones físicas reales en la RAM mediante la tabla de
segmentos.
4. Fragmentación
o Interna: Ocurre si el segmento asignado es más grande de lo que se usa.
o Externa: Hay huecos dispersos de memoria que no se pueden usar
adecuadamente.
5. Tabla de Segmentos
o Estructura de datos del SO que indica el inicio, longitud y permisos de cada
segmento.
6. Paginación vs. Segmentación
o En paginación, la memoria se divide en páginas de tamaño fijo.
o En segmentación, los bloques (segmentos) tienen tamaño variable y
representan algo lógico (código, datos).
o Se puede combinar (segmentación paginada) para aprovechar lo mejor de
ambos enfoques.

4. Ventajas y Desventajas de la Segmentación

Ventajas
 • Protección y Aislamiento: Cada segmento puede configurarse con permisos
adecuados.
• Flexibilidad: Se asignan segmentos según las necesidades reales del programa (código,
datos).
• Facilita la compartición: Es fácil compartir un segmento entre varios procesos (por
ejemplo, una librería) sin usar memoria duplicada.

Desventajas

• Fragmentación Externa: Los segmentos de distintos tamaños generan huecos difíciles

de reutilizar.
• Complejidad: El SO mantiene la tabla de segmentos y debe encontrar espacios libres
de tamaño adecuado.
• Consumo de Recursos: Podría aumentar la sobrecarga del sistema al hacer un
seguimiento detallado de cada segmento.

5. Segmentación Paginada
Para disminuir la fragmentación externa y mantener la organización lógica de los
segmentos, surge la segmentación paginada. En este esquema:

• Cada segmento se divide adicionalmente en páginas de tamaño fijo.

• El SO mantiene una tabla de segmentos y, para cada segmento, una tabla de páginas.

1. Segmento: Región lógica (código, datos, etc.).

2. Páginas dentro de cada segmento: Bloques de tamaño fijo (por ejemplo, 4 KB).
3. Tablas de Segmentos: Define los segmentos (inicio, tamaño).
4. Tablas de Páginas: Para cada segmento, mapea las páginas virtuales a marcos físicos.
5. Marco: Bloque en la memoria física donde se almacena la página real.
6. Desplazamiento (Offset): Indica la posición dentro de una página.

Ventajas

• Se reduce la fragmentación externa (al usar páginas de tamaño fijo).

• Sigue habiendo cierta organización lógica (segmentos por tipo de datos).

Ejemplo sencillo

• Un segmento de 12 KB se divide en 3 páginas de 4 KB cada una.

• El SO mapea estas páginas a marcos disponibles en la RAM.
• Desde el punto de vista del programa, sigue siendo “un solo segmento”.

6. Ejemplo Práctico para la Memoria de un Proceso

Suponiendo un proceso que tiene:
 • Segmento 0: Código (20 KB)
• Segmento 1: Datos (10 KB)
• Segmento 2: Pila (5 KB)

En segmentación simple: El SO debe encontrar bloques contiguos de 20 KB, 10 KB y

5 KB. Si no hay contiguidad, se generan problemas de fragmentación.

En segmentación paginada:

1. Segmento 0 (código) se subdivide en páginas de 4 KB, lo que da 5 páginas (20 / 4 = 5).

2. Segmento 1 (datos) en 3 páginas (10 / 4 = 2.5, se redondea).
3. Segmento 2 (pila) en 2 páginas (5 / 4 = 1.25).
Luego el SO asigna cada página a marcos libres en la memoria física. No necesita que
esos 20 KB estén en un único bloque contiguo, lo que reduce la fragmentación
externa.

Conclusión
La segmentación es una técnica fundamental para organizar y proteger la memoria, al
dividir los procesos en regiones lógicas con distintos propósitos y tamaños. Sin
embargo, puede enfrentarse a la fragmentación externa y ser compleja de administrar.

Para superar estos obstáculos, se introduce la segmentación paginada, combinando la

idea de “segmentos lógicos” con la de “páginas de tamaño fijo”. Así, se disfruta de más
flexibilidad, seguridad y un mejor aprovechamiento de la memoria, disminuyendo la
fragmentación y permitiendo un control más detallado de las regiones de código y datos
dentro del sistema.