Dado los siguientes procesos, con el tiempo de consumo de CPU expresado en
milisegundos, determinar el tiempo de espera para cada proceso para los algoritmos
FCFS y primer trabajo más corto. Los procesos arribaron en el instante 0 en el orden
P1,P2,P3,P4,P5. Luego, determinar el tiempo de espera promedio para cada algoritmo
(T exp).
Proceso Tiempo T(esp) FCFS (FIFO) T(esp) Primero el trabajo más
de CPU corto (SJF)
P1 10 0 0
P2 29 10 3
P3 3 39 10
P4 7 42 20
P5 12 49 32
T(esp) T(esp) = 28 T(esp) = 13
Una computadora tiene 4 marcos de páginas, A continuación se presenta una tabla con
las páginas en c/u de los marcos, el tiempo de carga(TC), el tiempo del último acceso
(TUA) y los bits R y M de cada página (los tiempos se expresan en pulsos de reloj). Se
necesita un marco libre para cargar una página. Indicar cuales son las posibles páginas
que reemplazaría el algoritmo NRU (marcar todas las posibles):
Página TC TUA M R NRU
0 115 271 1 1
1 213 275 1 0 X
2 120 268 1 0 X
3 170 285 0 1
La siguiente tabla muestra el tamaño máximo de las particiones con tamaño de bloque
2KB, determinar el valor de las incógnitas x1, x2 y x3. Justificar los cálculos realizados.
Tamaño del bloque FAT-X1 FAT-16 FAT-32 (Solo se
ocupan 28 bits)
X2 KB 16 MB 256 MB X3 MB
Obtención de X2 → Ya que la columna 3 ofrece datos de tamaño de partición y bits de la
FAT.
tamañoParticion = cantidadMaximaEntradas * tamañoBloque
256 [MB] = 2^16 * X2 [KB]
X2 = 256 [MB] / 2^16 = 268435456 bytes / 2^16 = 4096 bytes = 4 [KB]
Tamaño del bloque FAT-X1 FAT-16 FAT-32 (Solo se
ocupan 28 bits)
4 [KB] 16 MB 256 MB X3 MB
Con el tamaño de bloque como dato se puede calcular X1 (bitsFAT):
16 [MB] = 2^X1 * 4 [KB]
16777216 / 4096 bytes = 2^X1
4096 bytes = 2^X1
X1 = log_2(4096) = 12
Tamaño del bloque FAT-12 FAT-16 FAT-32 (Solo se
ocupan 28 bits)
4 [KB] 16 MB 256 MB X3 MB
Por último, para calcular X3 (tamaño de partición):
X3 = 2^28 * 4[KB] = 1073741824 [KB] = 1048576 [MB] = 1024 [GB] = 1 [TB]
Tamaño del bloque FAT-12 FAT-16 FAT-32 (Solo se
ocupan 28 bits)
4 [KB] 16 MB 256 MB 1 [TB]
¿Cuántas entradas como máximo posee la FAT en cada uno de los casos?¿Cuál es el
tamaño máximo de la FAT? Justificar los cálculos.
FAT-12 FAT-16 FAT-32 (Solo se ocupan 28
bits)
Número (2^12, 4096) (2^16, 65536) (2^28, 268435456)
máximo de
entradas
en la FAT
Tamaño TMFAT = 4096 bytes * 12/8 TMFAT = 65536 bytes * TMFAT = 268435456 bytes *
máximo de 16/8 32/8
la FAT TMFAT = 4096 * 1,5 bytes
TMFAT = 65536 * 2 bytes TMFAT = 268435456 * 4 bytes
Rellenar la estructura de datos sabiendo que el archivo H ocupa los bloques 7, 9 y 8
sucesivamente y el archivo B solo ocupa el bloque 6
B Dat 6
H Dat 7
Raíz
E: EOF
E 9 E 8
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
En un S.O. con paginación y algoritmo de envejecimiento se produce un fallo de página.
Las páginas que están usando marcos de página son las que se muestran en la tabla
con sus “edades” de 8 bits correspondientes. ¿Cuál es la página que debería removerse
y cuál es la nueva edad de las páginas después del fallo?
Página Bit Edad antes del Edad después Página a
R fallo del fallo remover
1 0 01010101 00101010 X
2 1 00110011 10011001
3 0 10101010 01010101
4 1 11001100 11100110
Algoritmo de Envejecimiento
En un sistema que tiene 8 páginas de direccionamiento virtual y 4 marcos, resolver
cuantos fallos de página se producen utilizando el algoritmo LRU para la siguiente
cadena de referencias.
1 3 5 7 5 3 6 8 7 6 4 1 3 4
1 1 3 5 7 5 3 6 8 7 6 4 1 3 4
2 1 3 5 7 5 3 6 8 7 6 4 1 1
3 1 3 3 7 5 3 6 8 7 6 4 3
4 1 1 1 7 5 3 3 8 7 6 6
5 1 7 5 5 3 8 7 7
6 1 1 1 5 3 8 8
7 1 5 5 5
F F F F F - - F F F - F F F -
10 FALLOS DE PÁGINA
El archivo FILEA.DAT utiliza los bloques 1, 3 y 5 sucesivamente y el archivo FILEB.DAT
utiliza los bloques 2, 4 y 6
FILEA.DAT: 1, 3 y 5
FILEB.DAT: 2, 4 y 6
1 3
2 4
3 5
4 6
5 EOF
6 EOF
7
Llegan solicitudes en disco al manejador del disco de los cilindros 10, 22, 20, 2, 40, 6 en
ese orden. El brazo está inicialmente en el cilindro 20 (bajando). ¿Cuáles son las
secuencias de movimientos? ¿Cuántos movimientos son necesarios utilizando el
algoritmo:
Secuencia Movimientos
20 - 10 = 10
22 - 10 = 12
22 - 20 = 2
FIFO (FCFS) 10 22 20 2 40 6
20 - 2 = 18
40 - 2 = 38
40 - 6 = 34
MOVIMIENTOS = 114
20 - 20 = 0
22 - 20 = 2
22 - 10 = 12
Primero el más cerca (SSTF) 20 22 10 6 2 40
10 - 6 = 4
6-2=4
40 - 2 = 38
MOVIMIENTOS = 60
20 - 20 = 0
20 - 10 = 10
10 - 6 = 4
Ascensor (Scan-Ascensor) 20 10 6 2 22 40
6-2=4
22 - 2 = 20
40 - 22 = 18
MOVIMIENTOS = 56
Determinar el rendimiento
Con multiprogramación:
(CPUA + CPUB)/MAX(TIEMPOAB) * 100 = (5+3)/9 * 100 = 8/9 * 100
= 0,88 * 100 = 88% de uso del CPU
Completar considerando la siguiente situación en el sistema
Matriz Asignación Máximos Disponibles
A B C D A B C D A B C D
0 0 1 2 0 0 1 2 1 5 2 0
1 0 0 0 1 7 5 0
1 3 5 4 2 3 5 6
0 3 3 2 0 6 5 2
0 0 1 4 0 6 5 6
a) ¿Cuál es el contenido de la matriz Necesidad?
Matriz Necesidad
A B C D
0 0 0 0
0 7 5 0
1 0 0 2
0 0 2 0
0 6 4 2
b) ¿En qué estado se encuentra el sistema?
El sistema está en estado seguro
El sistema está en estado inseguro
El sistema está bloqueado
Ninguno de los estados mencionados
c) Si llega una solicitud del proceso P1 de (0,4,2,0) ¿Puede atenderse de inmediato la solicitud?
Sí, porque hay suficientes recursos
disponibles (1,5,2,0)
No, porque el sistema evolucionará a un
estado inseguro
Sí, porque el sistema evolucionará a un
estado seguro
No, porque el sistema se bloquea
Ninguno de los estados mencionados
Completar el código del productor consumidor con semáforos
#define N 100
typedef int semaforo;
semaforo mutex = 1;
semaforo vacias = N;
semaforo llenas = 0;
void productor(void) {
int elemento;
while(TRUE){
elemento = producir_elemento();
down(&vacias);
down(&mutex);
insertar_elemento(elemento);
up(&mutex);
up(&llenas);
}
}
void consumidor(void) {
int elemento;
while(TRUE){
down(&llenas);
down(&mutex);
elemento = quitar_elemento();
up(&mutex);
up(&vacias);
consumir_elemento(elemento);
}
}
Completar el código de enter_region y left_region de la instrucción TSL.
Rx: registro de la CPU
Flag: variable en memoria.
JNZ: salte si es distinto de 0.
JZ: salte si es 0.
enter_region:
TSL Rx, flag
CMP Rx, #0
JNZ enter_region
RET
left_region:
MOVE flag, #0
RET
#define N 100
event_counter in = 0;
event_counter out = 0;
productor(){
int item, seq = 0;
while (TRUE){
producir_item(&item);
seq = seq + 1;
await(out, seq-N);
inserta_item(item);
advance(in);
}
}
consumidor(){
int item, seq = 0;
while (TRUE){
seq = seq + 1;
await(in, seq);
remove_item(item);
advance(out);
consumir_item(item);
}
}
Swapping. Completar
1: Ready, Suspend
2: Ready
3: Blocked, Suspend
4: Blocked
Dada la siguiente jerarquía de procesos en UNIX donde los ejecutables son todos
programas distintos:
¿Cuántos procesos ejecutaron fork? 2
¿Cuántos fork() se ejecutaron? 5
¿Cuántos procesos ejecutaron exec()? 6
(considera al proceso A que ya está en
ejecución)
¿Cuántos exec() se ejecutaron? (considera 6
al proceso A que ya está en ejecución)
