procesos sistemas operativos. contenido procesos comunicación entre procesos problemas clásicos...
TRANSCRIPT
PROCESOS
SISTEMAS OPERATIVOS
CONTENIDO Procesos Comunicación entre procesos Problemas clásicos Planificación de un proceso Organización de procesos en MINIX
Multiprogramación
Un contador de programa
Cambio deproceso
Cuatro contadores de programa
tiempo
procesoA
BC
D
D
A B
BA
D
CC
(a) (b) (c)
Estados de un proceso
En ejecución
Bloqueado Listo
1. El proceso se bloquea en la entrada2. El planificador elige otro proceso3. El planificador elige este proceso4. La entrada se vuelve disponible
12
3
4
Estrato inferior de un sistema operativo
Procesos
Planificador
0 1 n-2 n-1...
El estrato inferior de un sistema operativo estructurado por procesos maneja las interrupciones y realiza la planificación. El resto del sistema consta de procesos secuenciales
Campos de la tabla de procesosManejo de los procesosRegistros
Contador de programa
Palabra de condición del programa
Apuntador de pila
Estado del proceso
Hora a la que el proceso inició
Tiempo usado de la CPU
Tiempo del derivado de la CPU
Hora de la siguiente alarma
Apuntadores de la lista de espera de mensajes
Bits de señal pendientes
Id del proceso
Diversos bits de señalización
tabla de procesos (continuación)Administración de la memoriaApuntador al segmento de texto
Apuntador al segmento de datos
Apuntador al segmento bss
Condición de la salida
Condición de la señal
Id del proceso
Proceso padre
Grupo de procesos
Uid real
Uid efectivo
Gid real
Gid efectivo
Mapas de bits de señales
Diversos bits de señalización
tabla de procesos (continuación)
Manejo de los archivosMáscara UMASK
Directorio raíz
Directorio de trabajo
Descriptores de los archivos
Uid efectivo
Gid efectivo
Parámetros de llamada al sistema
Diversos bits de señalización
Interrupciones
1. El hardware apila el contador de programa, etc.
2. El hardware carga el nuevo contador de programa a partir del vector de interrupción.
3. El procedimiento del lenguaje ensamblador guarda registros.
4. El procedimiento del lenguaje ensamblador forma una nueva pila.
5. El procedimiento C marca como listo el proceso de servicio de la interrupción.
6. El planificador decide que proceso ejecutar después.
7. El procedimiento C regresa al código ensamblador.
8. El procedimiento del lenguaje ensamblador da inicio al proceso corriente.
Condiciones de concurso
Director de programas decola de impresión
abc
prog.c
prog.h
out = 4
in = 7
Proceso A
Proceso B
4
5
6
7
Dos procesos desean acceder la memoria compartida al mismo tiempo.
Secciones críticas1. Nunca dos procesos pueden encontrarse
simultáneamente dentro de sus secciones críticas.
2. No se hacen suposiciones acerca de las velocidades relativas de los procesos o del número de CPU.
3. Ningún proceso suspendido fuera de su sección crítica debe bloquear a otros procesos.
4. Nunca un proceso debe querer entrar en forma arbitraria en su sección crítica.
SolucionesExclusión mutua con espera ocupada
Una forma de implementar la exclusión mutua es mantener ocupado a un proceso en un ciclo de espera mientras otro este en su sección crítica.
Desactivación de interrupciones
Si un proceso desactiva las interrupciones al entrar en su sección crítica, se evita que otro proceso pueda interrumpirlo y de esta manera se consigue la exclusión mutua. Esto puede ser conveniente para procesos del kernel pero no es adecuado para procesos del usuario.
Variable de cierre
Una posible solución es el uso de un cerrojo, este es una variable que vale 0 si se puede entrar en la sección crítica y 1 si no se puede. Sin embargo este esquema tiene el mismo defecto que el manejo de cola de impresión que se vio antes.
Soluciones (continuación)Alternación estricta
El siguiente código en C muestra una forma de obtener exclusión mutua. El proceso 0 inspecciona la variable turn y determina que es 0 entrando en su sección crítica. A continuación el proceso 1 inspecciona turn y permanece en el ciclo cerrado, una vez que termine el proceso 0 hará 1 la variable turn y el proceso 1 podrá entrar en su sección crítica. Este esquema tiene el defecto de fallar si los procesos transcurren a muy diferentes velocidades. En este caso se puede llegar a violar el principio 3 que se expresó antes.
Alternación estricta
while (TRUE) { while (TRUE) {
while(turn != 0)/* espera */; while(turn != 1)/* espera */; critical_secction(); critical_secction();
turn = 1; turn = 0;
noncritical_section(); noncritical_section();
} }
Solución de Peterson#define FALSE 0
#define TRUE 1
#define N 2 /* número de procesos */
int turn; /* a quién le toca? */
int interested[N]; /* todos los valores son inicialmente 0 (FALSE) */
enter_region(process)
int process; /* número de proceso: 0 o 1 */
{
int other; /* número del otro proceso */
other = 1 - process; /* opuesto del proceso */
interested[process] = TRUE; /* demuestra su interés */
turn = process; /* colocar señal */
while (turn == process && interested[other] == TRUE);/* espera ocupada */
}
leave_region(process)
int porcess; /* proceso que sale de la región crítica */
{
interested[process] = FALSE; /* indicar salida de la región crítica */
}
Solución con instrucción TSL
enter_region:
tsl register,flag ;copia la bandera en el registro y
hace la bandera igual a 1
cmp register,#0 ;¿fue cero la bandera?
jnz enter_region ;repetir hasta que sea cero
ret ;regresar al solicitante
leave_region:
move flag,#0 ;almacena cero en la bandera
ret ;regresa al solicitante
Sleep (bloqueo) y wakeup (desbloqueo)
Considérese una llamada sleep que hace que se bloquee el solicitante, y otra wakeup que desbloquea un proceso.
Considérese el problema del productor y el consumidor (o problema del buffer limitado).
Dos procesos comparten un buffer, el productor coloca información en el buffer y el consumidor, la extrae.
El productor#define N 100 /* número de ranuras en el buffer */
Int cout = 0; /* número de elementos en el buffer */
producer()
{
while (TRUE){ /* repetir indefinidamente */
produce_item(); /* generar el siguiente elemento */
if (count == N) sleep();/* si el buffer está lleno, bloquearse */
enter_item(); /* colocar un elemento en el buffer */
count = count + 1; /* incrementar conteo de elementos */
if (count == 1) wakeup(consumer); /* ¿estaba vacío el buffer? */
}
}
El consumidor
consumer()
{
while (TRUE){ /* repetir indefinidamente */
if (count == 0) sleep(); /* si el buffer está vacío, bloquearse */
remove_item(); /* sacar el elemento del buffer */
count = count - 1; /* disminuir conteo de elementos */
if (count == N - 1) wakeup(producer); /* ¿estaba lleno el buffer? */
consume_item(); /* imprimir el elemento */
}
}
Semáforos
Un semáforo es una variable entera que cuenta el número de desbloqueos guardados para uso futuro. Las operaciones para manejo de semáforos son down y up. La operación down verifica un semáforo y si es mayor que 0 lo decrementa (es decir, utiliza el desbloqueo almacenado) sino el procesos se bloquea. La operación up incrementa un semáforo. Si hay más de un proceso bloqueado por ese semáforo, se elige uno al azar para desbloquearlo, por tanto el semáforo seguirá siendo 0 pero habrá un proceso menos bloqueado en él.
Implantación de semáforos
#define N 100 /* número de ranuras en el buffer */
typedef int semaphore; /* los semáforos son un tipo especial de int */
semaphore mutex = 1; /* controla el acceso a la región crítica */
semaphore empty = N; /* cuenta ranuras vacías */
semaphore full = 0; /* cuenta ranuras completas */
Productor con semáforosproducer()
{
int item;
while (TRUE){ /* repetir indefinidamente */
produce_item(&item); /* generar el siguiente elemento */
down(empty); /* disminuir el conteo vacío */
down(mutex); /* entrar en región crítica */
enter_item(); /* colocar un elemento en el buffer */
up(mutex); /* salir de la región crítica */
up(full); /* incrementar ranuras completas */
}
}
Consumidor con semáforosconsumer()
{
int item;
while (TRUE){ /* repetir indefinidamente */
produce_item(&item); /* generar el siguiente elemento */
down(full); /* disminuir el conteo completo */
down(mutex); /* entrar en región crítica */
remove_item(); /* tomad un elemento del buffer */
up(mutex); /* salir de la región crítica */
up(empty); /* incrementar ranuras vacías */
consume_item(); /* hacer algo con el elemento */
}
}
Transmisión de mensajes
Este método hace uso de dos primitivas, send y recieve, las cuales son llamadas al sistema. La sintaxis es
send(destination, &message);
y
recieve(source, &message);
El primero envía un mensaje a un destino y el segundo recibe de una fuente. Si no está disponible un mensaje el receptor se bloquea.
Productor con mensajes#define N 100 /* número de ranuras en el buffer */
producer()
{
int item;
message m; /* buffer de mensajes */
while (TRUE) {
produce_item(&item);/*genera algún elemento para colocarlo en el buffer */
receive(consumer, &m); /* espera a que llegue uno vacío */
build_message(&m, item);/* construir un mensaje para ser enviado */
send(consumer, &m); /* enviar el elemento al consumidor */
}
}
Consumidor con mensajesconsumer()
{
int item, i;
message m;
for (i = 0;i < N; i++) send(producer, &m); /* envía N vacíos */
while (TRUE) {
receive(producer, &m);/* toma el mensaje que contiene el elemento */
extract_item(&m, &item;/* sacar el elemento del mensaje */
consume_item(item); /* hacer algo con el elemento */
send(producer, &m); /* devolver contestación vacía */
}
}
Buffer para mensajes
Buzones
Ranuras repletas
Ranuras vacias
Lista de esperade emisión
Lista de esperade recepción
Mensaje
Mensaje
2
S
Semáforos, uno por proceso
S Mutex
Ranuras repletas
Ranuras vacias
Lista de esperade emisión
Lista de esperade recepción
Mensaje
Mensaje
S S
El problema de los filósofos comensales
Cinco filósofos están sentados a una mesa circular.
Cada uno tiene un plato de espagueti especialmente resbaladizo.
El espagueti es tan resbaladizo que un filósofo necesita dos tenedores para comerlo.
Entre cada plato hay un tenedor.
Hora del almuerzo en el departamento de filosofía
Solución obvia
#define N 5 {número de filósofos}
philosopher(i)
int i {número del filósofo}
{
while(TRUE){
think(); /* el filósofo está meditando */
take_fork(i); /*toma el tenedor de la izquierda */
take_fork((i+1) % N); /*toma el tenedor de la derecha */
eat(); /* que rico espagueti */
put_fork(i); /*coloca el tenedor de la izquierda */
put_fork((i+1) % N); /*coloca el tenedor de la derecha */
}
}
Solución con semáforos
#define N 5 /* número de filósofos */
#define LEFT (i-1)%N /* número del vecino de la izquierda */
#define RIGHT (i-1)%N /* número del vecino de la derecha */
#define THINKING 0 /* el filósofo está meditando */
#define HUNGRY 1 /* el filósofo intenta tomar los tenedores */
#define EATING 2 /* el filósofo está comiendo */
typedef int semaphore; /* los semáforos son entero */
int state[N]; /* estados */
semaphore mutex = 1; /*exclusión mutua de regiones críticas */
semaphore s[N]; /* un semáforo por filósofo */
continuación
philosopher(i);
int i; /* número de filósofo, de 0 a N-1 */
{
while(TRUE) { /* repetir indefinidamente */
think(); /* el filósofo está meditando */
take_forks(i);/* toma los dos tenedores o se bloquea */
eat(); /* que rico espagueti */
put_forks(i); /* coloca los tenedores */
}
}
continuación
take_forks(i)
int i; /* número de filósofo, de 0 a N-1 */
{
down(mutex); /* meter en región crítica */
state[i] = HUNGRY; /* registrar el hecho de que el filósofo i tiene hambre */
test(i); /* intentar tomar los tenedores */
up(mutex); /* salir de la región crítica */
down(s[i]); /* bloquearse si no se tomaron los tenedores */
}
Continuación
put_forks(i)
int i; /* número de filósofo, de 0 a N-1 */
{
down(mutex); /* meter en región crítica */
state[i] = THINKING; /* el filósofo i termina de comer */
test(LEFT);/* ver si ahora puede comer el vecino de la izquierda */
test(RIGHT); /* ver si ahora puede comer el vecino de la derecha */
up(mutex); /* salir de la región crítica */
}
Continuación
test(i)
int i; /* número de filósofo, de 0 a N-1 */
{
if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {
state[i] = EATING;
up(s[i]);
}
}
El problema de los lectores escritores
El problema de los lectores escritores modela el acceso a una base de datos.
Imagínese una base de datos grande, como un sistema de reservación de líneas aéreas, con muchos procesos competidores que desean leerla y escribirla.
Es aceptable hacer que múltiples procesos lean la base de datos al mismo tiempo, pero si un proceso se encuentra escribiendo la base de datos, ningún otro proceso puede tener acceso a la base de datos, ni los lectores.
Soluciónreader()
{
while(TRUE){
down(mutex); /* obtener acceso exclusivo a ‘rc */
rc = rc + 1; /* ahora un lector más */
if(rc == 1) down(db); /* si éste es el primer lector… */
up(mutex); /* liberar el acceso exclusivo a ‘rc’ */
read_data_base(); /* acceder datos */
down(mutex); /* obtener acceso exclusivo a ‘rc’ */
rc = rc - 1; /* ahora un lector menos */
if(rc == 0) up(db); /* si éste es el último lector… */
up(mutex); /* liberar el acceso exclusivo a ‘rc’ */
use_data_base(); /* sección no crítica */
}
}
Continuación
writer()
{
while(TRUE){
think_up_data(); /* sección no crítica */
down(db); /*obtener acceso exclusivo */
write_data_base(); /* actualizar datos */
up(db); /* liberar el acceso exclusivo */
}
}
Planificación de un procesoRequisitos de un buen algoritmo de planificación
1. Imparcialidad: asegura que cada proceso tenga la parte que le corresponde de la CPU.
2. Eficiencia: mantener la CPU ocupada el 100% del tiempo.
3. Tiempo de respuesta: minimizar el tiempo de respuesta para usuarios interactivos.
4. Cambio de posición: minimizar el tiempo que los usuarios de un lote deban esperar para obtener la salida.
5. Rendimiento: Maximizar el número de trabajos que se procesan por hora.
Torneo
Proceso corriente
Siguiente proceso Proceso corriente
B
(a) (b)
FF D G A D G A B
(a) Lista de procesos ejecutables. (b) Lista de procesos ejecutables después de que se termina la cantidad de B.
Planificación por prioridad
Encabezados dela lista de espera
Procesos ejecutables
(Prioridad más alta)
(Prioridad más baja)
Prioridad 4
Prioridad 3
Prioridad 2
Prioridad 1
El primer trabajo más corto
8 4 4 4
A B C D
(a) (b)
84 4 4
AB C D
En la figura se muestran 4 trabajos A, B; C y D, con tiempos de ejecución de 8, 4, 4, y 4 minutos, respectivamente. Al ejecutarlos en ese orden, el tiempo de cambio de A es de 8 minutos, de B es de 12 minutos, de C es de 16 y de D es de 20 minutos, para hacer un promedio de 14 minutos. En la figura 17 (b) se muestran los trabajos en orden de primero el más corto, los tiempos de cambio de posición son 4, 8 , 12 y 20, para hacer un promedio de 11 minutos.
Planificación de dos niveles
a,b,c,d
e,f,g,h
a,b,c,d
e,f,g,h
b,cf,g
a,de,h
Procesosen la
memoria principal
Procesos
en disco
(a)(b) (c)
Planificación en MINIXMINIX se divide en 4 estratos. Los estratos tienen las siguientes funciones:
Estrato1:
Captura interrupciones y trampas
•planificador
•manejo de comunicación entre procesos mediante mensajes
Estrato 2:
•Procesos de E/S, uno por dispositivo: disco, terminal, reloj, sistema, etc.
Los estratos 1 y 2 forman el kernel del sistema.
continuación
Estrato 3:
•Manejador de memoria
•Sistema de archivos
La interpretación de la llamada al sistema ocurre en el nivel 3.
Estrato 4:
•Procesos de usuario: shell, editores, compiladores, aplicaciones, etc.
Diagrama de estratos de MINIX
Estrato
4
3
2
1
InicProceso
del usuario... Procesos del usuario
Procesodel usuario
Procesodel usuario
Adiminstradorde la memoria
Sistemade archivo
Tarea Tarea Tarea Tareadel disco tty del reloj del sistema
...
Manejo de los procesos
Procesos del servidor
Tareas de E/S
Proceso de carga de MINIX
El proceso de carga de minix sigue los siguientes pasos:
1. Al encender se carga un pequeño programa llamado el “cargador”.
2. El cargador coloca todo el sistema operativo en memoria y transfiere el control a Init.
3. Init lee /etc/ttys para conocer las terminales e inicia un proceso derivado/terminal por cada una de ellas.
4. El proceso derivado ejecuta /bin/login para esperar a que alguien entre al sistema.
5. Después de entrar /bin/login ejecuta un shell especificado en /etc/passwd (generalmente /bin/sh).
Mapa de memoria de MINIX
Máximo de 640KMemoria disponiblepara programasde usuario
Inic
Sistema de archivo
minix/tools/init
minix/fs/fs
Comúnmente de 70K a 100K, segúncuántos buffers de hayanincluido en el sistema de archivo
minix/mm/mmAdministrador de la memoria 40K
Tarea de la memoria
Tarea de la terminal
Tarea del disco
Tarea del reloj
Manejo de los procesos
minix/kernel/kernel
Vectores deinterrupción
25K (según el número de tareas de E/S)
1536 Inicio del kernel
0No se utiliza
Comunicación
La comunicación se realiza por medio de mensajes. Existen tres primitivas:
send(dest,&message); - envía un mensaje a dest
receive(source,&message); - recibe un mensaje de source
send_rec(src_dst,&message); - envía un mensaje a src_dst y espera respuesta del mismo
Los procesos pueden enviar y recibir mensajes de procesos o tareas en su mismo estrato y de aquellos que estén en el estrato localizado directamente debajo de él.
Cuando un proceso envía un mensaje y el destino no lo espera, el emisor se bloquea hasta que el destino efectúa un recieve (principio de cita).
Planificación en minix
MINIX utiliza una lista de espera para cada nivel de prioridad de proceso.
En cada nivel se sigue el algoritmo del torneo.
La cantidad que se le asigna a cada proceso es de 100 ms.