9 Ejercicios

1  En un sistema con memoria física de 64 Mbytes gestionada por segmentación,
comparar las alternativas de gestión del espacio libre (mapa de bits y lista de huecos
libres) en cuanto a eficiencia espacial. ¿Qué cambiaría si el sistema fuera segmentadopaginado, con páginas de 4 Kbytes?
2  Un sistema de memoria paginada tiene un espacio de direccionamiento lógico
de 1 Gbyte y páginas de 4 Kbytes. Para una memoria física de 64 Mbytes, calcular el
tamaño de la tabla de páginas, teniendo en cuenta que la memoria es direccionable a
nivel de byte.
3 El siguiente código forma parte de un sistema de gestión de memoria
paginado como el del Ejercicio 2. Se define una función ubicar(), que será llamada
desde ejecutar_programa, que reserva espacio en memoria para el proceso creado:
 int tablas_pag[NUM_PROCS][MAX_ENT_TP];
 int marcos_libres;
 int ubicar(int num_paginas, int num_proc)
 {
  int i, marco;
  entrar_SC(MUTEX_MEM);
  if (num_paginas > marcos_libres) { /*no hay espacio*/
   dejar_SC(MUTEX_MEM);
   return(-1);
  }
  marcos_libres= marcos_libres - num_paginas;
  dejar_SC(MUTEX_MEM);
  for (i=0; i<num_paginas; i++) {
   entrar_SC(MUTEX_MEM);
   marco= buscar_en_mapa_bits();
   poner_a_1_mapa_bits(marco);
   dejar_SC(MUTEX_MEM);
   tablas_pag[num_proc][i]= marco;

}
  for (i=num_paginas; i<MAX_ENT_TP; i++)
   tablas_pag[num_proc][i]= -1; /*páginas no usadas*/
  return(0);
 }
 (a) Definir MAX_ENT_TP. Si el sistema dedica 4 Mbytes de memoria para ubicar
las tablas de páginas, ¿cuál debe ser el valor de NUM_PROCS?
 (b) Programar la rutina liberar(num_proc), que libera los bloques ocupados por el
proceso num_proc. Utilizar funciones para acceso al mapa de bits.
4  Se pretende segmentar el sistema de memoria del Ejercicio 2 para que las
tablas de páginas no ocupen más de un marco de página.
(a) Dibujar el esquema de la traducción de direcciones, mostrando la estructura
de las direcciones virtual y física.
(b) ¿Cuántas entradas tendrá la tabla de segmentos? Calcular el tamaño mínimo de
cada entrada, teniendo en cuenta que las tablas de  páginas pueden estar
ubicadas en cualquier dirección.
(c) Tenemos cargados 100 procesos que ocupan toda la memoria, y cada proceso
tiene como media 3 segmentos. Calcular (c1) la fragmentación interna media por
proceso, (c2) la fragmentación externa total en el  sistema, y (c3) la pérdida de
eficiencia espacial en el sistema por fragmentación interna y externa.
(d) Si la gestión de marcos libres se hace por mapa de bits, ¿cuántos bytes ocupará
el mapa?
(e) ¿Qué parámetros se modificarían si se ampliase la memoria a 128 Mbytes?
5 El sistema del ejercicio anterior se gestiona con memoria virtual. A partir de
las siguientes definiciones,
struct ent_seg {
   int longitud;
   int *ptabla_pag;
 } tablas_seg[NUM_PROCS][NUM_SEG];
(a) Introducir las definiciones necesarias y/o modificar las existentes.
(b) Programar una función ubicar(num_proc) con prepaginación, que rellena
las tablas de páginas a partir de las entradas de longitud de la tabla de
segmentos correspondiente, que se supone que ya ha sido cargada. Nótese que
ubicar() no carga las páginas en memoria.

(c) Programar una nueva versión de ubicar(num_proc) que establece la carga
de páginas por demanda.
6  Se quiere introducir memoria virtual en un sistema paginado donde el tiempo
de acceso a memoria paginada es de 0,1 µs. El tiempo medio para tratar un fallo de
página en el nuevo sistema con memoria virtual se estima que será de 5 ms. Calcular
la probabilidad máxima de fallo de página para que  el tiempo medio de acceso a
memoria en el sistema de memoria virtual no se incremente en más de 20% con
respecto al del sistema paginado original.
7  En un sistema paginado de memoria virtual con 3 marcos de memoria física,
considerar la siguiente secuencia de referencias a páginas:
1  2  3  4  2  3  2  3  1  5  1  2  6  2  5  1  5  2  5  5  1  6  3  5  6
Indicar la sucesión de fallos de página y las páginas víctimas elegidas según se siga
un algoritmo de reemplazo óptimo, FIFO, LRU o Segunda Oportunidad.
8 A partir de las siguientes definiciones:
 struct ent_tab_pag {
  char bit_V;  /* bit de validez */
  int marco;
 } tab_pag[NUM_PROC][NUM_PAG];
 struct ent_marco {
  char bits;  /* MASK_R:referencia, MASK_M:modificado */
  int tick_carga;
  int proceso;
 } marco[NUM_MARCOS];
escribir una rutina int pag_victima(p) que devuelva el número de marco de la página
elegida como víctima para el proceso p (asignación local) siguiendo las políticas (a)
de la segunda oportunidad, (b) FIFO. Modificar (con ambos algoritmos) la rutina
pag_victima() para que la asignación de páginas sea global.
9  Según se ha observado en un sistema como el del Ejercicio 5 (basado en el del
Ejercicio 2), aparece thrashing cuando el grado de multiprogramación supera los 100
procesos. Calcular el tamaño mínimo del working set para evitar esta situación.