Procesos e hilos. Pablo San Segundo (C-206)

Transcripción

1 Procesos e hilos Pablo San Segundo (C-206) [email protected]

2 KERNEL DEL SISTEMA OPERATIVO Al arrancar el PC siempre se carga en memoria una copia del Kernel desde disco El Kernel del sistema operativo es un programa, típicamente programado en C

3 Qué es un Proceso? Un programa en ejecución La unidad de procesamiento gestionada por el S.O.

4 Presencia en memoria y tabla BCP Registros de la CPU Contexto Entorno Identificadores de usuario y grupo Identificador de proceso Variables de entorno Usuario Sistema Control (tablas) Estado: Bloqueado, ejecución, listo Prioridad: cola de prioridades E/S: Desc. recursos,,mensajería etc. Presencia en memoria Bloque de Control de Proceso typedef struct bcp { struct bcp *siguiente; struct bcp *anterior; struct bcp *hebra int retardo; palabra marco; palabra pila; palabra marcador; int pri; int estado; struct bcp *todosenl; int mascara; k_ptrmens retenmens procnombre nombre; } bcp;

5 ESTADOS BÁSICOS DE UN PROCESO EN EJECUCIÓN Un proceso por procesador BLOQUEADO En espera de completar E/S LISTO Preparado para pasar al estado de ejecución

6 ENTORNO DEL PROCESO Definición Tabla NOMBRE-VALOR que se pasa al proceso en su creación Ubicación Imagen en Memoria: típicamente en la pila Valor Por defecto Mandatos Shell (API S.O.) SHELL echo $PATH echo $HOME SHELL PATH=/usr/bin:/home/pss/bin TERM=tty100 HOME=/home/pss PDW=/home/pss/ingsw PATH=$PATH:XXX

7 CARACTERÍSTICAS DE PROCESOS Jerarquías (familias) Procesos hijo, padre, hermano, abuelo etc.. Vida Creación Ejecución Muerte Tipo de ejecución Batch (lotes) Interactivo INI INI SES SHELL INI SES SHELL PROC 1 PROC 2

8 USUARIO Definición Persona autorizada a utilizar el sistema Autenticación User login (internamente es un número para el S.O.: i.e uid) Contraseña (password) Super-usuario (sudo, su) Derechos de administrador Grupo de usuarios Colectivo de usuarios con los mismos permisos Todo usuario ha de pertenecer a un grupo

9 FIN DE INTRODUCCIÓN

10 Clasificación de los Sistemas Operativos

11 Fundamento del multiproceso Definición Ejecución concurrente real de varios procesos con un solo procesador Bases Alternancia de los procesos en la CPU durante la fase de E/S Almacenamiento en memoria de varios procesos simultáneamente

12 Ejemplo Ejecución de proceso nulo

13 VENTAJAS DE LA MULTITAREA Funcionamiento del SO en modo interactivo de forma eficiente Aprovecha tiempos de espera de procesos durante E/S Aumenta el uso de la CPU Nuevo paradigma de programación Principio de modularidad : Un programa-varios procesos

14 GRADO DE MULTIPROGRAMACIÓN Definición Número de procesos activos en un instante de tiempo Recurso Memoria principal Sistema SIN memoria virtual

15 GRADO DE MULTIPROGRAMACIÓN Sistema CON memoria virtual

16 GRADO DE MULTIPROGRAMACIÓN Sistema CON memoria virtual RENDIMIENTO DEL PROCESADOR HIPER-PAGINACIÓN

17 FIN DE S.O. MULTITAREA

18 INFORMACIÓN DEL PROCESO EN S.O. i.e. RIED CODIGO PILA DATOS Se gestionan fuera del BCP. Por qué?

19 ESTADO DEL PROCESO : CONTEXTO Registros generales Motorola 68000: A0-A7, D0-D7 Contador de programa (PC) Siguiente instrucción a ejecutar Puntero de Pila ( Call Stack pointer ) Referencia la pila en memoria asociado a todo proceso Motorola (USP y SSP) Puntero de marco ( Frame pointer ) Registro de Estado Modo de ejecución, máscaras de interrupciones, información acerca de la última operación realizada en la ALU, etc Motorola (SR) Registros especiales Ejemplo: RIED: Registro que Identifica el Espacio de Direcciones que ocupa en memoria el proceso en ejecución

20 PROCESO EN MEMORIA Pertenece al BCP Segmentación fija Hoy en día la segmentación es variable Preasignación inicial de zona de swapping

21 TABLAS DEL SISTEMA OPERATIVO Tabla de procesos (BCP) Información exclusiva de cada proceso que no se puede COMPARTIR y cuyo tamaño no varía durante la ejecución de cada proceso (IMPLEMENTACIÓN) Tabla de Memoria (alias paginado) Información para la gestión de memoria Tabla de Entrada / Salida Información relativa a periféricos y a las operaciones E/S Tabla de Ficheros Información sobre los ficheros utilizados por los procesos

22 Ejemplo Tabla de Ficheros Doble direccionamiento Puntero de posición COMPARTEN LECTURA Y ESCRITURA EN FICHERO TABLA DE FICHEROS

23 EJEMPLO: INFORMACIÓN EN EL BCP TREEPS (LINUX)

24 FIN DE PRESENCIA EN MEMORIA DE UN PROCESO

25 NACIMIENTO DE UN PROCESO Linker Transmisión de ficheros al Motorola A imagen en memoria e.g. kernel.lib/dll

26 FORMACIÓN DE UN PROCESO SE ACTUALIZA LA PRIMERA VEZ Y EN CADA CAMBIO DE CONTEXTO Tablas S.O. COPIA DE LAS BIBLIOTECAS DEL SISTEMA EN LA IMAGEN DE MEMORIA (kernel.lib) EL EJECUTABLE NO CONTIENE A LAS BIBLIOTECAS DEL SISTEMA

27 FIN DE FORMACIÓN DE UN PROCESO

28 SERVICIOS DE GESTIÓN DE PROCESOS Identificación de procesos Entorno de un proceso Creación de procesos Cambio de imagen de un proceso Espera a la terminación de un proceso Finalización de la ejecución de un proceso Información adicional

29 SERVICIO POSIX: fork Definición pid_t fork (void) : Crea un proceso hijo clonando al padre. Copia no exacta (i.e. señales)

30 SERVICIO POSIX: fork Librerías #include <sys/types.h> Retorno Identificador de proceso padre 0 hijo -1 si error Descripción Crea un proceso hijo que ejecuta el mismo programa que el padre Se heredan los descriptores (i.e. archivos) Se desactivan las alarmas pendientes Depende de la distribución

31 SERVICIO POSIX: exec Definición Cambia el programa del proceso Los descriptores abiertos se mantienen

32 EJEMPLO: Servicio fork #include <sys/types.h> #include <iostream> int main() { pid_t pid; pid=fork(); if (pid= = -1) cout<< Error <<endl; else if (pid == 0) { cout<< Proceso hijo <<endl; } else{ cout<< Proceso padre <<endl; } return 0; }

33 SERVICIO POSIX: exec Declaraciones int execl (const char* path, const char* arg, ) int execlp(const char* file, const char* arg, ) int execvp(const char* file, const char* arg[]) Retorno -1 si error o NO RETORNA Descripción El mismo proceso ejecuta otro programa Los descriptores abiertos permanecen abiertos Las señales toman la acción por defecto Ultimo parámetro NULL #include <unistd.h>

34 EJEMPLO: Servicio execl #include <sys/types.h> #include <unistd.h> #include <iostream> int main() { pid_t pid; if ((pid = fork()) = = -1) cout<< Error <<endl; else if (pid == 0) { if(execl ("/bin/ls, ls", -l, NULL)){ cout<< Error al lanzar la tarea <<endl; } } int status; wait(&satus); return 0; }

35 EJEMPLO: Servicio execv #include <sys/types.h> #include <unistd.h> #include <iostream> int main() { pid_t pid; char * arg[3]; arg[0]= gedit ; arg[1]= test.cpp ;arg[2]=null; if ((pid = fork()) = = -1) cout<< Error <<endl; else if (pid == 0) { if(execvp (arg[0], arg)){ cout<< Error al lanzar la tarea <<endl; } } int status; wait(&satus); return 0; }

36 SERVICIO POSIX: int exit (int status) Definición Termina un proceso, devolviendo el parámetro status al proceso padre Declaración void exit (int status) EXIT_SUCCESS, EXIT_FAILURE Argumento Código de retorno al proceso padre Descripción Finaliza la ejecución del proceso Cierra todos los descriptores Se liberan todos los recursos #include <stdlib.h>

37 SERVICIO POSIX: wait #include <sys/wait.h> Definición Espera la terminación de un proceso hijo CUALQUIERA Declaración pid_t wait (int* status) pid_t waitpid (int pid, int* status, int options) Retorno WUNTRACED WNOHANG Identificador del proceso hijo, -1 si error Descripción Permite a un proceso padre esperar hasta que termine un proceso hijo Devuelve el estado del proceso hijo al terminar Macros para analizar el estado: WIFEXITED, WEXITSTATUS WIFSIGNALED, WTERMSIG, etc

38 EJEMPLO : Servicio wait con MACROS int main() { int status; pid_t pid; pid= fork(); if(pid==0){ execlp( gedit, main.cpp, NULL); exit(exit_success); } wait(&status) ; if(wifexited(status)){ if(wexitsatus(status)==exit_success){ cout<< OK <<endl; }else if(wexitsatus(status)==exit_failure)){ cout<< ERROR <<endl; } } cout<<"proceso padre terminado"<<endl; exit(exit_success); } Capturar el error

39 EJEMPLO : Servicio wait multiproceso int main() { int status; pid_t pid; for(int i=0; i<10; i++){ pid= fork(); if(pid==0){ cout<<"hilo: "<<i<<endl; exit(exit_success); } } //Espera a todos los hijos while ( wait(&status)!=-1 ){;} cout<<"proceso padre terminado"<<endl; exit(exit_success); }

40 EJEMPLO: waitpid int main(void) { int status; pid_t pid; pid= fork(); if(pid==0){ sleep(5); cout<<"proceso hijo terminado"<<endl; exit (EXIT_SUCCESS); } pid_t endid= waitpid(pid,&status, WNOHANG); //no bloqueante if(endid==pid){ cout<<"status del hijo diposnible"<<endl; } else{ cout<<"padre termina sin conocer el status del hjo"<<endl; } exit (EXIT_SUCCESS); }

41 Caso de uso típico de exec /fork /wait Padre e hijo comparten recursos

42 EVOLUCIÓN DE PROCESOS: ZOMBIES El hijo muere antes de la ejecución de un servicio wait( ) del padre Hijo: Proceso ZOMBIE BCP de B sigue existiendo

43 EJEMPLO: Zombies int main(void) { pid_t pid; pid= fork(); switch(pid){ case -1: cout<<"error al creado proceso duplicado"<<endl; exit(exit_failure); break; case 0: sleep(1); cout<<"proceso hijo terminado"<<endl; exit(exit_success); break; } cout<< hijo terminará sin wait del padre: ZOMBIE!"<<endl; sleep(30); int status; wait(&status); exit(exit_sucess); }

44 EJEMPLO: JERARQUÍAS DE PROCESOS #include <sys/types.h> #include <sys/wait.h> int main (int argc, char** argv ) { int i, valor; pid_t pid_1, pid_2; i=atoi(argv[1]); pid_1=fork(); while(i>0){ pid_2=fork(); if(pid_2!=0) { wait(&valor) break; } i=i-1; } return 0; } Ejecución desde Terminal <Nombre Ejecutable> 3 JERARQUÍA DE PROCESOS? A) Figura B) Sin Bloque

45 Ejercicio: Procesos distribuidos (I) Impleméntese un proceso que lance la tarea de leer un grafo en formato DIMACS de un fichero de texto y devuelva su grado en pantalla. El proceso principal debe esperar a la terminación de dicha tarea e indicar si se ha resuelto correctamente.

46 FIN DE SERVICIOS POSIX PARA PROCESOS

47 ESTADOS DE UN PROCESO Planificador Corto Plazo SWAPPING

48 PLANIFICACIÓN DE PROCESOS Planificador (Planner): Programa del S.O. que determina que proceso tiene que ejecutarse. Activador (Dispatcher) : Programa del SO que carga el programa seleccionado por el planificador en memoria Formas de planificar del S.O: Largo plazo: Decidir que procesos batch entran a ejecutarse Medio plazo: Añadir procesos a RAM Finalización del estado de suspendido. Sistemas con swapping. CORTO PLAZO: DECIDIR QUÉ PROCESO TOMA EL CONTROL DE LA CPU

49 NOCIONES BÁSICAS DEL CORTO PLAZO Tipos de planificación Sin expulsión: El proceso conserva la CPU mientras lo desee Con expulsión: El S.O. quita la CPU al proceso cada cierto tiempo. Colas de procesos Por prioridad (niveles) Por tipo Lotes Interactivo

50 OBJETIVOS DE LA PLANIFICACIÓN Reparto de la CPU equitativo Eficiencia (optimizar uso CPU) Mejorar el tiempo de respuesta Modo interactivo Modo lotes Cumplir plazos de ejecución en sistemas de tiempo real INCOMPATIBILIDAD DE OBJETIVOS! Windows NT Server Windows 7 Home Edition

51 COLAS DE PROCESOS EJEMPLO BATCH

52 Implementación de colas de procesos Implementación con punteros a otros BCP Acceso eficiente COLAS DE PRIORIDAD

53 ALGORITMOS DE PLANIFICACIÓN CÍCLICA (Round Robin) Asignación de CPU rotatoria Se asigna un tiempo máximo a todos los procesos (time slot ) Los procesos se organizan en una cola circular Un proceso que excede su slot se expulsa y se coloca al final de la cola SISTEMAS DE TIEMPO REPARTO COMPARTIDO por UID en vez de por TIEMPO de PROCESAMIENTO

54 ALGORITMOS DE PLANIFICACIÓN (II) FIFO ( first in-first out ) Los procesos se organizan según una cola clásica. Entran por el final y esperan su turno. Política de planificación SIN EXPULSIÓN El proceso en ejecución sólo será expulsado cuando él mismo realiza una llamada bloqueante al sistema (i.e. E/S) Problema: INANICIÓN Se suele combinar con política de prioridades (i.e. POSIX) PROCESAMIENTO POR LOTES

55 ALGORITMOS DE PLANIFICACIÓN (III) Prioridades Fijas: Problema de inanición (p. ej. RTOS) Variables (aumentan con envejecimiento) El trabajo más corto primero Aplicación en sistemas Batch Menor tiempo de respuesta Penaliza las tareas largas Dificultad en conocer a priori las tareas de mayor duración. Aleatorio

56 ALGORITMOS DE PLANIFICACIÓN RT (IV) Definición Sistemas de Tiempo Real (RTOS) Sistemas donde los procesos deben ejecutarse en instantes predeterminados Tipos de RTS Requisitos blandos / duros Ejecución a plazo fijo / periódico EJEMPLOS QNX RTLinux VxWorks Windows CE Prioridad 2h:30m:10s Reloj de tiempo / 2h:30m:15s 2h:30m:10s 2h:30m:20s REQUISITOS DUROS: En ningún caso de puede rebasar La CAPACIDAD el tiempo de DE reloj PROCESAMIENTO asociado al proceso NO es especialmente alta PREPROCESAMIENTO PREDECIBLE: Sin caches, sin paginación, sin predicción de saltos

57 PLANIFICACIÓN EN POSIX Prioridad Absoluta (RT) (0)-normal (>0)-RT Dinámica POSIX 19 a -20 (mayor número menor prioridad) El planificador siempre elige aquellos procesos con mayor prioridad Políticas de planificación FIFO (procesamiento por lotes) Cíclica (modo interactivo) Otra

58 Ejercicio: Procesos distribuidos (I) Algunos servicios POSIX para prioridad dinámica int setpriotiy (PRIO_PROCESS, int pid, int niceval) RETURN VALUE: -1 ERROR, 0 OK int getpriority (PRIO_PROCESS, int pid) Escriba un programa en C para POSIX que lance dos tareas P1 y P2 que compartanescrituraenunficherodetexto log.txt. Modifique la prioridad de P1 y P2 y compruebe como afecta a la salida. #include <sys/wait.h>

59 Solución int main(void) { pid_t pid, pid2; ofstream f("log.txt", ios::app); pid=fork(); if(pid==0){ //fichero compartido sleep(1); cout<<"proc 1: "<<getpriority(prio_process,pid)<<endl; // escribir en fichero exit(exit_success); } pid2=fork(); if(pid2==0){ sleep(1); cout<<"proc 2: "<<getpriority(prio_process,pid)<<endl; // escribir en fichero exit(exit_success); } setpriority(prio_process,pid,19); setpriority(prio_process,pid2,0); int status; while(wait(&status)!=-1) continue; f.close(); execlp("gedit", "gedit", "log.txt", NULL); exit (EXIT_SUCCESS); } //opcional

60 PLANIFICACIÓN WINDOWS NT

61 FIN DE POLÍTICAS DE PLANIFICACIÓN

62 THREAD (Proceso ligero) Definición Un thread es un proceso que comparte un espacio en memoria con otros threads. Estructura de un proceso en WIN NT Si termina el hilo principal mueren el resto de hilos! COMPARTEN MEMORIA

63 Paralelización con procesos ligeros

64 PROGRAMACIÓN CON THREADS Un thread es equiparable a una función que se ejecuta en PARALELO con otras funciones (threads) Programación con hilos Elevada dificultad Al escribir código es fundamental tener en cuenta un PARALELISMO REAL (aun cuando se tenga un solo procesador) Imaginar LLAMADAS DISTINTAS AL MISMO CÓDIGO Comunicación entre hilos Variables compartidas en memoria Descriptores de recursos compartidos, Elementos de sincronización compartidos etc. Aumenta la velocidad de ejecución de tareas con E/S

65 APLICACIÓN: DISEÑO DE SERVIDORES Tres arquitecturas de servidor

66 GESTIÓN DE PROCESOS LIGEROS JOINING es uno de los mecanismos de sincronización de hilos

67 SERVICIOS POSIX PARA PROCESOS LIGEROS (I) int pthread_create (pthread_t*, const pthread_attr_t*, void* (*func)(void*), void* arg ) Crea un proceso ligero que ejecuta func con argumentos arg y atributos attr Atributos (modificables mediante servicios) Tamaño de la pila Prioridad, Política de planificación etc. RETURN VALUE: 0-OK o ERRNUM void pthread_exit (void* value) Finaliza la ejecución e indica el estado de terminación pthread_t pthread_self (void) COMPARATIVA CON EXIT PARA PROCESOS? Devuelve el identificador del thread que realiza la llamada

68 SERVICIOS POSIX PARA PROCESOS LIGEROS (II) int pthread_join (pthread_t tid, void ** value_ptr) Suspende la ejecución de un thread JOINABLE hasta que termina el thread (a no ser que haya terminado) Devuelve el estado de terminación del thread en value_ptr según devuelto por pthread_exit o PTHREAD_CANCELED. RETURN VALUE: 0-OK int pthread_detach (pthread_t pid) Convierte un hilo en DETACHED en tiempo de ejecución RETURN VALUE: 0-OK #include <pthread.h> Linkar con pthread

69 Ejemplos: Hilos-Creación void* sumar_thread (void*) { int a=5; int b=8; cout<< la suma del hilo es: <<a+b<<endl; phtread_exit(null); } int main(void) { pthread_t thid; pthread_create(&thid, NULL, sumar_thread, NULL); if(pthread_join(thid,null)){ //0-OK cout<< Hilo joinable no terminado adecuadamente <<endl; } exit(exit_success); }

70 Ejemplos: Hilos-Paso de parámetros void* sumar_thread (void*param) { ssumandos* p=(ssumandos*) param; cout<< la suma del hilo es: <<p a +p b<<endl; phtread_exit(null); } struct ssumandos {int a; int b;} ; int main(void) { ssumandos sum; sum.a=10; sum.b=20; pthread_t thid; pthread_create(&thid, NULL, sumar_thread, &sum); pthread_join(thid,null); exit(exit_success); }

71 Ejemplos: Hilos-Comunicación (I) void* sumar_thread (void*param) { ssumandos* p=(ssumandos*) param; p a=8; p b=10; // modifica variable en bloque invocante phtread_exit(null); } struct ssumandos {int a; int b;} ; int main(void) { ssumandos sum; sum.a=10; sum.b=20; pthread_t thid; pthread_create(&thid, NULL, sumar_thread, &sum); pthread_join(thid,null); cout<< Los valores nuevo son: <<sum.a< : <<sum.b<<endl; exit(exit_success); }

72 Ejemplos: Hilos-Comunicación (II) void* sumar_thread (void*param) { ssumandos* p=(ssumandos*) param; ssumandos* pret=new ssumandos; pret->a=p a*2; pret->b=p b*2; //mod. de valores phtread_exit(pret); } struct ssumandos {int a; int b;} ; int main(void) { ssumandos sum; sum.a=10; sum.b=20; pthread_t thid; pthread_create(&thid, NULL, sumar_thread, &sum); void* ret_thread; pthread_join (thid, &ret_thread); ssumandos ret; ret.a=((ssumandos*) ret_thread) a; ret.b=((ssumandos*) ret_thread) b; cout<< Los valores devueltos son: <<ret.a< : <<ret.b<<endl; exit(exit_success); }

73 Ejemplos: Hilos-Comunicación (III) void* sumar_thread (void*param) { ssumandos* p=(ssumandos*) param; suma=p a + p b; phtread_exit(null); } struct ssumandos {int a; int b;} ; int suma=0; //variable compartida en memoria int main(void) { ssumandos sum; sum.a=10; sum.b=20; pthread_t thid; pthread_create(&thid, NULL, sumar_thread, &sum); pthread_join(null); cout<< La suma es: <<suma<<endl; exit(exit_success); }

74 Ejemplos: Hilos-DETACHED void* sumar_thread (void*param) { sleep(10); cout<< hilo terminado <<endl; phtread_exit(null); } int main(void) { pthread_t thid; pthread_create(&thid, NULL, sumar_thread, NULL); pthread_detach (thid); pthread_join(null); cout<< hilo principal terminado <<endl; exit(exit_success); }

75 SERVICIOS POSIX PARA PROCESOS LIGEROS (III) int pthread_attr_init (pthread_attr_t* attr) Inicializa la estructura de atributos de un thread a sus valores por defecto previstos por el S.O. RETURN VALUE: 0-OK Por defecto int pthread_attr_setdetachstate (pthread_attr_t* attr, int detachstate) Establece la forma de terminar de un proceso ligero Si detachstate = PTHREAD_CREATE_DETACHED el proceso ligero libera sus recursos cuando finalice su ejecución Si detachstate = PTHREAD_CREATE_JOINABLE no se liberan los recursos. Hay que utilizar pthread_join( ) En el caso general los hilos deberían ser generados como joinable (recomendado en el standard de POSIX) RETURN VALUE: 0-OK

76 SERVICIOS POSIX PARA PROCESOS LIGEROS (IV) int pthread_attr_setschedpolicy(pthread_attr_t* attr, int schedpol) Establece la política de planificación de un proceso ligero Tiene que tener la proiedad de PTHREAD_EXPLICIT_SCHED Si schedpol = SCHED_FIFO: política FIFO Si schedpol = SCHED_RR : política ROUND ROBIN int pthread_attr_setinheritsched (pthread_attr_t* attr, int inheritsched) Por defecto Establece la política de planificación en relación con el padre Si inheritsched = PTHREAD_EXPLICIT_SCHED se permite que tenga una política de planificación diferente a la del padre Si inheritsched = PTHREAD_INHERIT_SCHED se hereda la política de planificación del padre Por defecto

77 EJEMPLO JERARQUÍA DE THREADS (I) LIBRERÍA THREAD ATRIBUTOS

78 EJEMPLO THREADS (II) PASO DE PARÁMETROS? ATRIBUTO DETACHED ESPERA A TERMINACIÓN DE HIJOS

79 FIN DE SERVICIOS POSIX PARA HILOS