Tema 4: Gestión de procesos Capítulo 4: Gestión de procesos Procesos Procesos ligeros (threads) Políticas y algoritmos de planificación Señales y excepciones Temporizadores Servidores y demonios Servicios POSIX 1
Procesos Concepto p de Proceso Multitarea Información del proceso (BCP) Creación de procesos Terminación de procesos Estados de los procesos Cambio de contexto Planificación Concepto de proceso I PROGRAMA: Archivo ejecutable en un dispositivo de almacenamiento permanente (ej. disco) PROCESO: Un programa en ejecución, reside en MP y según se ejecuta modifica su contexto Desde el punto de vista del usuario: código + estructuras de datos El sistema operativo le asigna recursos y controla su ejecución Desde el punto de vista del sistema operativo: Técnicas de multiplexado (planificación) Caracterización de un proceso: tabla o bloque de control de procesos (BCP). En Linux: task_struct Cada proceso posee un espacio de direccionamiento virtual Independiente 2
Jerarquía de procesos Jerarquía de procesos Proceso hijo Proceso padre Proceso hermano Proceso abuelo Vida de un proceso Crea Ejecuta Muere o termina Ejecución del proceso Batch Interactivo Grupo de procesos Árbol típico de procesos en Solaris Entorno del proceso Tabla NOMBRE-VALOR que se pasa al proceso en su creación Se incluye en la pila Se establece: Por defecto (se copia la del padre) Mediante mandatos del shell (export) Mediante API del SO (putenv, getenv) Ejemplo: PATH=/usr/bin:/home/pepe/ :/home/pepe/bin TERM=vt100 HOME=/home/pepe PWD=/home/pepe/libros/primero TIMEZONE=MET 3
Conceptos Usuario: Persona autorizada a utilizar un sistema Se identifica en la autenticación mediante: Código de cuenta Clave (password) Internamente el SO le asigna el uid (user identification) Super-usuariousuario Tiene todos los derechos Administra el sistema Grupo de usuarios Los usuarios se organizan en grupos Alumnos Profesores Todo usuario ha de pertenecer a un grupo Bases de la Multiprogramación Paralelismo real entre E/S y UCP (DMA) Alternancia en los procesos de fases de E/S y de procesamiento La memoria almacena varios procesos Procesamiento Entrada/salida Tiempo 4
Ejemplo de ejecución en un sistema multitarea. Proceso nulo Proceso A Proceso B Proceso C Procesador Procesamiento Entrada/salida Listo SO Proceso nulo Tiempo Estados de los procesos: ejecución, bloqueado, listo Conceptos Multitarea: varios procesos activos a la vez Multiusuario: soporta varios usuarios en varias terminales Tiempo compartido: reparto equitativo del tiempo de CPU entre varios usuarios Planificador (sheduler): seleciona el siguiente proceso a ejecutar Activador (dispacher): Prepara la ejecución del proceso planificado -> cambio de contexto Grado de multiprogramación: nº de procesos activos Con BCP vigente Necesidades de memoria principal: Memoria virtual 5
Ventajas de la multitarea Facilita la programación, dividiendo los programas en procesos (modularidad) Permite el servicio interactivo simultáneo de varios usuarios de forma eficiente Aprovecha los tiempos que los procesos pasan esperando a que se completen sus operaciones de E/S Aumenta el uso de la CPU Concepto de proceso II INFORMACIÓN DEL PROCESO (BCP): Imagen de memoria (core image) Estado del procesador (registros del modelo de programación) Bloque de control del proceso BCP Estado actual del proceso Identificación pid, ppid Uid Uid, gid. euid,egid Prioridad del proceso Registros de procesador cuando el proceso no está en ejecución Puntero a la zona de memoria: Segmentos de memoria Recursos asignados: Ficheros abiertos, Temporizadores, Señales, Semáforos, Puertos Un puntero al siguiente BCP 6
Memoria de un proceso Contexto de usuario Contexto del nucleo Pila FFFF Registros especiales Heap Datos Texto 0000 Registros generales PC SP Estado Process Control Block (PCB) Planificación y estado Id de proceso y padre uid,guid, euid, egid puntero de pila registros CPU descripción de la memoria recursos asignados punteros para formar listas señales, mensajes, 7
El SO mantiene estructuras de datos asociadas a los procesos Mapa de memoria del Proceso A Mapa de memoria del Proceso B Mapa de memoria del Proceso C Tablas SO Mapa de Memoria Tablas del sistema operativo Tabla de procesos BCP Proceso A BCP Proceso B BCP Proceso C - Estado (registros) - Estado (registros) - Estado (registros) - Identificación - Identificación - Identificación - Control - Control - Control - Tabla de memoria - Tabla de E/S: drivers de bloques, de caracteres - Tabla de ficheros, de montajes Tablas del sistema operativo Tabla de procesos (tabla de BCP) Tabla de memoria: información sobre el uso de la memoria. Tabla de E/S: guarda información asociada a los periféricos y a las operaciones de E/S Tabla de fichero: información sobre los ficheros abiertos. C i i i l i i f ió l BCP Criterios para incluir o no una información en el BCP: Eficiencia Compartición 8
Información fuera del BCP Se considera del BCP Por eficiencia: Tabla de páginas Describe la imagen de memoria del proceso en sistemas con MV Tamaño variable -> El BCP contiene el puntero a la tabla de páginas (La compartición de memoria requiere que sea externa al BCP) Por compartición: Punteros de posición de los ficheros En la tabla de ficheros abiertos del BCP no se pueden compartir Si se asocian al nodo-i se comparte siempre Se ponen en una estructura común a los procesos y se asigna uno nuevo en cada servicio OPEN Memoria Virtual de un proceso Memoria virtual it Código RIED Memoria principal Datos Pila Tamaño Tabla de páginas Una tabla de páginas ái por proceso Disco Preasignación de zona de intercambio: Todas las páginas están en disco, algunas están copiadas en marcos de página. La información de traducción está en la tabla de páginas 9
Creación de procesos I Mapa de memoria Tabla de procesos Objeto ejecutable Bib lio te c a sistem a Cargador Imagen del proceso BCP Creación de procesos II El proceso padre crea un proceso, que a su vez, crea otros procesos, formando un árbol de procesos Esquemas de compartición de recursos: A. El padre y el hijo comparten todos los recursos B. El hijo comparte unsubconjunto de los recursos del padre C. El padre y el hijo no comparten recursos Ejecución El hijo comparte un subconjunto de los recursos del padre El padre espera hasta que el hijo termine 10
Creación de procesos III Espacio de direcciones El hijo hace una réplica del padre El hijo carga un programa en su espacio de direcciones Ejempos UNIX La lamada al sistema fork crea un proceso nuevo La lamada al sistema exec, después de fork, reemplaza el espacio de direcciones del proceso con un nuevo código de programa Terminación de procesos El proceso ejecuta la última sentencia y pide al SO Su eliminación (exit): Devuelve la salida desde el hijo al padre (via wait) Libera los recursos asignados El padre puede abortar la ejecución del hijo: El hijo excede sus recursos La tarea asignada al hijo ya no se necesita Cuando el padre termina Algunos SSOO no permiten continuar al hijo cuando el padre ha terminado Todos los hijos terminan en cascada 11
Realción padre-hijo en procesos padre Fork() Wait() reanuda hijo Exec() Exit() Estados de los procesos I Cuando un proceso se ejecuta, cambia su estado: Ejecución: Se ejecutan las instruciones del código del proceso Bloqueado: El proceso espera la ocurrencia de un evento Listo: El proceso espera que se le asigne tiempo de CPU para ejecutarse Zombie: El proceso ha terminado su ejecución pero aún tiene una entrada en la tabla de procesos (UNIX) 12
Estados de los procesos II Diagrama de estados de los procesos: se interrumpe termina Zombie Listo Ejecución Termina la E/S o elevento se planifica Bloqueado Espera E/S o un evento Cambio de contexto I 13
Cambio de contexto II Se produce por una interrupción. Cambio de contexto es el conjunto de dos operaciones: Se pasa a ejecutar la rutina de tratamiento de interrupción Se salva el estado del procesador en el correspondiente BCP Planificador: decide el siguiente proceso a ejecutar. Activador: pone a ejecutar un proceso. Copia el estado del BCP a los registros Termina con una instrucción RETI (retorno de interrupción) Restituye R el registro de estado (bit de nivel de ejecución) Restituye el contador de programa (para el nuevo proceso). El tiempo de cambio de contexto supone una sobrecarga; el sistema no realiza trabajo útil durante este tiempo El tiempo de cambio de contexto depende del soporte hardware Cambio de contexto III Registros especiales Tabla de procesos Estado Registros generales PC SP Estado BCP Proceso A Estado (registros) Información de identificación BCP Proceso B Estado (registros) Información de identificación BCP Proceso N Estado (registros) Información de identificación Información de Información de Información de Control Control Control 14
Planificación de procesos I Los procesos migran entre varias colas: Cola l trabajos (job): soporta todos los procesos del sistema Cola Listos (ready) ready): soporta todos los procesos que residen en memoria, preparados para ser ejecutados Colas Bloqueados: soportan los procesos que esperan por un dispositivo de E/S Planificación de procesos II: Colas de listos y bloqueados 15
Planificación de procesos III Llamadas al sistema I pid = fork() Crea un proceso idéntico al padre int execl(const char *path, const char *arg,...) int execlp(const char *file, const char *arg,...) int execvp(const char *file, char *const argv[]) Reemplaza la imagen del proceso (código+entorno) exit(status) Termina la ejecución del proceso y devuelve el estado pid = waitpid(pid, &statloc, options) Espera la terminación ió de un hijo pid_t getpid(void void) Devuelve el identificador del proceso. pid_t getppid(void void) Devuelve el identificador del proceso padre. 16
Llamadas al sistema. Fork #include <sys/types.h> pid = fork(void) Crea un proceso idéntico al padre Devuelve: El identificador de proceso hijo al proceso padre y 0 al hijo -1 el caso de error Descripción : Crea un proceso hijo que ejecuta el mismo programa que el padre Hereda los ficheros abiertos (se copian los descriptores). Las alarmas pendientes se desactivan. Llamadas al sistema. Fork Mapa de memoria Imagen del proceso A Tabla de procesos BCP A El proceso A hace un fork y crea el proceso hijo B Mapa de memoria Imagen del proceso A Imagen del proceso B Tabla de procesos BCP A BCP B Nuevo PID Nueva descripción de memoria Distinto valor de retorno (0 en el hijo) 17
Llamadas al sistema.exec int execl(const char *path, const char *arg,...) int execlp(const char *file, const char *arg,...) int execvp(const char *file, char *const argv[]) Reemplaza la imagen del proceso (código+entorno) Argumentos: path, file: nombre del archivo ejecutable arg: argumentos Descripción: Devuelve -1 en caso de error, en caso contrario no retorna. Cambia la imagen de memoria del proceso. El mismo proceso ejecuta otro programa. Los ficheros abiertos permanecen abiertos Las señales con la acción por defecto seguirán por defecto, las señales con manejador tomarán la acción por defecto. Llamadas al sistema.exec Mapa de memoria Imagen del proceso Tabla de procesos BCP El proceso hace un exec Mapa de memoria Tabla de procesos BCP Se borra la imagen de memoria Se borra la descripción de la memoria y registros Se conserva el PID Mapa de memoria Objeto ejecutable Biblioteca sistem a Cargador Imagen del proceso Tabla de procesos BCP Se carga la nueva imagen Se pone PC en dirección de arranque Se conservan los fd 18
Llamadas al sistema. Exit y Wait int exit(int int status) Argumentos: Código de retorno al proceso padre Descripción: Finaliza la ejecución del proceso. Se cierran todos los descriptores de ficheros abiertos. Se liberan todos los recursos del proceso pid = waitpid(pid, &statloc, options) Espera la terminación de un hijo Argumentos: Devuelve el código de terminación del proceso hijo. Descripción: Devuelve el identificador del proceso hijo o -1 en caso de error. Permite a un proceso padre esperar hasta que termine un proceso hijo. Devuelve el identificador del proceso hijo y el estado de terminación del mismo. Llamadas al sistema. Exit y Wait I El padre muere: INIT acepta los hijos Init Init Init Init wait() Init wait() Proceso A fork() Proceso A Proceso A exit() Proceso B Proceso B Proceso B Proceso B exit() 19
Llamadas al sistema. Exit y Wait II Zombie: el hijo muere y el padre no hace wait Init Init Init Init Init Proceso A fork() Proceso A Proceso A Proceso A Proceso A wait() Proceso B Proceso B exit() Proceso B zombie Proceso B zombie Llamadas al sistema.ejemplo Código C para crear un proceso int main() { pid_t pid; pid = fork(); if (pid < 0) { fprintf(stderr, "Fork ha fallado"); exit(-1); } else if (pid!= 0) {. wait(null); exit(0); } else { execlp ("/bin/ls", "ls", NULL); } } /* crea un proceso /* error /* Es el padre /* Código del padre /* Espera el fin del hijo /* El padre termina /* Es el hijo /* Ejecutar código 20
Threads Concepto de thread Modelos multithread Diseño con threads Threads en Linux Threads en Java Pthreads (POSIX threads) Concepto de thread I Proceso sencillo y multithread: código datos ficheros código datos ficheros registros pila registros registros registros pila pila pila thread thread Proceso con un único thread Proceso con varios threads 21
Estados de los threads Por thread Contador de programa, Registros Pila Procesos ligeros hijos Estado (ejecutando, listo o bloqueado) Por proceso Espacio de memoria Variables globales Ficheros abiertos Procesos hijos Temporizadores Señales y semáforos Contabilidad Proceso Procesos ligeros Bloqueado por comunicación Bloqueado por acceso a disco Activo Tipos de Threads Threads-kernel (ULT): Gestión the thread en el kernel Conocidos ygestionados por el núcleo del sistema operativo. Ej, libpthread en Linux o threads en WindowsNT Threads de usuario (KLT): Gestión the threads a nivel biblioteca de usuario Conocidos y gestionados por el lenguaje (ej, Java) o una biblioteca de funciones de usuario sin que el núcleo del sistema operativo los conozca Ej, Mach c-threads, fibras de WindowsNT Threads mixtos Conocidos y gestionados por una biblioteca de funciones de usuario que recurre al núcleo del sistema operativo para implementarlos vinculación o binding según distintas relaciones: 1 a 1, o varios a 1. 22
Modelos de vinculación de Threads I Many-to-One: varios threads de usuario soportados en un thread del kernel Solaris Green Threads GNU Portable Threads Threads de usuario K Thread del kernel One-to-One: cada thread de usuario está soportado en un thread del kernel Windows NT/XP/2000 Linux Threads de usuario Solaris posteriores a v9 K K K K Threads del kernel Modelos de vinculación de Threads II Many-to-Many: varios threads de usuario soportados en varios thread del kernel Solaris v9 Threads de usuario Windows NT K K K Thread del kernel Dos niveles: similar a M:M pero cada thread de usuario se puede enlazar con un thread del kernel Solaris v8 Threads de usuario K K K K Thread del kernel 23
Paralelización utilizando threads Procedimiento 1 Procedimiento 2 P F P F Ejecución Espera Espera serie en E/S en E/S Procedimiento 1 P Procedimiento i 2 Espera en E/S F Ejecución paralela P Espera en E/S F Procesamiento Threads en el diseño de servidores Distribuidor Trabajador Núcleo Puerto S olicitudes Núcleo Puerto S olicitudes Núcleo Puerto S olicitudes 24
Diseño con threads Proceso con un solo thread No hay paralelismo Llamadas al sistema bloqueantes Paralelismo gestionado por el programador Llamadas al sistema no bloqueantes Múltiples procesos cooperando Permite paralelismo gestionado por el SO No comparten variables Mayor sobrecarga de ejecución Proceso varios threads Paralelismo y variables compartidas Llamadas al sistema bloqueantes por thread Permite división de tareas Aumenta la velocidad de ejecución del trabajo Programación concurrente Simplicidad vs exclusión Imaginar otra llamada al mismo código Mutex Variables globales Linux Threads Linux Threads Linux se refiere a los threads como tareas (tasks) La creación de threads se realiza mediante la llamada al sistema clone() clone() permite a la tarea hija compartir el espacio de direcciones de la tarea padre (proceso) Java Threads Java threads se pueden crear: Extendiendo la clasethread Implementando el interfaz Runnable Los threads en Java los gestiona: La JVM: green threads El SO: correspondencia 1 a 1. 25
PThreads El API del standard POSIX (IEEE 1003.1c) 1c) para creación y sincronización de threads Este API especifíca el comportamiento de la biblioteca de thread, la implementación será el desarrollo de las especificaciones de esta biblioteca Es muy normal en SSOO tipo UNIX (Solaris, Linux, Mac OS X) Servicios POSIX para threads int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*func)(void *), void *arg) Crea un thread que ejecuta "func" con argumento "arg" y atributos "attr". Los atributos permiten especificar: tamaño de la pila, prioridad, política de planificación, etc. Existen diversas llamadas para modificar los atributos. int pthread_join(pthread_t thid, void **value) Suspende la ejecución de un thread hasta que termina el thread con identificador "thid". Devuelve el estado de terminación del thread. int pthread_exit(void *value) Permite a un thread finalizar su ejecución, indica el estado de terminación. pthread_t pthread_self(void) Devuelve el identificador del thread que ejecuta la llamada. int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate) Establece el estado de terminación de un thread. Si "detachstate" = PTHREAD_CREATE_DETACHED el thread liberara sus recursos cuando finalice su ejecución. Si "detachstate" = PTHREAD_CREATE_JOINABLE no se liberarn los recursos, es necesario utilizar pthread_join(). 26
Jerarquía de threads threads Proceso ligero A p_create Proceso ligero B No independ. p_create Proceso ligero D p_exit p_create Proceso ligero C p_join p_exit Programa de ejemplo I #include <stdio.h> #include <pthread.h> #define MAX_THREADS 10 void func(void) { printf("thread %d \n", pthread_self()); pthread_exit(0); } main() { int j; pthread_attr_t attr; pthread_t thid[max_threads]; pthread_attr_init(&attr); attr for(j = 0; j < MAX_THREADS; j ++) pthread_create(&thid[j], &attr, func, NULL); for(j = 0; j < MAX_THREADS; j ++) pthread_join(thid[j], NULL); } 27
Programa de ejemplo II #include <stdio.h> #include <pthread.h> #define MAX_THREADS 10 void func(void) { printf("thread %d \n", pthread_self()); pthread_exit(0); } main() { int j; pthread_attr_t attr; pthread_t thid[max_threads]; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr,pthread_create_detached); for(j = 0; j < MAX_THREADS; j ++) pthread_create(&thid[j], &attr, func, NULL); sleep(5); } Planificación Planificación a medio y largo plazo Planificación a corto plazo FIFO ó FCFS SJF, SRTF Prioridades Round-robin Tiempo real Planificación de Pthreads Planificación en POXIS Planificación en Linux Planificación en Windows-NT Servicios POXIS para planificación 28
Planificación de la CPU Planificación A largo plazo (añadir procesos a ejecutar) A medio plazo (añadir procesos a RAM desde disco) A corto plazo (qué proceso tiene la UCP) Planificación de E/S Tipos de planificación Sin expulsión: el proceso conserva la UCP mientras desee. Con expulsión: el SO quita la UCP al proceso Exige un reloj que interrumpe periódicamente Colas de procesos Por prioridad Por tipo Planificación a medio y largo plazo Nuevos de estados de los procesos: En espera (Bach): Espera entrar en el sistema Suspendido: En espera de asignación de memoria Suspendido y bloqueado Suspendido y lista 29
Estados de los procesos II Diagrama de estados de los procesos: En espera se admite se interrumpe termina Zombie Suspendido y listo se expulsa a disco Listo Ejecución Termina la E/S o el evento Suspendido y bloqueado se recupera de disco se expulsa a disco se planifica Termina la E/S o el evento Bloqueado Espera E/S o un evento Planificación a corto plazo Planificación a corto plazo: cuando un proceso: 1. Se bloquea 2. Pasa de ejecutando a listo 3. Pasa de bloqueado a listo 4. Termina La planificación en los casos 1 y 4 es no expulsora (nonpreemptive) En el resto de casos es expulsora (preemptive) 30
Criterios de planificación MÁXIMIZAR Utilización de la CPU que sea máxima Productividad bach (throughput) # de procesos que se procesan por unidad de tiempo MÍNIMIZAR Tiempo de respuesta (Turnaround) tiempo en ejecutar un trabajo en particular Tiempo de espera tiempo que un proceso pasa en la cola de listos Tiempo de respuesta interactivo tiempo que pasa desde que se envía el trabajo hasta que se obtiene una respuesta CONSEGUIR Reparto equitativo del procesador Cumplimiento de plazos (tiempo real) Calidad de servicio (sistemas multimedia) Algoritmos de planificación I FIFO ó FCFS Organización en una lista ordenada por tiempo de llegada SJF, SRTF Organización en lista ordenada por tiempo previsto de ejecución Bach: tiempo previsto para la ejecución de un proceso Interactivo: tiempo previsto para la próxima ráfaga de CPU Prioridades Fíjas o dinámicas Organización en una lista ordenada por prioridades calculadas Round-RobinRobin Organización en una lista circular con quantos de tiempo Expropiación por agotamiento del quanto y replanificación Lotería Se asigna a cada proceso un rango de valores y se genera un número a leatorio Tiempo real A plazo fijo: EDF (prioridades dinámicas) Periódicos: RMS (prioridades estáticas) 31
FIFO ó First-Come, First-Served (FCFS) I Procesos T. cómputo P 1 24 P 2 3 P 3 3 Suponiendo que los procesos llegan en el siguiente orden P 1, P 2, P 3 El diagrama de Gantt es: P 1 P 2 P 3 0 24 27 30 Tiempo de espera para: P 1 = 0; P 2 = 24; P 3 = 27 Tiempo medio de espera: (0 + 24 + 27)/3 = 17 FIFO ó First-Come, First-Served (FCFS) II Suponiendo que los procesos llegan en el siguiente orden P 2, P 3, P 1 El diagrama de Gantt es: P 2 P 3 P 1 0 3 6 30 Tiempo de espera para: P 1 = 6;P 2 = 0 ; P 3 = 3 Tiempo medio de espera: (6 + 0 + 3)/3 = 3 Mucho mejor que el caso anterior Efecto Convoy: los procesos cortos detrás de los largos 32
Shortest-Job-First (SJF) Scheduling I Asocia a cada proceso el tiempo previsto de ejecución. Selecciona para ejecutar el proceso con menor tiempo. Dos esquemas: No expulsor (nonpreemptive) una vez planificado sigue en la CPU hasta que completa su ráfaga de CPU. Expulsor (preemptive) si llega un nuevo proceso con un tiempo menor que el que se está ejecutanto, este último se expulda. También se llama Shortest-Remaining-Time-First (SRTF) SJF es óptimo da el menor tirmpo de espera medio para un conjunto de procesos. Problema: se debe suministrar el siguiente tiempo de ráfaga -> estimación teniendo en cuenta las anteriores Ejemplo de SJF no expulsivo Procesos T. llegada T. cómputo P 1 0.0 7 P 2 20 2.0 4 P 3 4.0 1 P 4 5.0 4 SJF (no-expulsivo) P 1 P 3 P 2 P 4 0 3 7 8 12 16 Tiempo medio de espera = (0 + 6 + 3 + 7)/4 = 4 33
Ejemplo de SJF expulsivo Procesos T. llegada T. cómputo P 1 0.0 7 P 2 2.0 4 P 3 4.0 1 P 4 5.0 4 SJF (expulsivo) P 1 P 2 P 3 P 2 P 4 P 1 0 2 4 5 7 11 16 Tiempo medio de espera = (9 + 1 + 0 +2)/4 = 3 Planificación basada en prioridades I Se asocia un número de prioridad (entero) a cada proceso La CPU ejecuta el proceso de mayor prioridad (menor entero mayor priodad) Expulsivo No expulsivo SJF es un planificador de prioridad, en el que la prioridad es el tiempo de cómputo de cada ráfaga de CPU (a menor ráfaga mayor prioridad). id d) Problema Inanición (starvation) el proceso de menor prioridad puede no ejecutarse nunca Solución Envejecimiento (aging) a medida que pasa el tiempo, el proceso aumenta su prioridad 34
Planificación basada en prioridades II Establecimiento de prioridades: Interno: uso de la memoria, bloqueos de E/S, duración estimada de la siguiente ráfaga de CPU Procesos T. llegada T. Ráfaga estimado Prioridad P 1 0.0 7 3 P 2 2.0 4 2 P 3 4.0 1 1 P 4 5.0 4 2 Externo: coste, frecuencia, importancia,.. Procesos T. llegada Frecuencia Prioridad P 1 0.0 1 4 P 2 2.0 3 2 P 3 4.0 6 1 P 4 5.0 2 3 Round Robin (RR) Cada proceso tiene una unidad de tiempo de CPU (quantum), normalmente 10-100 milliseg. Cuando pasa el proceso es expulsado y puesto en la cola de Listos Si hay n procesos en la cola de Listos, y el quantum es q, a cada proceso le toca 1/n del tiempo CPU en trozos de al menos q unidades de tiempo cada uno. Ningún proceso espera más de (n-1)q unidades de tiempo. Performance q grande FIFO q pequeño q debe ser grande respecto al tiempo de cambio de contexto (latencia) para que el overhead no sea demasiado grande 35
Ejemplo de RR con Quantum = 20 Process Burst Time P 1 53 P 2 17 P 3 68 P 4 24 El diagrama de es: P 1 P 2 P 3 P 4 P 1 P 3 P 4 P 1 P 3 P 3 0 20 37 57 77 97 117 121 134 154 162 Normalemente, la media de turnaround es mayor que en SJF, pero mejor tiempo de respuesta El quantum y la latencia de cambio de contexto 36
El tiempo de Turnaround varía con el Quantum Colas multilevel I La cola de Listos se particiona en colas separadas : foreground (interactivo) background (batch) Cada cola tiene su propio algoritmo de planificación foreground RR background FCFS La planificación se aplica entre las colas: Planificación de prioridad fija; (se sirven todos de foreground y después de background). Se puede producir inanición. Rodaja de tiempo cada cola tiene una cierta cantidad de tiempo de CPU time que se reparte entres sus procesos; ej.., 80% to foreground in RR y 20% to background in FCFS 37
Colas multilevel II Colas multilevel con realimentación Tres colas: Q 0 RR con quantum de 8 milisegundos y FIFO Q 1 RR con quantum de 16 milisegundos y FIFO Q 2 FIFO Planificación Un nuevo trabajo llega a la Q 0 con planificación FIFO. Cuando gana la CPU, se ejecuta 8. Si no termina se mueve a Q 1. En Q 1 se sirve con FIFO y se le dan 16 m. Si no termina se mueve a Q 1. 38
Planificación en Tiempo real Tiempo real duro o crítico (Hard real-time) las tareas se debe complentar dentro de un plazo preestablecido (con unas garantías de tiempo) RMA: Asignas las prioridades según la frecuencia (tareas periódicas e independientes). Garantiza que cumplen el plazo para una utilización del procesador < 70% EDF: Primero la tarea que antes cumpla en plazo (prioridades dinámica). Más dificil de implementar que el anterior. La utilización del procesador puede ser del 100% Tiempo real blando o no crítico (Soft real-time) las tareas críticas deben teber prioridades más altas que las que no lson de tiempo real. Planificación en Tiempo real. RMS I Tarea Cómputo Plazo= T Prioridad 1 4 10 1 2 4 15 2 3 10 35 3 1 2 3 tiempo Tiempo de cómputo (C) Fin de periodo (T = Periodo ) 39
Planificación en Tiempo real. RMS II Utilización del procesador pora una tarea i U i = C i T i 1 Utilization del procesador para n tareas n U(n) = n(2-1) Resultados: Si U i U(n) el conjunto de tareas es planificable. If U i > 1 el conjunto de tareas es no planificable. Si U(n) < U i el conjunto de tareas es inconcluso *si todas las tareas cumplen su plazo en el primer hiperperiodo el conjunto de tareas es planificable. Planificación en Tiempo real. RMS III Tarea Cómputo Plazo= T Prioridad 1 4 10 1 2 4 15 2 3 10 35 3 U(3) = 3(2 1/3 1) = 0.779 U 1 = 4 / 10 = 0.4 U 2 = 4/15= 0.267 U 3 = 10 / 35 = 0.286 U total = 0.953 Resultados: U 1+2 = 0.667, planificanle. Sin embargo, 0.779 < 0.953 < 1 Por lo que es inconcluso para 3. Si las tareas cumplen el plazo en el primer HIPERPERIODO (35 en este caso) son planificables 40
Planificación en Tiempo real. EDF Las prioridades se asignan de acuerdo a sus plazos: El plazo más corto, la prioridad mayor; El plazo más largo, la prioridad menor. Planificación en POSIX I Cada política de planificación lleva asociado un rango con al menos 32 niveles de prioridad. El planificador elegirá el proceso o thread con la prioridad más alta Políticas de planificación Para compartición de tiempo prioridad variable Otra (SCHED_OTHER) Para tiempo real prioridad fija, superior a SCHED_OTHER FIFO (SCHED_FIFO) Cíclica (SCHED_RR) 41
Planificación SCHED_OTHER en LINUX Funcionamiento general LINUX divide el tiempo de CPU en épocas (epoch) En cada época cada proceso tiene un quantum de tiempo que se le asigna al comenzar la época Cuando un proceso agota su quantum se le expulsa y se selecciona otro proceso ejecutable Un proceso puede ser seleccionado múltiples veces mientras le quede quantum Por ejemplo, puede haber sido expulsado tras una E/S, propia o ajena, y luego vuelto a asignar la CPU La época termina cuando todos los procesos ejecutables han agotado su quantum En ese momento, se reasigna los quantum para la época siguiente LINUX favorece los procesos que no han agotado su quantum en la época anterior La prioridad está relacionada con el quantum restante (a mayor quantum, mayor prioridad) Planificación Pthread Políticas de planificación a definir como en procesos. Ambitos de planificación: PTHREAD_SCOPE_PROCESS: Planificación local La librería de threads decide que thread se ejecuta. PTHREAD_SCOPE_SYSTEM: Planificación global El kernel decide qué thread se ejecuta. Los atributos de planificación se pueden añadir mediante servicios a los atributos de creación de un thread: #include <pthread.h> int pthread_attr_setscope(pthread_attr_t *attr, int scope); int pthread_attr_getscope(const pthread_attr_t *attr, int *scope); int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy); int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy); 42
Planificación en Windows NT I Reiniciado Iniciado Situar en la cola de listos Finalizado Bloqueado Fin de bloqueo Listo Ejecución finalizada Espera terminada Bloqueado Pila del kernel en swap Pila del kernel en memoria Transición Seleccionado Expulsado para ejecución Ejecución Expulsado Cambio de contexto. Comienzo de ejecución Reserva Planificación en Windows NT II Pt: Prioridades relativas de threads Promoción dinámica: +n si se desbloquea (hasta 15) Decaimiento dinámico: -1 si agota el quantum (hasta Pt) Anti-inanición: Si no se ha ejecutado en los últimos 3 segundos, adopta prioridad 15 para ejecutar 2*quantum 43
Servicios POSIX para planificación I #include <sched.h> Modificar la prioridad de un proceso int sched_setparam(pid_t pid, const struct_param *param); Modificar la prioridad y la política int sched_setscheduler(pid_t pid, const sched_param *param); Obtener los parámetros de planificación de un proceso int sched_getparam(pid_t pid, const struct_param *param); Obtener la prioridad de un proceso int sched_getscheduler(pid_t pid); Capítulo 4: Gestión de procesos Señales y excepciones Temporizadores Servidores y demonios 44
Señales I Señal: Mecanismo por el que un proceso puede ser notificado de, o afectado por, un evento que se produce en el sistema: - excepciones detectadas por hardware - expiración de una alarma o temporizador - finalización de una operación de I/O asíncrona - llegada de un mensaje - invocación de la función kill() y similares -actividad del terminal, etc. Número de señal: Entero positivo que identifica una señal. Existen también constantes predefinidas para dar nombre a las señales Señales II Las señales son interrupciones al proceso Envío o generación Proceso- Proceso (dentro del grupo) con el kill SO - Proceso Proceso Código Función tratamiento Señal 45
Señales III Una señal se puede generar para un proceso o para un thread. Cada thread tiene una máscara de señales, que define las señales bloqueadas. La máscara se hereda del padre Señal no bloqueada: se entrega Ignorar Terminar el proceso Ejecutar manejador Señal bloqueada: queda pendiiente hasta que se acepta con sigwait() Tratamiento de señales I Opciones para tratar una señal: Enviar la señal al thread al que la señal se refiere Enviar la señal a todos los threads del proceso Asignar un thread específico para recibir todas las señales del proceso Cada señal se trata mediante un manejador manejador 1. La señal se genera por un evento particular 2. La señal se envía al proceso 3. La señal se trata 46
Tratamiento de señales II Hay muchos tipos de señales, según su origen SIGILL instrucción ilegal SIGALRM vence el temporizador SIGKILL mata al proceso El SO las transmite al proceso El proceso debe estar preparado para recibirla Especificando un procedimiento de señal con sigaction() Enmascarando la señal con sigprogmask() Si no está preparado acción por defecto El proceso, en general, muere Hay algunas señales que se ignoran o tienen otro efecto El servicio pause() para el proceso hasta que recibe una señal Señales. Ejemplo Unix /* Programa A. Fichero Fichero padre.c * Manda ejecutar el programa B * Lee caracteres del terminal y cada vez que detecta salto de linea * envia una señal al proceso B */ #include <stdio.h> #include <signal.h> #include <unistd.h> #include <stdlib.h> pid_t resp; char buf[1]; main() { } resp = fork(); if (resp == 0) if (execlp("./hijo","hijo", NULL) == -1) { perror("exec"), exit(1); } while (read(0, buf, 1) == 1) { if (buf[0] == '\n') { kill(resp, SIGUSR2); } } 47
Señales. Ejemplo Unix /* Programa B. Fichero hijo.c * Crea un fichero y escribe en él * una línea por cada señal que recibe, hasta un máximo de 5 */ #include <fcntl.h> #include <signal.h> #include <stdlib.h> int fd, n=5; void proc(int arg) { n--; return; } int main() { signal(sigusr2, proc); if ((fd = open("fichero", O_CREAT O_TRUNC O_WRONLY)) == -1) { perror("open"); exit(1); } } while (n!= 0) { pause(); write(fd, "Linea\n", 7); } return 0; Excepciones Evento que ocurre durante la ejecución de un programa y que requiere la ejecución de un fragmento de código fuera del flujo normal de ejecución. Manejo de excepcion en Java try { Bloque donde puede producirse una excepción } catch { Bloque que se ejecutará si se produce una excepción en el bloque anterior } 48
Temporizadores El SO mantiene un temporizador por proceso El proceso activa el temporizador con alarm() El SO envía una señal SIGALRM al proceso cuando vence su temporizador Proceso servidor Es un proceso que: Está pendiente de recibir órdenes de un proceso cliente Estructura de bucle infinito Uso de puertos de comunicación PROCESOS CLIENTES PROCESO SERVIDOR RECURSO Servidor secuencial: El servidor mismo ejecuta las órdenes Servidor paralelo: Delega ejecución las órdenes a threads o procesos hijos 49
Proceso servidor. Funcionamiento a) b) c) Servidor Padre Servidor Padre Servidor Padre Servidor Hijo Puerto A Puerto A Puerto A Puerto B Cliente A Cliente A Proceso servidor. Máquinas distribuidas Procesos cliente y servidor en máquinas distintas Puerto Cliente Servidor ficheros Servidor impresión Servidor e_mail SO SO SO SO RED 50
Procesos demonios Es un proceso que ejecuta: En background (su padre no le espera) No asociado a un terminal o proceso login Que espera que ocurra un evento Funciona como servior O que debe realizar una tarea de forma periódicas Características Se arrancan al iniciar el sistema No mueren Están normalmente en espera de evento No hacen el trabajo, lanzan otros procesos o procesos ligeros Ejemplos:Telnetd, httpd, lpd Servicios POSIX para señales I include <sys/types.h> #include <signal.h> Manipular conjuntos de señales: int sigemptyset (sigset_t *set); int sigfillset (sigset_t *set); int sigaddset (sigset_t *set, int signo); int sigdelset (sigset_t *set, int signo); int sigismember (const sigset_t *set, int signo); Estas funciones no afectan de forma directa al comportamiento del sistema 51
Servicios POSIX para señales II Examinar y cambiar la acción asociada a una señal (armado): int sigaction (int sig, const struct sigaction *act, struct sigaction *oact); si act es NULL, la acción actual no se cambia si oact no es NULL, la acción actual se devuelve en *oact Enviar una señal a un proceso: int kill (pid_t pid, int sig); Enviar una señal a un thread: pthread_kill(pthread_t t thread, int sig); Aceptar una señal bloqueada: int sigwait (const sigset_t *set, int *sig); Servicios POSIX para señales III Máscara de señales: int sigprocmask (int how, sigset_t *set, sigset_t *oset); Permite modificar o examinar la máscara de señales de un proceso. int sigpending (sigset_t *set); Devuelve el conjunto de señales bloqueadas pendientes del proceso. Espera de señales: int pause(void); Bloquea al proceso hasta que llegue una señal. Servicios de temporización: unsigned int alarm(unsigned int seconds); Activa un temporizador unsigned int sleep(unsigned int seconds); El proceso se suspende en num de segundos. 52