Examen SO FDI UCM Feb-2021-B
Examen SO FDI UCM Feb-2021-B
Examen SO FDI UCM Feb-2021-B
0 1 2 3 4 5 6 7 8 9 10 11 12 13
EOF EOF 10 30 44 13 34 21 22 23 1 32 40 20
14 15 16 17 18 19 20 21 22 23 24 25 26 27
28 27 6 33 26 11 35 38 36 3 50 5 52 48
28 29 30 31 32 33 34 35 36 37 38 39 40 41
45 16 EOF EOF EOF 9 12 42 47 4 31 19 EOF 55
42 43 44 45 46 47 48 49 50 51 52 53 54 55
51 25 53 37 43 18 24 46 41 8 39 EOF 2 29
a) Represente esquemáticamente la misma situación de disco, pero suponiendo que, en vez de FAT, se
dispone de un sistema de ficheros tipo UNIX. En este sistema, la estructura del inodo está compuesta
por tres punteros directos, un puntero indirecto simple y un puntero indirecto doble.
b) Indique y explique el número máximo y mı́nimo de accesos a bloques de disco que se requieren para
leer todo el fichero Febrero2021.docx utilizando:
a) El sistema de asignación basado en FAT descrito inicialmente. Supóngase que el primer bloque
del directorio SO es conocido, y no hay ningún bloque de la FAT cargado inicialmente en
memoria.
enter_dock();
load_parcel(p);
// esperar a que el camión esté cargado
// notificar si cargado
delivery();
} }
} }
Los operarios (worker) repiten indefinidamente las acciones de coger un paquete (get parcel) y
cargarlo en el camión (load parcel). Varios operarios pueden estar cogiendo un paquete al mismo
tiempo, pero cargarán el camión de uno en uno. El hilo del operario sólo debe ejecutar la función
load parcel cuando haya algún camión en el muelle y quede sitio en dicho camión para el paquete.
Los camiones (truck) tiene capacidad para cargar NP paquetes, y repiten indefinidamente las acciones
de entrar al muelle (enter dock) para recoger la carga y salir al reparto (delivery). Varios hilos
de camión pueden estar ejecutando la función delivery al mismo tiempo. Sin embargo, en el muelle
sólo cabe un camión y por tanto el hilo que simula al camión debe esperar a que el muelle quede libre
para ejecutar la función enter dock en exclusiva. Asimismo, el hilo debe esperar a que el camión esté
completamente cargado para salir del muelle y empezar el reparto.
Completa las funciones truck y worker para que los hilos se sincronicen correctamente, añadiendo
las variables que consideres necesarias.
#define N 10
#define M 3
#define NP 10
mutex_t mtx;
cond_t space, loaded, dempty;
int dock_empty = 1;
int truck_space;
while (1) {
mutex_lock(&mtx);
while (!dock_empty)
cond_wait(&dempty, &mtx);
truck_space = NP;
dock_empty = 0;
cond_broadcast(&space);
enter_dock(id);
while (truck_space)
cond_wait(&loaded, &mtx);
dock_empty = 1;
cond_signal(&dempty);
mutex_unlock(&mtx);
delivery();
}
}
while (1) {
p = get_parcel();
lock(&mtx);
while (dock_empty || truck_space < 1)
cond_wait(&space, &mtx);
truck_space--;
load_parcel(id, p);
if (truck_space == 0)
cond_broadcast(&loaded);
unlock(&mtx);
}
}
A) Identificas problemas que puede presentar este algoritmo de planificación?. En caso afirmativo,
describirlos razonando la respuesta.
Completar el diagrama temporal, indicando también los procesos preparados que hay en cada una de las
colas. Al rellenar el diagrama temporal, se ha de usar el siguiente convenio:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
T1
T2
T3
T4
Q1
Q2
Q3
#include <stdio.h>
/* resto de includes */
pthread_create(&th1, NULL,
...
copyv,(void*) arg1);
pthread_create(&th2, NULL,
#define N 2048
copyv,(void*) arg2);
int A[N] = {0};
// Punto E
int *B;
pthread_join(th1, NULL);
pthread_join(th2, NULL);
void* copyv(void* arg);
// Punto F
for (i=0; i<N; i++)
int main(int argc, char* argv[])
printf("B[%i]=%i\n",i,B[i]);
{
// Punto G
int pid,i;
return 0;
pthread_t th1, th2;
}
int arg1[2], arg2[2];
void* copyv(void* arg)
// Punto A
{
for (i=0; i<N; i++)
int* params = (int*) arg;
A[i] = i+1;
int i;
// Punto B
for (i=params[0]; i <= params[1]; i++)
printf("Initialization was OK");
B[i] = A[i];
// Punto C
B=malloc(N*sizeof(int))
return NULL;
// Punto D
}
arg1[0] = 0; arg1[1] = N/2 - 1;
arg2[0] = N/2; arg2[1] = N-1;
Considerando que:
Las llamadas al sistema y el resto de funciones de librerı́a que se incluyen en el programa nunca
fallan.
Hay suficientes marcos de página libres en el sistema.
Todas las funciones externas se incluyen en una única biblioteca, donde no se definen variables
globales. Dicha biblioteca se enlazó de forma estática al crear el ejecutable.
La única sección de texto (código) presente en el ejecutable tras la compilación y enlazado estático
del programa ocupa 103KiB.
El contenido inicial de la pila al lanzar a ejecución el programa ocupa 128 bytes.
Un entero en C ocupa 4 bytes.
a. Identifique qué regiones lógicas (y su tamaño en páginas) constituyen la imagen de memoria del
proceso multihilo en los puntos marcados en el código como A, B, C, D, E, F y G.
b. ¿Cuántos fallos de página se producirán al pasar del punto A al punto B?. ¿Y del punto F al G?
Justifique sus respuestas.
Asumiendo que el proceso original tiene PID 100 (y es hijo de Init), se pide: