Sistemas Operativos. Grado Ingeniería Informática. TGR

Sistemas Operativos. Grado Ingeniería Informática.
TGR-2.1 Procesos. Noviembre 2014
Problemas para hacer en clase
1. Dos procesos A y B tienen una ráfaga de CPU de 50 ms y un proceso C tiene cuatro
ráfagas de CPU de 10 ms. intercaladas con tres ráfagas de E/S a disco de 30 ms. Los
procesos tiene el mismo tiempo de llegada con el orden C, A, B. Complete el diagrama de
planificación y calcule el tiempo de retorno promedio y el porcentaje de utilización de la
CPU y del disco bajo las políticas de planificación de la CPU FIFO (FCFS), Round-Robin
(RR) con quantum 50 ms. y RR con quantum 10 ms. y SRTF (Shortest Remaining Time
First). Recordad SRTF es la versión apropiativa en tiempo de llegada del SJF (Shortest Job
First), i.e., si un proceso que llega a la cola de procesos listos en ejecución tiene un tiempo
esperado de ejecución menor que el proceso en ejecución, el proceso que llega toma la CPU.
FIFO
cpu C
dsk
A
C
2. Conteste brevemente
-¿Bajo que condiciones el algoritmo de planifiación de procesos FIFO (FCFS) resultaría en el
tiempo de respuesta promedio más pequeño?
-¿Bajo que condiciones la planificación Round Robin se comporta igual que FIFO?
-¿Bajo que condiciones la planficación de procesos Round Robin se comporta peor que FIFO (en
tiempo de respuesta promedio)?
-En la situación anterior, si se reduce el quantum, ¿ayudaría o perjudicaría las prestaciones del RR
con respecto a FIFO?
-Un proceso CPU-bound (limitado por CPU) es un proceso que usa mucha CPU en relación a su
uso de E/S. La definición de proceso E/S-bound (limitado por E/S) es análoga. ¿Es la siguiente
afirmación verdadera o falsa?: Para un proceso CPU-bound es razonable darle más prioridad en las
operaciones E/S que a un proceso E/S-bound.
3. Considere los estados de los procesos: en ejecución (running), preparado o listo (ready),
bloqueado (blocked, waiting), bloqueado suspendido (blocked swapped out), suspendido
listo, exit (terminado). Para las siguientes situaciones diga que transición se produce en el
diagrama de estados.
-Se produce un evento por el que espera un proceso en memoria: E/S completa, despierta en un
semáforo, etc.:
-Un proceso comunica con otro proceso y tiene que esperar por el mensaje del otro proceso:
-Mediante una llamada al sistema un proceso requiere un recurso (por ejemplo un fichero o una
sección de memoria compartida) que no puede ser satisfecho inmediatamente por el sistema
operativo:
-Un proceso aborta:
-Un proceso termina normalmente:
-Se produce el evento que un proceso bloqueado en memoria secundaria estaba esperando:
-El proceso en ejecución necesita más memoria y el sistema operativo decide mover un proceso
bloqueado a disco
-Normalmente el sistema operativo preferiría suspender (intercambiar) un proceso bloqueado que
suspender un proceso listo ya que ambos están en memoria pero el bloqueado no está listo para
ejecución. De alguna razón para una transición Listo → Suspendido listo
-Algunos textos de SO muestran la transición Bloqueado suspendido → bloqueado, mientras otros
la ignoran. ¿Por qué?
4. El programa a.out tiene que ejecutar b.out y c.out que están en el directorio actual y tienen
que dar un mensaje de haber finalizado ambas ejecuciones. ¿Es correcta esta
implementación? En caso contrario proponer una alternativa.
#include
#include
#include
#include
#include
#include
<unistd.h>
<sys/types.h>
<errno.h>
<stdio.h>
<sys/wait.h>
<stdlib.h>
/*
/*
/*
/*
/*
/*
Symbolic Constants */
Primitive System Data Types */
Errors */
Input/Output */
Wait for Process Termination */
General Utilities */
int main()
{
pid_t pid;
if ((pid=fork()) == -1)
perror("fallo en
exit(0);
}
if (pid==0){
execl("./b.out",
}
else
execl("./c.out",
{
fork");
"b.out", NULL);
"c.out", NULL);
printf("Finalizados b.out y c.out");
return 1;
}
5. a) ¿Cuántas líneas de salida genera este programa? b) ¿Cual es el orden posible de esas
lineas?
#include
#include
#include
#include
#include
#include
#include
<unistd.h>
/* Symbolic Constants */
<sys/types.h> /* Primitive System Data Types */
<errno.h>
/* Errors */
<stdio.h>
/* Input/Output */
<sys/wait.h>
/* Wait for Process Termination */
<stdlib.h>
/* General Utilities */
<string.h> /* String utilities*/
void unix_error(char *msg)
{
fprintf (stderr, "%s: %s\n", msg, strerror(errno));
exit(0);
}
pid_t Fork(void)
{
pid_t pid;
if ((pid = fork()) < 0)
unix_error("Fork error");
return pid;
}
int main()
{
int status;
pid_t pid;
printf("Hello\n");
pid = Fork();
printf("%d\n", !pid);
if (pid != 0) {
if (waitpid(-1, &status, 0) > 0) {
if (WIFEXITED(status) != 0)
printf("%d\n", WEXITSTATUS(status));
}
}
printf("Bye\n");
exit(2);
}
Sistemas Operativos. Grado Ingeniería Informática.
TGR-2.2 Procesos. Noviembre 2014
Soluciones problemas a resolver por los estudiantes.
1. Considerar los siguientes procesos con los tiempos de llegadas, prioridades y ráfagas de cpu.
Proceso
Ráfaga de CPU
Prioridad
Tiempo llegada
1
50 ms
4
0 ms
2
20 ms
1
20 ms
3
100 ms
3
40 ms
4
40 ms
2
60 ms.
Muestra como se planifican estos procesos con los algoritmos Shortest Remaing Time First (SRTF),
Prioridades no Apropiativo (un valor más pequeño en la tabla indica más prioridad) y Round Robin
con quantum de 30 ms. SRTF es una versión apropiativa de SJF (Shortest Job First) donde si un
proceso que llega a la cola de procesos listos para ejecución tiene un tiempo esperado de ejecución
menor que el proceso en ejecución, el proceso que llega toma la CPU. ¿Cuál es el tiempo de espera
promedio para los distintos algoritmos y esta carga de trabajo? Cada celda representa 10ms.
Shortest Remaning Time First
1 1 2 2 1 1 1 4
4
4
4
3
3
3
3
3
3
3
3
3
3
P1 comienza pero es apropiado al llegar P2 (a los 20 ms) porque P2 tiene una ráfaga de 20,
menor que los 30 ms que quedan a P1. P2 se ejecuta hasta completarse. A los 40 ms llega P3
pero tiene una ráfaga (40 ms) mayor que lo que queda a P1 por completar, de forma que P1
toma de nuevo la CPU, después P4 toma la CPU y completa y finalmente lo mismo con P3.
Tiempo medio de espera: (20 + 0 + 70 + 10)/4 = 25 ms.
Prioridades no apropiativas
1 1 1 1 1 2 2
4
4
4
4
3
3
3
3
3
3
3
3
3
3
P1 comienza porque es el único que está en la cola de proceso listos para ejecución, a los 20 ms
llega P2, que es el proceso de más prioridad, pero el algoritmo no es apropiativo con lo que no
puede tomar la CPU hasta que P1 se completa. Cuando acaba P2, en la cola están P4 y P3 y se
ejecuta primero P4 porque tiene más prioridad.
Tiempo medio de espera: (0 + 30 + 70 + 10)/4 = 27.5 ms.
Round Robin de quantum 30 ms.
1 1 1 2 2 1 1 3
3
3
4
4
4
3
3
3
4
3
3
3
3
P1 llega primero y consigue 30 ms de CPU. En ese momento P2 está en la lista de preparados
de forma que se apropia de la CPU y se ejecuta durante 20 ms y termina. Observe que P3
habrá llegado a la cola cuando P2 acaba pero se habrá puesto después de P1 por lo que P1
toma la CPU de nuevo y se completa su ejecución. En ese momento P4 habrá llegado a cola de
preparados pero se habrá puesto en esta cola después de P3, por lo que P3 toma la CPU y P3 y
P4 se alternan en CPU hasta que acaban.
Tiempo medio de espera: (20 + 10 + 70 + 70)/4 = 42.5 ms.
2. a) ¿Qué salida genera el proceso hijo? b) ¿Qué salida genera el proceso padre?
int main()
{
int x=1;
if (Fork()==0)
printf("printf1: x=%d\n", ++x);
printf("printf2: x=%d\n", --x);
}
El hijo ejecuta ambos printf:
printf1: x=2
printf2: x=1
El padre sólo el printf2:
printf2 x=0
3.¿Qué posibles salidas genera el siguiente programa?
int main()
{
if (Fork()==0) {
printf("a");
}
else {
printf("b");
waitpid(-1, NULL, 0);
}
printf("c");
exit(0);
}
El padre imprime b y luego c. El hijo imprime a y luego c (en el caso de que el fork no falle, si
el fork fallase sólo el padre puede imprimir bc). Pero no se puede suponer nada acerca de
como se entrelaza la ejecución del padre y el hijo, por lo que en principio todas estas salidas
son posibles: acbc, bacc, abcc.