75-62 Técnicas de Programación Concurrente II 2004 Threads - C y Perl

Transcripción

1 FIUBA Técnicas de Programación Concurrente II 2004 Threads - C y Perl Ing. Osvaldo Clúa Bibliografía: man de Linux, perlthrtut Wagner Dosley: "Getting started with Posix Threads" Andrae Muy B:A Pthreads Tutorial. (disponibles en Internet) Un buen libro (algo teórico) es Andrews: Foundations of Multithread, parallel and Distributed programming. Puede haber material que ayude en las páginas de sus clases en Threads Una thread es una abstracción del flujo de control de un proceso. Cada thread tiene su propia ejecución, valor del Contador de Programa, Estado y registros. En general hay dos modelos de threads: system wide y user space. Las p-threads o threads posix son un ejemplo de un sistema systme wide de threads en la que el propio sistema operativo se hace cargo de la planificación; en cambio, en perl los threads son una biblioteca que corre en el espacio del usuario. Un programa c/c++ que usa threads requiere: 1. incluir pthread.h 2. declarar variables del tipo pthread_t 3. crear un thread con pthread_create 4. un thread termina su ejecución llamando a pthread_exit( ) Como ejemplo de C ++ 1.#include <pthread.h> 2.#include <iostream> 3.#include <unistd.h> 4.using namespace std; 5. 6.// En Linux, a pesar de que cada thread es un proceso separado 7.// se ve que comparte memoria (con algo de debug) 8.// compilar con -lpthread int variable_compartida; void *func(void *arg){ 13. extern int variable_compartida; 14. int ret=1; 15. for (int i=0; i<10;i++) 16. variable_compartida++; 17. cout<<"proceso "<<getpid()<<", thread

2 "<<pthread_self() 18. <<", variable_compartida "<<variable_compartida<<endl 19. <<", &variable_compartida "<<&variable_compartida<<endl; 20. pthread_exit(reinterpret_cast<void *>(&ret)); int main(){ 23. pthread_t th1,th2; 24. extern int variable_compartida; 25. int *retorno; 26. variable_compartida=0; 27. pthread_create(&th1,null,func,null); 28. pthread_create(&th2,null,func,null); 29. for(int i=0;i<10;i++) 30. variable_compartida++; 31. pthread_join(th1,reinterpret_cast<void **> (&retorno)); 32. cout <<"Termino th1 con "<<*retorno<<endl; 33. pthread_join(th2,reinterpret_cast<void **> (&retorno)); 34. cout <<"Termino th2 con "<<*retorno<<endl; 35. cout<<"variable_compartida vale "<<variable_compartida<<endl; 36. cout<<"proceso "<<getpid()<<", thread "<<pthread_self() 37. <<", variable_compartida "<<variable_compartida<<endl 38. <<", &variable_compartida "<<&variable_compartida<<endl; 39. Si bien la ejecución de este programa muestra dos números de proceso, en el código se ve claramente que se trata de un único proceso compartiendo memoria. Una thread tiene atributos que se acceden por medio de las funciones que comienzan con pthread_attr y se pasan como segundo argumento de pthread-create. (No se pueden usar para cambiar los atributos de una thread que esté corriendo). En perl las threads son objetos (es decir, blessed references) y su implementación se conoce como ithreads (threads del intérprete). Las variables compartidas deben declararse antes de la declaración de la función. como ejemplo: 1. #! /usr/bin/perl 2. # 3. # Atencion: perl debe haber sido compilado con threads. 4. # Busque una distribucion asi preparada para probar este ejemplo -2-

3 5. # 6. use English; 7. use threads; 8. use threads::shared; my $var_comp:shared=0; 11.my $var_propia=0; sub sub1 { 14. for ($i=0;$i<10;$i++){ 15. $var_comp++;$var_propia print "En el thread ",threads->self->tid()," proceso $PID \$var_comp = $var_comp y \$var_propia=$var_propia \n" $thr1 = threads->create(\&sub1); 21.$thr2 = threads->create(\&sub1); 22.@r1=$thr1->join; 23.@r2=$thr2->join; 24.print "En el thread ",threads->self->tid()," proceso $$ \$var_comp = $var_comp y \$var_propia=$var_propia \n"; Semáforos Con el #include <semaphore.h> se incluyen en el código los semáforos POSIX que no deben confundirse con los de System V vistos en TPC1. Las operaciones de estos semáforos controlan recursos compartidos entre threads: int sem_init(sem_t *sem, int pshared, unsigned int value); int sem_wait (sem_t * sem); int sem_trywait(sem_t * sem); int sem_post(sem_t * sem); int sem_getvalue(sem_t * sem, int * sval); int sem_destroy(sem_t * sem); En Perl se usa la clase Thread::Semaphore y un ejemplo de productor consumidor sería: 1.#! /usr/bin/perl 2.#Productor consumidor conthreads y semaforos 3.# 4.use English; 5.use threads; -3-

4 6.use threads::shared; 7.use Thread::Semaphore; my $vacio= Thread::Semaphore->new(3); 11.my $lleno= Thread::Semaphore->new(0); 12.sub Produce{ 13. for ( $i=0;$i<10;$i++){ 14. $vacio->down; 15. $buffer[$i%3]=$i*100+9; 16. $lleno->up; print "Productor terminado\n"; sub Consume{ 22. for ( $i=0;$i<10;$i++){ 23. $lleno->down; 24. $x=$i%3; 25. print "Consumido \$buffer[$x]=$buffer[$x]\n"; 26. $vacio->up; print "Consumidor terminado\n"; print "Comienza el programa\n"; 32.$thr1 = threads->create(\&produce); 33.$thr2 = threads->create(\&consume); 34.@r1=$thr1->join; 35.@r2=$thr2->join; Ejercicios simples en C++ y Perl 1. Atomic Broadcast: Solucione el problema de un productor y n consumidores, para un buffer de b posiciones. 2. Filósofos jugadores. Cada filósofo antes de tomar un tenedor arroja una moneda.... Detectar e indicar cuando hubo deadlock. 3. Agua Átomos de Hidrógeno y Oxígeno vagan por el espacio (es decir, duermen un número al azar de tiempo) buscándose mutuamente para formar Agua. Cuando un átomo de Oxígeno está listo entra en el proceso Oready del que solo saldrá como Agua. Un átomo de Hidrógeno entra en Hready, del que solo saldrá como agua. Cuando se produce el encuentro de dos H y un O. alguno de los átomos (posiblemente el de O) llama a HacerAgua. Al terminar HacerAgua los tres átomos terminan su llamado. No debe haber busy wait ni deadlock ni starvation. -4-

5 Debe resolver cada ejercicio en ambos lenguajes. Exclusión mutua En pthreads, la estructura de exclusión mutua es el mutex. pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; pthread_mutex_t errchkmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex); int pthread_mutex_destroy(pthread_mutex_t *mutex); Un fastmutex no tiene memoria, en cambio un recmutex sí. Un recmutex puede comportarse como un semáforo, peor pertenece ala biblioteca pthread. El equivalente en Perl es el lock( ) que se debe aplicar sobre una variable shared. No impide el acceso a la variable, solo bloquea algún otro lock. En perl no hay unlock( ) se termina el lock al salir del bloque en que se inició. Un ejemplo en C++ 1. // thread/admin.cc 2. #include <pthread.h> 3. #include <iostream> 4. #include <unistd.h> 5. using namespace std; 6. // 7. //Administrador de un recurso único 8. // pthread_mutex_t mutex=pthread_mutex_initializer; void *usar(void * p){ 13. pthread_mutex_lock(&mutex); 14. cout<<"proceso "<<getpid()<<", thread "<<pthread_self() 15. <<" en control, una tecla para salir"<<endl; 16. cin.get(); 17. pthread_mutex_unlock(&mutex); 18. pthread_exit(0); int main(){ 21. pthread_t th1,th2,th3; 22. pthread_create(&th1,null,usar,null); 23. pthread_create(&th2,null,usar,null); 24. pthread_create(&th3,null,usar,null); 25. pthread_join(th1,null); 26. pthread_join(th2,null); 27. pthread_join(th3,null); 28. exit(0); -5-

6 Condiciones Un mutex sólo puede ser librado por la thread que hizo el lock. Las variables de condición permiten ceder el control hasta que algún predicado sobre un área compartida se cumpla. En C/C++ las operaciones sobre éstas variables son: pthread_cond_t cond = PTHREAD_COND_INITIALIZER; int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr); int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); int pthread_cond_destroy(pthread_cond_t *cond); Los atributos pthread_condattr_t no están implementados en la versión Linux de pthreads, por lo que son ignorados. La interacción con los mutex se vé en el segundo parámetro de int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) Una thread que quiere esperar debe primero hacer un pthread_mutx_lock (&mutex) y después ejecutar pthread_cond_wait(&cond,&mutex). Entonces la thread libera al mutex y espera la cond. Cuando se la libere volverá a tomar al mutex. La thread que libera, después de testear la cond, hará un pthread_cond_signal(&cond) despertando a una thread que se encuentre en estado de espera (si la hay), pero retiene el mutex. También puede optar por hacer un pthread_cond_broadcast(&cond) liberando a todas las que estuvieran esperando, sin embargo las recién despiertas se secuencializarán al re-entrar en el mutex. Siguiendo atentamente el ejemplo que sigue en C++ puede entenderse el funcionamiento: 1.// thread/cond.cc 2.#include <pthread.h> 3.#include <iostream> 4.#include <unistd.h> 5.using namespace std; 6. 7.// 8.//prueba de las variables de condicion 9.// pthread_mutex_t mutex=pthread_mutex_initializer; 12.pthread_cond_t uno, dos; -6-

7 void* lathread(void * arg){ // volvamos el parámetro a su clase original 17. int a=*reinterpret_cast<int*> (arg); 18. pthread_mutex_lock(&mutex); 19. cout<<"soy la thread "<<pthread_self()<<" con arg=" 20. <<a<<" teniendo el mutex."<<endl; 21. pthread_cond_wait(&uno,&mutex); 22. cout<<"soy la thread "<<pthread_self()<<" con arg=" 23. <<a<<" ya paso la cond uno y espero la dos."<<endl; 24. pthread_cond_wait(&dos,&mutex); 25. cout<<"soy la thread "<<pthread_self()<<" con arg=" 26. <<a<<" ya paso la dos y me voy."<<endl; 27. pthread_mutex_unlock(&mutex); int main(){ 31. pthread_t th[5]; 32. cout<<"proceso principal, un broadcast a dos que deberia perderse. "<<endl; 33. pthread_cond_broadcast(&dos); 34. for (int i=1;i<=5;i++){ 35. pthread_create(&th[i-i], NULL,laThread,static_cast<void*>(&i)); for (int i=1;i<=5;i++){ 38. cout<<"main: con [enter] hago signal cond uno por vez "<<i<<endl; 39. cin.get(); 40. pthread_cond_signal(&uno); cout<<"main: con [enter] hago signal cond dos con broacast."<<endl; 43. cin.get(); 44. pthread_cond_broadcast(&dos); 45. for (int i=1;i<=5;i++){ 46. pthread_join(th[i-1],null);

8 En Perl, las funciones cond_signal, cond_wait y cond_broadcast pueden aplicarse a cualquier variable que tenga un lock. No existe entonces la distinción entre cond y mutex que hace pthreads. El ejemplo anterior quedaría como sigue (note que al no haber unlock debe usarse un bloque adicional, pruebe que pasa si no se usa ese bloque). 1.#! /usr/bin/perl 2.# 3.# Atencion: perl debe haber sido compilado con threads. 4.# Busque una distribucion asi preparada para probar este ejemplo 5.# 6.use English; 7.use threads; 8.use threads::shared; my $uno:shared; 11.my $dos:shared; sub lathread { 15. my $arg=$_[0]; 16. { #bloque del lock uno 17. lock $uno; 18. print "Thread ",threads->self->tid()," con argumento $arg teniendo el lock de uno.\n"; 19. cond_wait $uno; 20. print "Thread ",threads->self->tid()," con argumento $arg ya paso la uno y espero la dos.\n"; lock $dos; 23. cond_wait $dos; 24. print "Thread ",threads->self->tid()," con argumento $arg ya paso la dos y me voy.\n"; print "Main: un broadcast a dos que deberia perderse.\n"; 28. cond_broadcast $dos; for ($i=0;$i<5;$i++){ 31. $thr[$i] = threads->create(\&lathread,($i)); 32.for ($i=0;$i<5;$i++){ 33. print "Main: con [enter] hago cond_signal \$uno por -8-

9 vez ", $i+1,".\n"; 34. $a=<>; 35. cond_signal $uno; print "Main: con [enter] hago cond_broadcast \$dos.\n"; 38.$a=<>; 39.cond_broadcast $dos; 40. for ($i=0;$i<5;$i++){ 41. $thr[$i]->join; Mas ejercicios simples en C++ y Perl (usando locks y conditions) 4. El puente: Un puente de una sola mano tiene extremos norte y sur por donde arriban vehículos en ambas direcciones. Los vehículos que van en la misma dirección puede cruzar el puente juntos, pero no simultáneamente con otro que viene en la dirección opuesta. Modele los vehículos como procesos y programe este comportamiento, sin dar prioridad a ninguna dirección (aunque pueda darse que un tipo de autos no cruce nunca por tráfico continuo). 5. Atomic broadcast. El mismo problema de antes, pero use condiciones y fast mutex, no use mutex recursivos que funcionan como semáforos 6. Cuenta corriente: Una cuenta corriente se maneja desde muchos lugares con operaciones de retiro y deposito. Su balance nunca debe ser negativo. Un deposito no se demora nuca, pero un retiro debe esperar a que haya fondos suficientes. Debe resolver cada ejercicio en ambos lenguajes. Principios de Algoritmia Concurrente. Barrier Synchronization: Esta técnica consiste en utilizar algoritmos iterativos que calculan sucesivamente una mejor aproximación a la respuesta buscada. En general cada algoritmo manipula un arreglo de valores y ejecuta los mismos cálculos varias veces sobre este arreglo. Este arreglo se parte en porciones y una thread se encarga de cada porción. Un esquema general sería: Worker (i) { // hay n Workers repeat{ <cálculo sobre el conjunto i> esperar a que terminen los n Workers La barrera puede aparecer en cualquier parte del lazo, y pude4e, además, marcar un momento de comunicación ya sea entre workers o entre los workers y el coordinador. Esta técnica se usa para implementar los dos esquemas que se ven a continuación: Parallel Computation: Consiste en efectuar los mismos cálculos sobre distintos conjuntos de datos. Por ejemplo: cálculo de prefijos. -9-

10 Es frecuente aplicar una operación a todos los elementos de un arreglo en la forma que se conoce como reduce o scan en algunos lenguajes. Por ejemplo, el scan del arreglo [1; 2; 4; 5] es un arreglo con los elementos [1; 1+2; 1+2+4; ] Al último elemento se lo conoce como el reduce. Una aplicación inmediata es el cálculo de probabilidades acumuladas. Un algoritmo paralelo sería: Valor inicial: [1;2;3;4;5,6] 1) Hallar todas las sumas de los elementos vecinos. (2**0) Iteración 1: [1;3;5;7;9;11] 2) Hallar todas las sumas de los elementos de distancia 2. (2**1) Iteración 2: [1;3;6;10;14;18] 3) Hallar todas las sumas de los elementos de distancia 4. (2**2) Iteración 4:[1;3;6;10;15;21]... y después de ceil(log2 (n)) en nuestro caso: ceil(log2(6)) = ceil(2.585) = 3 iteraciones llegamos al resultado. Este algoritmo debe usar una barrera para impedir interferencias y es válido con cualquier operador asociativo. Bag of Tasks En este caso, el número de workers es fijo cada uno toma una tarea de la valija y la ejecuta, posiblemente generando mas tareas. Worker (){ repeat{ <tomar una tarea de la valija> if (no-hay-mas) break; <ejecutar la tarea> Es una inversión de la recursividad (acá lo que es recursivo es la cantidad de tareas) y es escalable frente a la posibilidad de agregar procesadores. Como ejemplo, podemos usar la multiplicación de matrices de nxn, por ejemplo A x B= C. Esta operación se divide en n**2 productos internos, uno para cada combinación de una fila de A y columna de B. Como primer aproximación podemos supones que tenemos menos de n procesadores disponibles. Entonces cada tarea se resume en encontrar la fila f de la matriz resultado C. En la valija hay n tareas. Podemos representar la valija por una variable proxfila e indicar que se tomó una tarea sumándole 1. Termina al haber procesado las n filas. proxfila=0; A[n,n]; B[n,n];C[n,n]; Worker (){ int fila; repeat{ fila=proxfila; proxfila++; if (fila >=n) break; -10-

11 <calcular C[fila,*]; En este ejemplo no hay barreras. Ejercicios ( No los adivinó?) Los siguientes dos ejercicios deben resolverse cada uno en un lenguaje diferente. 7. Programe en C++ o Perl el problema de scan/reduce para un operador asociativo parámetro (oportunidad para lucirse en oop o generics). 8. Programe en Perl o C++ el problema de la multiplicación de matrices. -11-