25-4-2025
Administración de Memoria Real de
Diferentes Sistemas Operativos
Unidad 3 - Administración de memoria
Instituto Tecnológico de Tepic.
Ingeniería en Sistemas Computacionales.
Sistemas Operativos
Maestra: Efraín Padilla Valera
Grupo 5 “A”
Ayala Gonzalez Jose Angel - 21400648
Duran Ocampo Luis Carlos - 23400531
Tabla de contenido
Introducción ........................................................................................................................................ 1
Desarrollo ............................................................................................................................................ 1
Linux ................................................................................................................................................ 1
Estructura General ...................................................................................................................... 1
Paginación ................................................................................................................................... 1
Administración de Estructuras de Datos ..................................................................................... 2
Reemplazo de Páginas................................................................................................................. 2
Swapping ..................................................................................................................................... 2
Herramientas y Monitoreo.......................................................................................................... 2
Windows.......................................................................................................................................... 3
Principios Generales de Administración de Memoria Real en Windows .................................... 3
Técnicas principales utilizadas .................................................................................................... 3
Protección de Memoria............................................................................................................... 4
Administración Multinúcleo y NUMA ......................................................................................... 4
Gestión de Memoria Baja............................................................................................................ 5
Unix ................................................................................................................................................. 5
Estructura de la memoria en Unix clásico ................................................................................... 5
Protección y control de acceso ................................................................................................... 5
Asignación de memoria ............................................................................................................... 6
El uso del swapping ..................................................................................................................... 6
Estructuras de datos utilizadas ................................................................................................... 6
Limitaciones y evolución ............................................................................................................. 6
Mach................................................................................................................................................ 7
Filosofía de diseño....................................................................................................................... 7
Representación de la memoria física .......................................................................................... 7
Asignación y liberación de memoria real .................................................................................... 8
Administración en entornos multiprocesador ............................................................................ 8
Optimización del uso de memoria real ....................................................................................... 8
Interacción entre memoria real y objetos de memoria .............................................................. 9
Conclusión ........................................................................................................................................... 9
Bibliografía ........................................................................................................................................ 10
Introducción
La memoria real, también conocida como memoria física, es el espacio de almacenamiento
principal con el que cuenta un sistema informático para ejecutar instrucciones y manejar datos de
los procesos en tiempo real. A diferencia de la memoria virtual, que puede incluir espacios de
almacenamiento en disco duro, la memoria real está compuesta exclusivamente por la RAM
(Random Access Memory) disponible en el sistema.
El correcto manejo de esta memoria es crucial para el rendimiento y estabilidad del sistema
operativo, ya que permite la asignación eficiente de recursos entre múltiples procesos. Para
lograrlo, los sistemas operativos implementan distintas técnicas de administración, siendo las más
comunes la paginación, la segmentación, o una combinación de ambas. Estas técnicas permiten
abstraer y optimizar el uso de la memoria física, asegurando que los procesos accedan de manera
segura y ordenada al espacio de direcciones que requieren.
Este informe explora cómo se lleva a cabo la administración de la memoria real en diferentes
sistemas operativos modernos, como Linux, Windows, Unix y Mach, basándose en fuentes
reconocidas como Modern Operating Systems de Andrew Tanenbaum y Operating System
Concepts de Abraham Silberschatz (9.ª edición).
Desarrollo
Linux
El sistema operativo Linux implementa un modelo sofisticado y eficiente para la administración de
la memoria real, que permite el manejo concurrente de múltiples procesos sin comprometer el
rendimiento del sistema. La memoria real en Linux está basada principalmente en la técnica de
paginación, complementada por otros mecanismos como la memoria virtual, gestión de cachés,
asignación dinámica de memoria y reemplazo de páginas.
Estructura General
Linux trata la memoria como una colección de páginas físicas del mismo tamaño, generalmente de
4 KB, aunque también soporta páginas grandes (huge pages) para optimizar el rendimiento en
aplicaciones que manejan grandes cantidades de datos. Estas páginas físicas forman bloques
llamados zonas de memoria, que se dividen según su finalidad:
ZONE_DMA: Para dispositivos que requieren acceso directo a memoria en un rango específico.
ZONE_NORMAL: Usada para la mayoría de las operaciones del sistema.
ZONE_HIGHMEM: Usada en sistemas de 32 bits cuando la RAM excede el límite direccionable
directo.
Paginación
La paginación es el núcleo de la administración de la memoria real en Linux. Consiste en dividir
tanto la memoria física como la virtual en bloques del mismo tamaño (páginas), y asignar páginas
virtuales de los procesos a marcos físicos de memoria mediante tablas de páginas.
Linux utiliza una estructura jerárquica de tablas de páginas, cuya profundidad puede variar
dependiendo de la arquitectura del procesador. Por ejemplo:
En arquitecturas x86 de 32 bits se utiliza una estructura de dos niveles.
En arquitecturas x86_64 (64 bits) se utiliza una jerarquía de cuatro niveles: PGD, PUD, PMD y PTE.
Cada entrada en estas tablas contiene la dirección del siguiente nivel o la dirección física final,
junto con bits de control (presente, lectura/escritura, acceso de usuario, etc.).
Administración de Estructuras de Datos
Linux mantiene varias estructuras de datos para rastrear y administrar la memoria:
struct page: Cada página física tiene una estructura page asociada que contiene información sobre
su uso actual (libre, asignada, en caché, etc.).
Buddy system: Se usa para la asignación y liberación eficiente de bloques contiguos de páginas.
slab/slub/slob allocators: Se utilizan para gestionar la asignación de pequeños objetos en el
kernel, optimizando la reutilización y minimizando la fragmentación.
Reemplazo de Páginas
Cuando no hay suficiente memoria libre, Linux debe elegir qué páginas remover de la memoria
real. Para ello, utiliza algoritmos de reemplazo de páginas inspirados en el algoritmo LRU (Least
Recently Used), aunque con optimizaciones:
Active list: Contiene páginas usadas recientemente.
Inactive list: Contiene páginas que no han sido usadas en un tiempo y que son candidatas para ser
liberadas o movidas al swap.
El kernel evalúa periódicamente estas listas y decide qué páginas pueden ser descartadas, escritas
a disco (si están modificadas), o simplemente reutilizadas.
Swapping
Linux también utiliza el mecanismo de swap, que permite mover páginas de memoria poco
utilizadas al disco duro (espacio de intercambio), liberando RAM para procesos más activos.
Aunque el uso excesivo de swap puede reducir el rendimiento, es esencial para mantener la
estabilidad cuando la RAM disponible es insuficiente.
Herramientas y Monitoreo
El sistema provee herramientas para monitorear y ajustar el uso de la memoria, tales como:
free, top, htop: Muestran el estado general de la memoria.
/proc/meminfo: Archivo del sistema que contiene estadísticas detalladas.
vmstat: Muestra estadísticas sobre memoria virtual y procesos.
Además, los administradores pueden ajustar ciertos parámetros mediante la interfaz
/proc/sys/vm/, como swappiness, que determina la propensión del sistema a usar swap.
Windows
La memoria real, también conocida como memoria principal o memoria física, es el espacio de
almacenamiento volátil que un sistema operativo utiliza directamente para cargar procesos, datos
y programas que están en ejecución. En el sistema operativo Windows, la administración de esta
memoria es un proceso crítico para asegurar un rendimiento eficiente, estabilidad del sistema y la
correcta ejecución de múltiples aplicaciones simultáneamente.
Principios Generales de Administración de Memoria Real en Windows
Windows utiliza una arquitectura de administración de memoria sofisticada, basada
principalmente en el concepto de páginas y marcos de página (page frames) de tamaño fijo. Cada
proceso tiene su propio espacio de direcciones virtuales, pero cuando hablamos estrictamente de
memoria real, nos referimos a cómo Windows gestiona los bloques físicos de memoria disponibles
en el hardware.
El sistema operativo mantiene una tabla de administración de memoria física conocida como PFN
Database (*Page Frame Number Database*), donde cada entrada corresponde a un marco de
página en la memoria real. Esta base de datos contiene información sobre el estado de cada
página, como si está libre, en uso, compartida, bloqueada, etc.
Técnicas principales utilizadas
1. Paginación
Aunque Windows implementa memoria virtual de forma extensiva, en lo que respecta a la
memoria real, sigue trabajando con paginación interna. Es decir, la memoria física se divide en
pequeñas unidades de tamaño fijo llamadas páginas (normalmente de 4 KB en arquitecturas
x86/x64).
El sistema mantiene:
• Páginas activas: actualmente utilizadas por procesos activos.
• Páginas libres: no asignadas a ningún proceso.
• Páginas de transición: páginas que están en proceso de ser liberadas o reasignadas.
El sistema operativo intenta mantener un equilibrio dinámico entre la cantidad de páginas libres y
usadas para asegurar que siempre haya memoria disponible para nuevos procesos.
2. Administración de listas de páginas
Windows organiza la memoria real en varias listas de páginas:
• Free List (Lista Libre): páginas disponibles para su asignación inmediata.
• Zeroed Page List (Lista de Páginas en Cero): páginas libres que han sido rellenadas con
ceros para seguridad (protección contra la exposición de datos residuales).
• Standby List (Lista en Espera): páginas no usadas activamente pero que aún contienen
datos válidos de procesos terminados o inactivos.
• Modified List (Lista Modificada): páginas que han sido alteradas y que deben escribirse en
disco antes de poder ser liberadas.
Este sistema de listas permite que Windows recicle eficientemente las páginas físicas sin necesidad
de asignar y liberar constantemente bloques de memoria, lo cual sería costoso en términos de
rendimiento.
3. Compromiso de memoria
Windows maneja un concepto llamado commitment o compromiso de memoria, que indica la
cantidad de memoria que el sistema garantiza que puede respaldar, ya sea en RAM real o en
espacio de intercambio (pagefile). Cuando hablamos estrictamente de memoria real, el
compromiso garantiza que una cantidad específica de RAM esté disponible para una aplicación
cuando lo requiera, aunque físicamente no se haya asignado aún.
4. Uso de Reservas de Memoria
Windows también utiliza reservas de memoria en memoria real para ciertas operaciones críticas
del sistema. Por ejemplo:
• El Nonpaged Pool (grupo no paginado): memoria que debe estar siempre en RAM, porque
el sistema o drivers pueden necesitar acceso inmediato a ella.
• El Paged Pool (grupo paginado): memoria que, aunque pertenece a componentes del
sistema, puede ser enviada a disco si es necesario.
Sin embargo, para acceso de bajo nivel, especialmente para controladores y operaciones de
hardware, el Nonpaged Pool es crítico porque garantiza que esas áreas de memoria estén siempre
presentes en la memoria real.
Protección de Memoria
Incluso en el manejo de la memoria real, Windows implementa protección de memoria. Cada
página física tiene atributos de acceso, como:
• Solo lectura
• Lectura y escritura
• Ejecución prohibida (*Data Execution Prevention*, DEP)
Estos atributos evitan que los procesos escriban en áreas de memoria no autorizadas o ejecuten
código malicioso en regiones protegidas.
Administración Multinúcleo y NUMA
En sistemas modernos con múltiples procesadores o arquitecturas NUMA (Non-Uniform Memory
Access), Windows optimiza el acceso a la memoria real mediante:
• Localización de memoria: intentando asignar memoria física más cercana al procesador
que ejecutará el proceso.
• Balanceo de memoria: redistribuyendo la carga de memoria entre distintos nodos de
memoria para evitar cuellos de botella.
Este tipo de administración asegura que el acceso a la memoria real sea lo más rápido posible,
aprovechando las características físicas del hardware.
Gestión de Memoria Baja
Cuando Windows detecta que hay poca memoria real disponible, activa mecanismos de
administración de memoria, como:
• Limpieza de páginas en standby.
• Liberación de cachés del sistema.
• Notificación a aplicaciones para liberar recursos.
• Invocación de políticas de priorización para decidir qué procesos reciben memoria.
Todo esto ocurre antes de recurrir al uso del archivo de paginación, ya que el objetivo principal es
maximizar el uso de la memoria real disponible.
Unix
La administración de memoria real fue uno de los aspectos fundamentales en el diseño de Unix
desde sus primeras versiones. Cuando Unix surgió a finales de los años 60 y principios de los 70, las
computadoras tenían capacidades de memoria extremadamente limitadas, por lo que una gestión
eficiente y segura de la memoria física era esencial para el funcionamiento del sistema.
En esta época, el concepto de memoria virtual aún no era utilizado de manera generalizada, por lo
que los desarrolladores de Unix tuvieron que diseñar técnicas que permitieran compartir y
proteger la memoria real entre varios procesos concurrentes.
Estructura de la memoria en Unix clásico
En los primeros sistemas Unix, la memoria real se dividía en dos grandes regiones: el espacio del
núcleo (kernel) y el espacio de usuario. El núcleo del sistema operativo siempre residía en
memoria, y ocupaba una región protegida que no podía ser accedida ni modificada por los
procesos de usuario.
Esta separación era estrictamente necesaria para mantener la estabilidad y seguridad del sistema,
ya que cualquier corrupción del espacio del núcleo podría llevar al fallo completo del sistema
operativo. Los procesos de usuario, por otro lado, disponían de su propio espacio de memoria
aislado, en el cual almacenaban su código, datos y pila de ejecución.
Protección y control de acceso
Para garantizar que los procesos de usuario no invadieran el espacio de memoria reservado para el
núcleo o para otros procesos, Unix utilizaba mecanismos de protección de memoria
proporcionados por el hardware. El sistema se basaba en el uso de un registro base y un registro
límite.
El registro base almacenaba la dirección de inicio de la memoria asignada a un proceso, mientras
que el registro límite indicaba la cantidad de memoria que el proceso podía utilizar. Cada acceso a
memoria realizado por un proceso era verificado automáticamente por el hardware: si la dirección
estaba fuera del rango permitido, se generaba una interrupción (trap) que transfería el control al
sistema operativo para tomar medidas, generalmente finalizando el proceso ofensivo.
Esta protección a nivel de hardware era esencial para implementar un sistema multiusuario
confiable, en el que múltiples programas pudieran ejecutarse simultáneamente sin interferirse
entre sí ni comprometer el sistema.
Asignación de memoria
La asignación de memoria en Unix se realizaba mediante un esquema de asignación contigua.
Cuando un nuevo proceso debía cargarse en memoria, el sistema operativo buscaba un bloque de
memoria física lo suficientemente grande como para contener todo el proceso completo,
incluyendo su código, datos y pila.
Este método tenía la ventaja de ser simple y eficiente cuando existía suficiente espacio libre. Sin
embargo, a medida que los procesos se creaban y destruían, la memoria libre podía fragmentarse
en pequeños bloques dispersos, lo cual dificultaba la carga de nuevos procesos. Esta situación,
conocida como fragmentación externa, representaba uno de los principales retos de la gestión de
memoria real.
El núcleo del sistema mantenía un mapa de memoria libre que registraba qué zonas estaban
disponibles y cuáles estaban ocupadas. De esta manera, cuando se requería memoria para un
nuevo proceso, se consultaba esta estructura para encontrar un espacio contiguo adecuado.
El uso del swapping
Dado que la cantidad de memoria física era muy limitada, Unix implementó muy temprano una
técnica llamada swapping para manejar la sobrecarga de procesos. El swapping consistía en
trasladar completamente un proceso fuera de la memoria principal hacia un espacio de
almacenamiento secundario en disco.
Cuando la memoria se saturaba, el sistema seleccionaba uno o varios procesos inactivos o de baja
prioridad para ser expulsados al disco, liberando así espacio para otros procesos que requerían
atención inmediata. Más adelante, cuando el proceso swappeado debía volver a ejecutarse, era
recargado nuevamente en la memoria.
Aunque el swapping permitía que el sistema aparentara soportar más procesos de los que cabían
físicamente en memoria, implicaba un coste considerable en términos de rendimiento, ya que el
acceso a disco era miles de veces más lento que el acceso a la RAM.
Estructuras de datos utilizadas
Para organizar y gestionar la memoria, Unix utilizaba diversas estructuras de datos internas. Una
de las más importantes era la tabla de procesos, donde se almacenaba información clave de cada
proceso, como su dirección base, su tamaño, su estado actual y su prioridad.
Otra estructura fundamental era el mapa de memoria libre, que permitía al sistema identificar qué
regiones de la memoria estaban disponibles para ser asignadas. Estas estructuras permitían una
administración relativamente eficiente y eran actualizadas constantemente conforme se creaban,
terminaban o swappeaban procesos.
Limitaciones y evolución
La administración de memoria real en Unix, aunque robusta y efectiva en su contexto histórico,
enfrentaba serias limitaciones. La fragmentación de memoria, el coste elevado del swapping y la
necesidad de cargar procesos completos en memoria limitaban la escalabilidad del sistema a
medida que se demandaban aplicaciones más complejas y sistemas con más usuarios simultáneos.
Estas limitaciones impulsaron el desarrollo posterior de técnicas más avanzadas, como la
segmentación y, más adelante, la paginación de memoria y el uso extensivo de memoria virtual,
que permitieron a Unix evolucionar hacia versiones mucho más eficientes y flexibles en entornos
con mayor carga de trabajo.
Sin embargo, la administración de memoria real en Unix sentó las bases de principios de diseño
que siguen vigentes hoy en día: protección estricta de espacios de memoria, separación clara
entre el núcleo y los procesos de usuario, y la necesidad de optimizar el uso de recursos limitados
para garantizar la estabilidad del sistema.
Mach
En el sistema operativo Mach, el manejo de la memoria real (es decir, la memoria física instalada
en la máquina) se diseñó para ser altamente eficiente, modular y flexible, en línea con los
principios generales del sistema. Mach introduce innovaciones importantes respecto a sistemas
anteriores, especialmente por su integración natural con arquitecturas multiprocesador y su
filosofía de microkernel, que exige que la memoria física sea gestionada de manera limpia y bien
controlada.
A diferencia de UNIX tradicionales, donde la memoria real estaba estrechamente ligada a
estructuras de procesos pesadas y manejos más rígidos, Mach planteó una separación clara entre
el hardware de memoria física y las abstracciones que se implementaban encima de él.
Filosofía de diseño
En Mach, la memoria real no se asigna directamente a procesos o tareas de manera estática o
rígida. En cambio, Mach trata la memoria física como un recurso del sistema que puede ser
asignado dinámicamente a medida que las tareas lo necesitan. Esta administración dinámica es
posible gracias a la organización basada en objetos de memoria y a la fuerte separación entre las
funciones del núcleo (microkernel) y las políticas de gestión de recursos.
El objetivo principal era ofrecer un sistema donde el núcleo fuera responsable solamente de las
operaciones básicas y de bajo nivel relacionadas con la memoria física, mientras que las políticas
más complejas (como qué páginas liberar o qué tareas priorizar) podían ser definidas y
modificadas en espacio de usuario.
Representación de la memoria física
Mach representa la memoria real mediante un conjunto de páginas físicas administradas dentro
del microkernel. Cada página física está descrita mediante una estructura de datos que indica su
estado: libre, asignada, sucia, en espera, bloqueada, entre otros atributos.
El núcleo mantiene listas de páginas que agrupan páginas físicas de acuerdo a su estado actual.
Por ejemplo:
• Lista de páginas libres: Contiene las páginas que actualmente no están asignadas a
ninguna tarea y están disponibles para su uso inmediato.
• Lista de páginas en espera o inactivas: Contiene páginas que pueden ser reutilizadas si la
presión de memoria lo exige.
• Lista de páginas bloqueadas: Contiene páginas que no pueden ser liberadas hasta que se
complete algún evento pendiente.
Esta clasificación permite que el sistema pueda rápidamente encontrar memoria física disponible
cuando una tarea lo necesita.
Asignación y liberación de memoria real
Cuando una tarea necesita memoria, Mach se encarga de asignar páginas físicas desde la lista de
páginas libres. La asignación puede ocurrir de dos formas:
• Asignación explícita: Cuando el kernel o un servidor de memoria solicita directamente
páginas físicas para su uso.
• Asignación por demanda: Cuando un acceso a una región de memoria causa un fallo de
página (page fault) y se necesita cargar datos en memoria real.
La liberación de memoria, por otro lado, sucede cuando:
• Una tarea termina su ejecución y libera los recursos asociados.
• Una región de memoria se marca como no necesaria.
• El sistema de gestión de memoria detecta que algunas páginas pueden ser desalojadas
para optimizar el uso de memoria.
Mach no recicla las páginas inmediatamente. En lugar de eso, implementa un modelo de retardo
controlado, manteniendo las páginas en espera durante un tiempo antes de liberarlas, para
mejorar el rendimiento del sistema ante accesos repetidos.
Administración en entornos multiprocesador
El soporte multiprocesador de Mach influye también en su administración de la memoria real.
Dado que múltiples CPUs pueden estar accediendo simultáneamente a estructuras de memoria, el
sistema debe garantizar la coherencia y sincronización.
Para esto, Mach utiliza:
• Locks (bloqueos finos): Para proteger las listas de páginas y estructuras internas
relacionadas con la memoria.
• Atomicidad en operaciones básicas: Algunas operaciones sobre el estado de una página
se implementan como operaciones atómicas para evitar inconsistencias en entornos
concurrentes.
La arquitectura permite que cada procesador tenga acceso eficiente a su propio subconjunto de
memoria libre cuando es posible, reduciendo la contención entre CPUs.
Optimización del uso de memoria real
Mach introduce también mecanismos de optimización del uso de memoria física, entre ellos:
• Clustering: Agrupamiento de páginas adyacentes en operaciones de lectura y escritura de
disco, para reducir la sobrecarga de transferencias pequeñas.
• Copy-on-write: Técnica mediante la cual múltiples tareas pueden compartir una misma
página física mientras no modifiquen su contenido. Solo cuando una tarea intenta escribir
en la página, se crea una copia privada para esa tarea, minimizando el uso de memoria.
• Reactivación selectiva: Páginas que fueron liberadas pueden ser rápidamente reactivadas
si son requeridas nuevamente en poco tiempo.
Estos mecanismos permiten que la memoria real se aproveche de forma mucho más eficiente que
en sistemas más tradicionales.
Interacción entre memoria real y objetos de memoria
Aunque aquí nos centramos en la memoria real y no en la virtual, es importante mencionar que
Mach introduce el concepto de objetos de memoria. Estos objetos abstractos permiten al sistema
asociar regiones de memoria real a representaciones más generales, como archivos, dispositivos, o
datos de red.
Cuando se necesita asignar memoria real a un objeto de memoria, Mach puede mapear páginas
físicas directamente, hacer copias diferidas (lazy copies) o gestionar el acceso concurrente a las
mismas páginas físicas entre varias tareas.
Esto muestra cómo la memoria real, aunque administrada de forma muy controlada en el núcleo,
se integra de manera flexible con otros servicios del sistema.
Conclusión
La administración de la memoria real es un componente fundamental para garantizar la eficiencia
y estabilidad de los sistemas operativos modernos. En sistemas como Linux, Windows, Unix y
Mach, se emplean diferentes estrategias y técnicas para manejar este recurso crítico, adaptándose
a las necesidades específicas de cada entorno. La paginación, la segmentación y la gestión
dinámica de la memoria son elementos comunes en estos sistemas, aunque cada uno implementa
sus propios métodos y optimizaciones para maximizar el rendimiento y la protección de la
memoria.
Linux, por ejemplo, se distingue por su enfoque en la paginación y el uso de herramientas
avanzadas para el monitoreo y ajuste de la memoria, mientras que Windows pone énfasis en una
organización compleja de las listas de páginas y el compromiso de memoria. Unix, en sus primeras
versiones, priorizó la protección y separación de memoria, aunque enfrentó limitaciones debido a
la fragmentación, lo que impulsó el desarrollo de nuevas técnicas. Por su parte, Mach, con su
arquitectura de microkernel y administración dinámica de memoria, representa un enfoque más
flexible y modular, adecuado para sistemas multiprocesador.
En conjunto, estos sistemas demuestran cómo la administración eficiente de la memoria real es
crucial para optimizar el rendimiento del sistema, proteger los procesos y garantizar la estabilidad,
especialmente en entornos con múltiples usuarios o recursos limitados.
Bibliografía
Moshel, A. (2024, 29 noviembre). Mysteries of the Windows Kernel Pt.3 — Memory Management
& Address Translation. Medium. https://medium.com/@amitmoshel70/mysteries-of-the-windows-
kernel-pt-3-memory-management-address-translation-
5c3501ac7723#:~:text=Previously%2C%20I%20mentioned%20a%20term,Descriptor%E2%80%9D%
20but%20instead%20for%20one
Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). Operating System Concepts (10th ed.) [Sample
pages]. Pearson Education.
https://ptgmedia.pearsoncmg.com/images/9780135462409/samplepages/9780135462409_Samp
le.pdf
Microsoft. (n.d.). !memusage (display memory usage information). Microsoft Learn.
https://learn.microsoft.com/en-us/windows-hardware/drivers/debuggercmds/-memusage
Windows-Driver-Content. (s. f.). Ejercicio 1: Identificación de procesos con grandes conjuntos de
trabajo. Microsoft Learn. https://learn.microsoft.com/es-es/windows-hardware/test/wpt/memory-
footprint-optimization-exercise-
1#:~:text=,conservan%20en%20el%20almacenamiento%20permanente
Windows-Driver-Content. (s. f.-b). Ejercicio 1: Identificación de procesos con grandes conjuntos de
trabajo. Microsoft Learn. https://learn.microsoft.com/es-es/windows-hardware/test/wpt/memory-
footprint-optimization-exercise-1
Moshel, A. (2024b, noviembre 29). Mysteries of the Windows Kernel Pt.3 — Memory Management
& Address Translation. Medium. https://medium.com/@amitmoshel70/mysteries-of-the-windows-
kernel-pt-3-memory-management-address-translation-
5c3501ac7723#:~:text=Standby%20Page%20List%20%E2%80%94%20Pages,Out%E2%80%9D%20i
nto%20the%20%E2%80%9CPage%20File%E2%80%9D
Silberschatz, A., Galvin, P. B., & Gagne, G. (2012). Operating system concepts (9th ed.). Wiley.
