concurrencia - unr · es un estándar de implementación de threads en sistemas operativos...

Informática Electrónica

Concurrencia

DSI- EIE – FCEIA2015

DSI – EIE - FCEIA Informática Electrónica 2

¿Que es concurrencia?

Ejecución simultánea de dos o mas aplicaciones en una única plataforma de cómputo


¿Donde hay concurrencia?

● En una PC● En un smartphone● En un sistema de tiempo real tipo automóvil● En un dispositivo de comunicaciones digitales● En un Raspberry PI● En un PLC● ...


¿Cuando se manifiesta la concurrencia?

● Dos o mas programas intentando acceder simultáneamente a un recurso compartido– Una variable en memoria

– Un puerto de E/S

– Un dispositivo

– ...


Procesos

● Son la materialización del concepto “programa en ejecución”

● Son creados por el sistema operativo (cuando existe), por el firmware del dispositivo de cómputo ante la ocurrencia de un evento, por otro proceso o por un usuario

● Disponen de un “contexto”, que es el conjunto de recursos que permiten su funcionamiento


Procesos

● Tres áreas de memoria exclusivas:– Stack: pila para alojar

llamadas a funciones

– Text: código del programa

– Data: almacenamiento de variables estáticas

– Heap: almacenamiento de variables dinámicas Fuente: https://computing.llnl.gov/tutorials/pthreads


Contexto

● Contador de programa● Registros del procesador● Punteros y áreas de memoria asignada● PID, UID y GID: identificadores únicos de

proceso, usuario y grupo● Prioridad y permisos


Estados de un proceso

● Los procesos están en “estados” completamente determinados temporalmente– Listo

– Suspendido

– En ejecuciónListo Suspendido

En Ejecución

Creación Finalización


Estados de un proceso

● En un dispositivo con procesador único, sólo un proceso está activo en un instante determinado. El resto de los procesos creados están suspendidos o listos

● En un dispositivo con múltiples procesadores -ej. un micro multicore- pude haber mas de un proceso activo en un instante dado


Threads

● Dentro de un proceso pueden coexistir dos o mas “hilos de control”, secuencias ordenadas de instrucciones, rutinas o funciones que se ejecuten concurrentemente Fuente: https://computing.llnl.gov/tutorials/pthreads


Threads y Procesos

● Un proceso puede crear, ejecutar y destruir múltiples threads

● Todos los threads creados por un proceso comparten un mismo espacio de memoria (el del proceso que las creó), es decir, pueden acceder a las variables globales de ese proceso

● Cada thread tiene además un espacio privado de memoria, separado del resto


Threads: memoria

Fuente: https://computing.llnl.gov/tutorials/pthreads


¿Cuándo usar threads?

● Cuando un programa permite una descomposición paralela, es decir:– Las tareas pueden ejecutarse paralelamente

– Los datos que se procesan permiten acceso concurrente

– Hay interacción significativa con los canales de entrada/salida

– Se deben procesar eventos asincrónicos

– Se puede jerarquizar el trabajo


¿Cuándo usar threads (ii)?

Fuente: https://computing.llnl.gov/tutorials/pthreads


¿Cuándo usar threads (iii)?

● Básico: cuando un programa debe enviar y recibir datos por un puerto serie y a la vez interactuar con el usuario

● Avanzado: un programa que debe ejecutar cálculo numérico sobre un conjunto de datos, tales como una manipulación de imágenes

● Siempre que se requiera paralelismo


¿Cómo usar threads?

● Necesitamos un soporte del sistema operativo y/o el lenguaje de programación

● Si la plataforma de hardware es monoprocesador, los threads serán ejecutados (despachados) en un modelo de “tiempo compartido” (pseudo-paralelismo)

● Si la plataforma es multiprocesador puede haber paralelismo real


Pthreads

● Es un estándar de implementación de threads en sistemas operativos conformantes con POSIX, como Linux, Solaris, AIX, Unix, Mac OS, etc.

● Es un API con la forma de librería de funciones de lenguaje “C”

● Fue especificada por primera vez en el estándar POSIX 1003.1c de 1995

● Hay implementaciones de esta API para múltiples sistemas operativos, entre ellos, Windows y Linux


Pthreads API

● Es una colección de funciones en lenguaje C que permiten:– Crear, ejecutar y finalizar threads

– Sincronizar ejecución de threads

– Administrar recursos de threads

● El header a incluir es <pthread.h>

● Todas las funciones comienzan con el prefijo pthread_


Creación y finalización de threads

● pthread_create(pthread_t *thread, const pthread_attr_t *attr,

void *(*start_routine) (void *),

void *arg)

– Crea un thread a partir de la función start_routine con los argumentos apuntados por arg

● pthread_exit(void *status)– Usado por un thread para finalizar su ejecución

● pthread_cancel(pthread_t thr)– envía un pedido de cancelación (terminación) al thread thr

http://man7.org/linux/man-pages/man3/pthread_create.3.html

http://man7.org/linux/man-pages/man3/pthread_exit.3.html

http://man7.org/linux/man-pages/man3/pthread_cancel.3.html


Ejemplo de pthread_create()

void *print_message_function( void *ptr );

main(){ pthread_t thread1; char message1[80]; iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1);

...


Paso de argumentos

● El último argumento de pthread_create() es un puntero a void, y se usa para pasar por referencia argumento(s) al thread a crear:

pthread_create(thread, attr, rutina, void *args)

● Ejemplo desarrollado en computing.llnl.gov/tutorials/pthreads

https://computing.llnl.gov/tutorials/pthreads/#PassingArguments


Sincronización

● Hay situaciones donde se requiere sincronizar dos o mas threads, por ejemplo:– El thread que muestra datos en pantalla debe

esperar que estos lleguen por el puerto serie

– El thread que procesa tramas de video debe esperar la transformación que producen otros threads para mostrar en pantalla

– ...


Sincronización en Pthreads

● El API Pthreads brinda varios mecanismos para obtener sincronización, uno de ellos es la operación join:– pthread_join() permite que un thread “espere”

hasta la finalización de otro

– En el ejemplo pthreads1.c puede verse que la función main() crea dos threads y luego espera que terminen con pthread_join()


Exclusión mutua (mutex)

● Mutex es el acrónimo de MUTual EXclusion (exclusión mutua)

● Un mutex es una variable utilizada para proteger datos compartidos, por ejemplo, un arreglo o un puerto de E/S

● Actúa como una llave cuya posesión permite a un thread acceder al recurso compartido mientras los demás threads que intenten hacerlo concurrentemente son bloqueados

● Un mutex se adquiere y se libera


Mutex: ejemplo

● Caso típico de aplicación: “competencia” entre dos threads para actualizar un contador:

Thread 1 Thread 2 contador

LeerContador(): 5 5

LeerContador(): 5 5

IncrementarContador() 6

IncrementarContador() 6

tiempo


Solución con mutex

● Ambas threads antes de leer el contador deben “adquirir” una variable tipo mutex, única, que “protege” al contador:

pthread_mutex_lock (&mutex1);v1 = LeerContador();v1++;IncrementarContador(v1);pthread_mutex_unlock (&mutex1);


Funciones Mutex

● Las variables mutex deben declararse e inicializarse antes de su utilización, generalmente se hace en el main() antes de crear los threads

● Cuando se termina de utilizar debe destruirse mediante otra función del API

● Cuando un thread intenta adquirir un mutex que ya está “ocupado” se bloquea salvo que use la función pthread_mutex_trylock()


API de mutex

int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

https://computing.llnl.gov/tutorials/pthreads/man/pthread_mutex_init.txt

https://computing.llnl.gov/tutorials/pthreads/man/pthread_mutex_init.txt

https://computing.llnl.gov/tutorials/pthreads/man/pthread_mutex_lock.txt




Variables de Condición

● Hay situaciones donde la ejecución de un thread está ligada al cumplimiento de una condición determinada, por ejemplo, que una variable alcance determinado valor

● Por ejemplo, dos threads que reciben datos y los van almacenando en memoria, mientras que un tercero, que procesará los datos recibidos, espera que se alcance un mínimo necesario


Variables de Condición

● API:

● Ejemplo: condvar.c desarrollado en computing.llnl.gov

int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr);int pthread_cond_destroy(pthread_cond_t *cond);int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);int pthread_cond_signal(pthread_cond_t *cond);

https://computing.llnl.gov/tutorials/pthreads/#ConVarOverview


Conclusiones

● Los threads permiten explotar el paralelismo para maximizar performance y atender múltiples tareas simultáneas

● No todos los problemas admiten descomposición paralela

● Para usar threads necesitamos soporte del sistema operativo, la plataforma y el lenguaje de programación

concurrencia - unr · es un estándar de implementación de threads en sistemas operativos...

Documents