Try   HackMD

SOA: Ejercicios UD1

Mapa de memoria

Text section
Data section
BSS section

Memory management and allocation

Memory allocation schemes

Ejercicio 3

Tabla de un nivel

Tabla de dos niveles

Ejercicio 4

Ejercicio 5

Ejercicio EXAMEN Enero 2023

Sea un procesador Intel® IA-64 que proporciona un esquema de gestión de memoria que soporta paginación, con direccionamiento a nivel de byte y las siguientes características:

  • Paginación con dos niveles de indirección.
  • LEVEL-2 (Tabla de punteros de directorio (PDPT) en terminología IA64)
  • LEVEL-1 (PML4: Page Map Level 4 en terminología IA64)
  • El rango de direccionamiento de la memoria virtual es de 48 bits y de 52 para la memoria física.
  • Cada entrada de las diferentes tablas LEVEL-2(PDPTE) y LEVEL-1(PML4E) ocupa 64 bits. Entre otros, cada entrada contiene, además del marco del siguiente nivel, 4 bits de estado, los bits P, R, D, W. Cuando están activos, señalizan que la página está presente ( P ), ha sido referenciada ( R ), ha sido escrita (Dirty) y si está permitida la escritura (Write).

Con todo ello, se pide:

( a ) ¿Tamaño de la página?

( b ) ¿Cuántas páginas diferentes se pueden direccionar?

( c ) ¿Cuántos marcos de página se pueden direccionar?

( d ) ¿Tamaño en bytes del directorio de tablas de página?

( e ) Dada la dirección virtual 0x000056789ABC, indique los valores dedicados a selección de página y desplazamiento dentro de la página.

¿Tamaño de la página?
Hay 30 bits de offset: 1Gb

¿Cuántas páginas diferentes se pueden direccionar?
Hay 9+9 bits dedicados a la selección de página: 218 => 256K páginas

¿Cuántos marcos de página se pueden direccionar?
Hay 22 bits dedicados a la selección de marcos: 222 => 4MB marcos

¿Tamaño en bytes del directorio de tablas de página?
Hay 29 entradas, cada entrada ocupa 23 octetos. La tabla ocupa 212 bytes.

Dada la dirección virtual 0x000056789ABC, indique los valore dedicados a selección de página y desplazamiento dentro de la página.

El desplazamiento son los 30 bits más bajos. 5(0101b) 6789ABC

Página: 1
Desplazamiento: 16789ABC

Ejercicio EXAMEN Junio 2022

Ejercicio 1 (20 puntos / 45 minutos)

Un sistema operativo dispone de memoria virtual paginada con las características siguientes:

  • Un único espacio de memoria virtual de 4GB a compartir por todos los procesos que se creen
  • Una memoria principal de 2GB
  • Páginas de 4KB
  • Tabla de páginas de dos niveles con descriptores de página de 4 Bytes. Cada entrada de la tabla de páginas contiene, además del marco de página, 4 bits de estado, los bits P, R, D, W. Cuando están activos, señalizan que la página está presente §, ha sido referenciada ®, ha sido escrita (Dirty) y si está permitida la escritura (Write).
  1. ¿Que representan los valores A, B, C y D en el siguiente código?, ¿A qué secciones de memoria pertenecen? (3 puntos)
















#include <stdio.h> 
#include <stdlib.h> 

int y=1; 

int main(int argc, char *argv[]) 
{ 
    int  x = 100 * y; 

    printf("Dirección A : %p\n", (void *) &y); 
    printf("Dirección B : %p\n", (void *) main);
    printf("Dirección C : %p\n", (void *) &x); 
    printf("Dirección D : %p\n", (void *) malloc(1)); 

return x; 
}
  • A: localización de la variable “y”, sección de datos inicializados(DATA).
  • B: comienzo de la función main, sección de código (TEXT).
  • C: localización de la variable “x”, sección de pila (STACK).
  • D: solicitud de memoria dinámica, sección “heap” (HEAP).

Suponga ahora que se está ejecutando como único proceso el siguiente código:




























#include <stdio.h> 
#include <stdint.h> 

#define TAM_VECTOR 4096 
#define TAM_FILAS  1024 
#define NUM_FILAS     4 

float X[TAM_VECTOR];            // array con 4096 elementos 
float A[NUM_FILAS][TAM_FILAS];  // array bidimensional, 1024 elementos 
                                // por fila, 4 filas 
uint32_t n, x, y; 

void main()
{ 
    for(n = 0; n < TAM_VECTOR; n++)
    { 
        X[n] = (float)n; 
    } 

    for( y = 0; y < NUM_FILAS; y++)
    { 
        for( x = 0; x < TAM_FILAS; x++)
        { 
            A[y][x] = X[(y * TAM_FILAS) + x];  
        } 
    } 
}

Suponga también que el código cabe de forma completa en una única página virtual, por ejemplo, la 0x0000 que tiene asignado el marco 0x3000 y que los datos se ubican a partir de la página virtual 0x1000 en el orden en el que están declarados. Los elementos de los arrays X y A se almacenan de forma consecutiva. En el caso de A se almacenan por filas y en orden creciente del número de fila. Los números enteros (uint32_t) y en coma flotante (float) ocupan 4 bytes.

Con todo ello se pide responder, de forma razonada, a las cuestiones siguientes:

  1. Indique las páginas y direcciones virtuales de comienzo de los arrays A, X y la variable y. Indique también las direcciones virtuales de los siguientes datos: A[0,2], A[2,0] y X[128] (5 puntos)

    Comienzo A:

    Comienzo X:

    Localización y:

    A[0,2]:

    A[2,0]:

    X[128]:

  • Comienzo A: 0x00005000 -> página 5, el vector X ocupa las 4 primeras páginas (1, 2, 3 y 4)
  • Comienzo X: 0x00001000 -> página 1
  • Localización variable y: 0x00009008 -> página 9, desplazamiento 8, “n” y “x” ocupan los 8 primeros
  • A[0,2]: 0x00005008 -> Estamos en el tercer elemento de la primera fila, cada uno ocupa 4 octetos
  • A[2,0]: 0x00007000 -> Cada fila ocupa una página, estamos en la tercera
  • X[128]: 0x00001200 -> Elemento 128 decimal en la primera página, cada elemento ocupa 4 posiciones
  1. En el supuesto de que haya marcos libres suficientes para todas las páginas de datos referenciadas y que se asignan en orden creciente según se han declarado comenzando desde el marco 0x4000. Indique cuál será la serie de carga de páginas y los marcos asociados en memoria principal debido a la ejecución de dicho programa. Indique la cantidad de memoria no asignada debido a fragmentación interna. (5 puntos)



El vector X ocupa las páginas 1,2,3 y 4, el array bidimensional A ocupa otras 4 páginas, 5, 6 ,7 y 8. Las variables n, x e y estarían en la página 9

  • Vector X: Página 1 -> Marco 0x4000, Página 2 -> Marco 0x5000, Página 3 -> Marco 0x6000, Página 4 -> Marco 0x7000
  • Array A: Página 5 -> Marco 0x8000, Página 6 -> Marco 0x9000, Página 7 -> Marco 0xA000, Página 8 -> Marco 0xB000
  • Variables n, x e y: Página 9 -> Marco 0xC000

Las variables n, x e y ocupan 4 octetos cada una, 12 en total. Una página tiene una capacidad de 4096 octetos por lo que se pierden por fragmentación interna 4096 - 12 = 4084 octetos.

  1. En este caso, ¿Cuál sería la dirección real de comienzo de A[0,2], A[2,0], X[128]. (2 puntos)

    A[0,2]:

    A[2,0]:

    X[128]:

  • A[0,2]: 0x00008008 -> Estamos en el tercer elemento de la primera fila, cada uno ocupa 4 octetos
  • A[2,0]: 0x0000A000 -> Cada fila ocupa una página, estamos en la tercera
  • X[128]: 0x00004200 -> Elemento 128 decimal en la primera página, cada elemento ocupa 4 posiciones


  1. Suponga ahora que NO haya marcos libres suficientes para todas las páginas referenciadas y solo se han asignado 4 marcos de página para la ejecución de este programa y se utilizase el algoritmo de sustitución ÓPTIMO. ¿Cuáles serían las primeras 4 páginas asignadas al inicio del programa? ¿Cuál sería la cadena de referencia en los accesos a memoria por parte del programa? ¿Cuál sería la secuencia de reemplazo que se seguiría por parte del SO para asignar los marcos disponibles? (5 puntos)
Cadena de referencia Inicio                                                        
Marco 0                                                        
Marco 1                                                        
Marco 2                                                        
Marco 3                                                        
Page out                                                        

El programa copia el contenido del vector X en A, distribuyéndolo en 4 filas de 1024 elementos. X y A ocupan ambas 4 páginas. Para hacer la copia necesitamos las páginas de código, la página de datos origen, la página de datos destino y la página de las variables de control. Inicialmente serían las páginas: 0, 1, 5 y 9.

Página Estado
Código 0 Presente
X 1 Presente
X 2
X 3
X 4
A 5 Presente
A 6
A 7
A 8
Variables de control 9 Presente

Al finalizar la copia de la primera página de X, se accederá a la segunda página de X que deberá copiarse en la página 6 de A.

La página 2 no está presente. Viendo el código y aplicando un reemplazo optimo sabemos que ya no se accederá a la página 1 de X por lo que podríamos marcarla como no presente y reusar el marco asignado. Otra alternativa sería reemplazar la página 5, ya que tampoco se usará más. Ahora se copiarían datos a la página 6, para ello procedemos al reemplazo con la 5 ( o la 1 si en el caso anterior hubiéramos usado la 5). El estado de la tabla sería:

Página Estado
Código 0 Presente
X 1
X 2 Presente
X 3
X 4
A 5
A 6 Presente
A 7
A 8
Variables de control 9 Presente

Este proceso se repite para las cuatro páginas que ocupan X y A
Una posible secuencia sería:

Cadena de referencia Inicio Página 2 Página 6 Página 3 Página 7 Página 4 Página 8 Final
Marco 0 0 0 0 0 0 0 0 0
Marco 1 1 2 * 2 3 * 3 4 * 4 4
Marco 2 9 9 9 9 9 9 9 9
Marco 3 5 5 6 * 6 7 * 7 8 * 8
Page out 1 5 2 6 3 7
Last changed by 
 
dasilvin
0
766

Read more

PDI-2024: Symbolic debugging of a program.

Just because a program has no compilation errors does not mean that it works correctly. In case of malfunction, the program must be debugged to find the problem. Symbolic debugging allows to execute the program in a controlled way, step by step, stopping its execution and visualizing the value of the variables as we go along the program flow.

Feb 17, 2025
PDI-2024: P4 Solution

​

Dec 19, 2024
PDI-2024: Practice 4: TC/TM processing

Satellite instruments generate scientific data and other metadata onboard spacecraft. These data must be reliably and transparently transmitted to other computing systems in space or on Earth, which implies the need to encode and decode these data in a standardized and highly automated manner.

Nov 26, 2024
PDI-2024: Classroom exercises

Se desea obtener el tiempo de procesamiento de la función uint16_t calculaCRC( uint8_t datos[], uint32_t tam ); que realiza el cálculo del CRC 16 de un secuencia de datos.

Nov 20, 2024
Read more from dasilvin
Published on HackMD