Materia: Técnicas Digitales 3 THREADS Materia: Técnicas Digitales 3 Autor: Jonathan Rubstein

Índice Procesos Ciclo de vida Scheduling Sincronización Señales Atributos Funciones Ejemplos Autor: Jonathan Rubstein

Procesos – Definiciones Procesos pesados: Procesos livianos: Los procesos no comparten ninguna porción de la memoria entre si. Cada uno se ejecuta en su propio procesador virtual con CPU y memoria. Todos ellos comparten el mismo espacio de almacenamiento permanente (el disco). Necesita una MMU para su uso. Los procesos livianos comparten la memoria pero tienen su propia CPU virtual. Autor: Jonathan Rubstein

Procesos – Procesos livianos Se pueden tener varios en una misma área de memoria. El tiempo de creación es 10 a 100 veces menor comparado con la creación de procesos pesados. Se destruyen con mayor rapidez. El context switch es más rápido. Se comunican entre si con mayor facilidad. Reducen la seguridad. Autor: Jonathan Rubstein

Procesos - estructuras Cada tipo de proceso tiene su propia estructura de datos, en la cual guarda la información necesaria para su control. PCB ( process control block ) o task_struct pid y ppid. Prioridad. Dirección al proximo pcb. Stacks y Registros. Estados del proceso. Datos para ipc. File descriptors varios. Restricciones y permisos. TCB ( Thread control block ) Thread id. Estado. Registros de CPU. Stack pointer. Program counter. Signal mask Autor: Jonathan Rubstein

Ciclo de vida Just create: Se instancia el thread pero todavía esta activo. Runnable: El thread esta esperando a que el scheduler le de su slot correspondiente. Running: El thread se esta ejecutando. Blocked: Se esta ejecutando una función bloqueante, ya sea operaciones de E/S o métodos de sincronización. Dead: Termino su función o surgió un error que para el thread. Autor: Jonathan Rubstein

Scheduling Cada thread tiene su juego de parámetros para el scheduler. Puede ser cargados antes o después de su creación. La política utilizada para cuando se bloquea la ejecución por un mecanismo de sincronización se define cuando se crea dicho mecanismo. Para definir los quantum de tiempo se tienen en cuenta la prioridad, el estado y la métrica entre otras variables. La métrica refiere al comportamiento del thread. Por ejemplo, estaba esperando un evento que acaba de llegar. En cuanto al context switch, los procesos livianos tiene menor tiempo de cambio debido a que se guardan menos datos. Se introduce la función yield() que fuerza el cambio de contexto. Autor: Jonathan Rubstein

Sincronización – El porque Los procesos livianos comparten todo su acceso a memoria por lo tanto se crean race condition constantemente. Al igual que los semáforos en ipc se debe prevenir la escritura y lectura recurrente. Se puede bloquear un thread hasta que se de una condición especifica. Autor: Jonathan Rubstein

Sincronización – Mecanismos Mutex ( Mutual exclusion lock ) Similar al semaforo de ipc. Bloquea el flujo hasta que es liberado. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER Join Espera a que termine un thread especifico. condition variables Bloquean un thread hasta que otro cumple la condición. Puede despertar a un thread que este esperando o a todos aquellos que esten bloqueados por la condicion. pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER Autor: Jonathan Rubstein

Sincronización - DeadLocks Mutex void *function1(){… pthread_mutex_lock(&lock1); - Execution step 1 pthread_mutex_lock(&lock2); - Execution step 3 DEADLOCK!!! ... pthread_mutex_lock(&lock2); pthread_mutex_lock(&lock1); } void *function2() { ... pthread_mutex_lock(&lock2); - Execution step 2 pthread_mutex_lock(&lock1); pthread_mutex_lock(&lock1);pthread_mutex_lock(&lock2); ... } main() { ... pthread_create(&thread1, NULL, function1, NULL); pthread_create(&thread2, NULL, function1, NULL); ... } Autor: Jonathan Rubstein

Señales Se configura que señal puede recibir cada thread. int pthread_sigmask(int how, const sigset_t *newmask, sigset_t *old- mask); Posibilidades: SIG_SETMASK, SIG_BLOCK, SIG_UNBLOCK Se puede enviar una señal especifica a un thread en particular. int pthread_kill(pthread_t thread, int signo); Es posible bloquear un thread hasta que llegue una señal activada en el set indicado. int sigwait(const sigset_t *set, int *sig); Para cambiar el handler se utiliza: int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); Autor: Jonathan Rubstein

Atributos Los atributos son las propiedades. Son del tipo pthread_attr_t. Se les asignan al crear el thread. Si al lanzarlo los atributos son nulos se le otorga los definidos por defecto. Definen el estado de espera ( join ), quien lo controla ( scope ),la política para el scheduler, prioridad, entre otros. Para destruirlos se usa pthread_attr_destroy(). Autor: Jonathan Rubstein

Funciones - 1 Crea un thread. int pthread_create(pthread_t *tid ,pthread_attr_t *attr,void *(*func)(void*), void *arg); Espera por la finalizacion de un thread que no sea detach. int pthread_join(pthread_t tid, void **status) Configura al thread para liberar los recursos usados al terminar. int pthread_detach(pthread_tic) Termina la ejecución. void pthread_exit(void *status) Devuelve el thread id. pthread_t pthread_self(void) Autor: Jonathan Rubstein

Funciones - 2 Copia los argumentos por defecto a atributo. int pthread_attr_init(pthread_attr_t* atributo) Destruye la varible atributo. int pthread_attr_destroy(pthread_attr_t * atributo) Compara dos thread id (devuelve cero si son distintos). int pthread_equal(pthread_t tid1, pthread_t tid2) Cancela la ejecucion del thread indicado. int pthread_cancel(pthread_t tid) Autor: Jonathan Rubstein

Funciones - 3 Si el mutex esta libre lo bloquea, sino para la ejecución hasta que este libre. int pthread_mutex_lock (pthread_mutex_t *mutex) Trata de bloquar el mutex, si esta ya esta tomado devuelve un EBUSY. int pthread_mutex_trylock (pthread_mutex_t *mutex) Si el thread esta bloqueado lo libera. int pthread_mutex_unlock (pthread_mutex_t *mutex) Destruye el mutex. int pthread_mutex_destroy (pthread_mutex_t *mutex) Autor: Jonathan Rubstein

Funciones – 4 Bloquea hasta que se cumple la condición. int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex) Despierta a un thread que este dormido por cond_wait. int pthread_cond_signal (pthread_cond_t *cond) Despierta a todos los thread dormidos. int pthread_cond_broadcast (pthread_cond_t *cond) Destruye a la variable cond. int pthread_cond_destroy (pthread_cond_t *cond) Autor: Jonathan Rubstein