S.O.: Concurrencia 2

Transcripción

1 Gorka Guardiola Laboratorio de Sistemas, Grupo de Sistemas y Comunicaciones, URJC 17 de febrero de 2010

2 (cc) 2008 Grupo de Sistemas y Comunicaciones. Algunos derechos reservados. Este trabajo se entrega bajo la licencia Creative Commons Attribution-ShareAlike. Para obtener la licencia completa, véase También puede solicitarse a Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

3 Evitar la espera activa Desperdicia procesador Latencia vs carga procesador No es justa (no es FIFO, sino casi aleatoria) Puede haber inanición, starvation, no en teoría, pero en la práctica sí (ejecuta al cabo de mucho) Evitar la contienda (contention), mantener las regiones críticas pequeñas Pero y si podemos evitarla del todo...?

4 Evitar la espera activa Nos puede ayudar el planificador Qué pasaba con un proceso cuando yo llamaba a sleep()? Bloquear un proceso Despertar un proceso

5 Bloquear un hilo de ejecución Para evitar espera activa: mecanismo para bloquear un proceso Primitiva de sincronización: llamada al sistema (en el kernel) o de librería Bloquear un proceso cambia el estado a bloqueado se le echa del procesador Despertar un proceso cambia el estado a listo para ejecutar

6 Bloquear un proceso Se puede hacer con un pipe Para un proceso lo pongo a leer (ojo, no escribo: buffering) Para despertar a uno escribo en el pipe

7 Rendezvous, cita llamada al sistema rendezvous(2) void* rendezvous(void* tag, void* value) Entre dos (cita romántica) es simétrica, el primero que llega se bloquea garantiza: que lo de antes se ha ejecutado en los dos procesos se usa un identificador, tag, (identifica una pareja) intercambian dos valores

8 Rendezvous, cita Proceso 1 Proceso 2 RENDEZVOUS Tag = 3 Valor = 84 TODO LO DE ANTES DEL RENDEZVOUS SE HA EJECUTADO DESPUES DE QUE AMBOS RETORNEN No hay nadie bloqueado en el Tag 3: se queda en Rendez RENDEZVOUS Tag = 3 Valor = 84 Como ya hay uno en Tag = 3 en estado Rendez (bloqueado) se desbloquean los dos

9 variable local void *val, *oval, *tag; tag = (void *)38; if (rfork(rfproc RFMEM) == 0) { print("hijo: antes"); val = (void *)1; oval = rendezvous(tag, val); print("hijo: despues %p\n", oval); } else{ print("padre: antes\n"); val = (void *)0; oval = rendezvous(tag, val); print("padre: despues %p\n", oval); }

10 Rendezvous, cita Qué se usa en tag? normalmente un puntero reservado antes con malloc un valor único para esta pareja acordado espacio de tags diferente en cada grupo creado con rfork con la flag RFREND

11 Rendezvous, cita Qué se usa en el valor? un valor que quiero intercambiar normalmente intercambio punteros, el valor del puntero, no su contenido.

12 qlock Interfaz igual que el de lock estos son justos (tienen una cola, por eso la q) no hacen espera activa, usan rendezvous

13 Ejemplo de uso de qlock //me declaro QLock l; como variable global if (rfork(rfproc RFMEM) == 0) { qlock(&l); i++; print("%#p %d\n", &i, i); qunlock(&l); } else{ qlock(&l); i++; print("%#p %d\n", &i, i); qunlock(&l); }

14 qlock v.s. lock Latencia: acotada con qlock, aunque más alta si no hay contienda Sleep vs Rendez Orden Fifo vs orden Aleatorio qlock si funciona con threads (hay una implementación de rendezvous para threads)

15 qlock: implementación lista enlazada hago rendezvous en los punteros

16 qlock: implementación 0x x2e003 LOS TAGS DE RENDEZVOUS SON LAS DIRECCIONES Por ejemplo, en este qlock hay un proceso bloqueado en rendezvous(0x37032, 0); 0x3703e 0x x x3703a 0x3704a 0x3703e 0x x x3704a 0x3704e 0x x37056

17 Barrera otra primitiva de sincronización como rendezvous pero para N procesos se van bloqueando hasta que hay N, cuando hay N se desbloquean

18 Barrera de 4, ejemplo P1 P2 P3 P4 barrier(4, b) barrier(4, b) barrier(4, b) Cuando llega el cuarto vuelven a ejecutar todos barrier(4, b) tiempo

19 Semáforos (semaphores, seinpalen, 1965 Dijkstra) Otra primitiva de sincronización Más general Como un cuenco de fichas con N fichas (puede empezar a 0) Coger ficha (si no hay fichas, espero), wait, down, acquire, P (probeer) Soltar ficha (si alguien esperando, le despierto), signal, up, release, V (verhoren, verlaag) No hay inanición (no necesariamente fifo aunque es una forma de hacerlo) No hay un número máximo de fichas en el cuenco

20 Semáforos en Plan 9 int semacquire(long *addr, int block); long semrelease(long *addr, long count);

21 Semáforos (semaphores, seinpalen, 1965 Dijkstra) block puedo suponer que siempre es 1 addr es la dirección del long que representa el semáforo count es el número de fichas para poder soltar más de una ficha a la vez

22 Semáforos: usos Para que sólo entre uno en la región crítica Se inicializa a 1 Se llama mutex Similar a un lock down() lock() up() unlock()

23 Ejemplo de uso de mutex //globales long sem = 1; //local if (rfork(rfproc RFMEM) == 0) { down(&sem, 1); i++; up(&sem, 1); } else{ down(&sem, 1); i++; up(&sem, 1); }

24 Semáforos: usos Para que sólo entren N en la región crítica Se inicializa a N down() antes de entrar up() al salir

25 Semáforos: usos Para esperar Se inicializa a 0 down() para esperar up() para levantarlo

26 Ejemplo de uso de semáforo para esperar //globales long sem; //local if (rfork(rfproc RFMEM) == 0) { print("hijo antes\n); down(&sem, 1); //espero print("hijo despues\n); } else{ print("padre antes\n); up(&sem, 1); print("padre despues\n); }

27 Cómo implemento semáforos? Con pipes up(): escribir en el pipe down(): leer del pipe Puedo usar rendezvous(2) como con qlock(2) Necesito un contador de fichas (ojo, compartido, proteger con locks)

28 El problema de los lectores escritores Región crítica con dos tipos de hilos que acceden Un tipo de hilos lectores pueden acceder varios a la vez Otro escritores sólo puede acceder uno Hay exclusión mutua entre ambos tipos (o lectores o escritores) Otra forma de verla es dos tipos de formas de coger un cierre

29 Solución 0 (mala) un mutex para la región crítica sólo puede entrar un lector (y quiero que puedan entrar varios)

30 Solución 0 (mala): escritor //globales long mutexesc = 1; //local semacquire(&mutexesc, 1); //region critica semrelease(&mutexesc, 1);

31 Solución 0 (mala): lector semacquire(&mutexesc, 1); //region critica semrelease(&mutexesc, 1);

32 Solución 1 (injusta) Dos semáforos, un mutex para la región crítica Un mutex para proteger el contador de lectores Un contador del número de lectores El primero echa el cierre y el último lo suelta Ojo! con el orden y quién se queda bloqueado

33 Solución 1 (injusta): escritor //globales long mutexesc = 1; long mutexnl = 1; int nl; //local semacquire(&mutexesc, 1); //region critica semrelease(&mutexesc, 1);

34 Solución 1 injusta: lector semacquire(&mutexnl, 1); if(nl++ == 0) semacquire(&mutexesc, 1); semrelease(&mutexnl, 1); //region critica semacquire(&mutexnl, 1); if(--nl == 0) semrelease(&mutexesc, 1); semrelease(&mutexnl, 1);

35 Solución 1 injusta Uso peculiar de mutex entrelazados, ojo!! Es injusta, los lectores se apropian del cierre y se lo pasan sólo entre ellos. Si hay un escritor esperando, no debería dejar entrar a mas lectores

36 Idea general, torniquetes (turnstile) Para evitar injusticias como las anteriores Uso peculiar de semáforos

37 torniquetes (turnstile) //globales long torn = 1; //local semacquire(&torn, 1); semacquire(&mutexesc, 1); semrelease(&torn, 1);

38 torniquetes (turnstile) semacquire(&torn, 1); semrelease(&torn, 1);

39 torniquetes (turnstile) Si espera para el mutex, tiene el torniquete El torniquete deja pasar en orden justo (es un semáforo)

40 Solución 2 justa: escritor con torniquete //globales long mutexesc = 1; long mutexnl = 1; long torn = 1; int nl; //local semacquire(&torn, 1); semacquire(&mutexesc, 1); semrelease(&torn, 1); //region critica semrelease(&mutexesc, 1);

41 Solución 2 justa: lector con torniquete semacquire(&torn, 1); semrelease(&torn, 1); semacquire(&mutexnl, 1); if(nl++ == 0) semacquire(&mutexesc, 1); semrelease(&mutexnl, 1); //region critica semacquire(&mutexnl, 1); if(--nl == 0) semrelease(&mutexesc, 1); semrelease(&mutexnl, 1);

42 Productor/consumidor Tenemos un hilo que produce fichas Tenemos otro hilo que las consume Problema muy muy común: Hilo que lee del micro produce audio, programa lo consume (teléfono) Hilo que lee de la red, hilo que lo consume (programa que usa la red) Hilo que que produce datos, hilo que los manda a otra máquina (programa que usa la red) Hilo que que produce datos, hilo que los procesa, se lo manda a otro hilo... (procesado de señal)

43 Productor/consumidor El productor deja las cosas en un buffer (con N huecos) El consumidor las recoge El buffer tiene que ser circular (mod N) El buffer es compartido, mutex Y si no hay nada, espera activa? Puedo usar semáforos

44 productor //global //local long fichsem; long holesem = N; char *buf[n]; int i; char *fich; i = 0; while(fich = produce()){ semacquire(&holesem, 1); buf[i++] = fich; i %= N; semrelease(&fichsem, 1); }

45 consumidor //local int i; char *fich; i = 0; while(1){ semacquire(&fichsem, 1); fich = buf[i++]; i %= N; semrelease(&holesem, 1); consume(fich) }

46 productor/consumidor (N=8) Consumido 5 Productor U U U U U

47 productor/consumidor Consumidor 5 Productor 2 U U U U U

48 productor/consumidor Consumidor U Productor 2 U U U U

49 Productor/consumidor Solución mala, da miedo, el buffer no tiene mutex ( lo necesita?), por si acaso, es una variable compartida, lo pongo Qué pasa si hay más de un productor o consumidor? Necesito que compartan i y j, uso el mutex general para acceder a todas las cosas compartidas

50 compartido //global long mutex = 1; long fichsem; long holesem = N; char *buf[n]; int i, j;

51 productor //local char *fich; while(fich = produce()){ semacquire(&holesem, 1); semacquire(&mutex, 1); buf[i++] = fich; i %= N; semrelease(&mutex, 1); semrelease(&fichsem, 1); }

52 consumidor //local int i; char *fich; while(1){ semacquire(&fichsem, 1); semacquire(&mutex, 1); fich = buf[j++]; j %= N; semrelease(&mutex, 1); semrelease(&holesem, 1); consume(fich) }

53 Productor/consumidor Podría tener dos mutex, uno para i y otro para j el buffer no tiene mutex ( lo necesita?) Qué pasa si no quiero sacarlos en orden? Y si no es un buffer y es otro tipo de recurso? Mantra: un recurso compartido, uso un mutex...

54 Problema de los filósofos cenando (aka pollos en la marmita) Tengo N filósofos (hilos de ejecución) en una mesa Cada filósofo necesita dos tenedores para comer Un filósofo duerme/come Cada filósofo es un proceso independiente Un filósofo se puede quedar dormido hasta que suceda una condición

55 Problema de los filósofos: deadlock Si un filósofo coge primero el tenedor izquierdo y luego el derecho Puede pasar que todos los filósofos cojan el tenedor derecho Se quedan durmiendo esperando cada uno al siguiente alrededor de la mesa

56 Alternativas de solución Tengo un mutex y cojo dos palillos a la vez Produce hambruna si dos filósofos se alternan Uso un camarero Serializo todas las peticiones Desperdicia recursos pero no hay hambruna

57 Solución con hambruna Coger los dos palillos Tener cuidado con como se hace que esperen (no bloquearme con un mutex... ) Ver la solución de los pollos (mismo problema)

58 monitores C. A. R. Hoare y Per Brinch Hansen Asociado al lenguaje Objeto, ADT o módulo especial que actúa como mecanismo de sincronización Tengo el estado compartido dentro del monitor Una serie de operaciones para acceder a él Hay el equivalente a un cierre global escondido asociado al monitor

59 monitores Estoy fuera o dentro del monitor, automaticamente se echa el cierre al entrar, se suelta al salir Se entra al monitor al llamar a uno de los métodos o funciones del monitor Si estoy dentro puedo llamar a otros métodos del monitor (el synchronized de java no sirve para implementar monitores).

60 variables condición Para esperar, necesito un mecanismo (no veo el cierre del monitor) condwait(cv) condsignal(cv) condwait(cv) se duerme y suelta el cierre condsignal(cv) se despierta y coge el cierre, una sóla operación para que no se cuele gente y cambie la condición

61 variables condición Si no hay nadie esperando a la condición, se pierde la variable no lleva asociada la condición, sólo es una cola y un timbre Ha varios tipos, en unos condsignal(cv) es lo último a lo que puedo llamar, (o condsignalreturn(cv)) en otros sólo se despierta cuando abandono el monitor...

62 Monitores Pocos lenguajes tienen soporte de monitores Se puede (y se debe) pensar en monitores al implementar un módulo, ADT u objeto En Plan 9 hay soporte para implementar variables condición rsleep(2) Una variable condición es una variable de tipo Rendez Van asociadas a un QLock. Tengo que poner el campo l apuntando al QLock del monitor al inicializar mi variable Rendez

63 Variables condición en Plan 9 typedef struct Rendez { QLock *l;... } Rendez; void rsleep(rendez *r) int rwakeup(rendez *r) int rwakeupall(rendez *r)

64 Variables condición en Plan 9 Rendez full; QLock l; int var; void init(void){ } full->l = &l;

65 Variables condición en Plan 9 void set(int b) { qlock(&l); if(var == 0) rsleep(&empty);... qunlock(&l); }

66 Variables condición en Plan 9 int dothings(int a) { qlock(&l); var = 1; rwakeup(&r);... qunlock(&empty); return; }

67 Paso de mensajes CSP 1978 C. A. R. Hoare Convertir productor/consumidor en una primitiva Bloqueante (para permitir sincronización) Usar un proceso para que ejecute las regiones críticas (transferir la propiedad junto con la comunicación) Similar a pipes (salvo que aquí puedo mandar punteros), salvo por eso la idea es parecida

68 libthread(2) incluir thread.h #include <thread.h> main es de la librería de threads, uso threadmain (el main de verdad viene de la librería de threads) void threadmain(int argc, char *argv[]) tamaño de la pila con mainstacksize, variable global (hay un valor por defecto) int mainstacksize

69 libthread(2) Creo threads (colaborativos, de usuario) y procesos (expulsivos, de kernel) int proccreate(void (*fn)(void*), void *arg, uint stacksize) int threadcreate(void (*fn)(void*), void *arg, uint stacksize) Cada proceso con viene con un thread encima (incluido main) Para salir void threadexits(char *status) void threadexitsall(char *status)

70 libthread(2) Para identificar un thread (como pids) int threadid(void) Para poner nombre a un thread (para tstack y errores en general) void threadsetname(char *name)

71 libthread(2), ejemplo tid.c, ejemplo tonto tincr.c, ejemplo contador con threads

72 libthread(2) El primer parámetro es un puntero a función int proccreate(void (*fn)(void*), void *arg, uint stacksize) int threadcreate(void (*fn)(void*), void *arg, uint stacksize)

73 libthread(2) El primer parámetro es un puntero a función El nombre de una función es su dirección (valor para pasar al puntero) Un puntero tiene un tipo, que es el de una función Una función para un thread o un proc tiene que tener este aspecto: void procfunct(void *v) Ojo con los parámetros, puede haber condiciones de carrera

74 libthread(2) Los threads tienen memoria compartida Su pila vive en el segmento de datos, memoria compartida Pueden usar qlock (hay una implementación de rendezvous) Mejor si uso canales (forma diferente de pensar, modelo diferente)

75 Canal Tiene que verlo todos los implicados Implementa un productor/consumidor Un canal es como un buzón Se puede mandar a través de él (send) o recibir (recv) Puede tener espacio (buffering) dentro o no Si no hay espacio (no lo hay buffering o está lleno) send se bloquea hasta que alguien reciba Si no hay nada en el buffer y no hay nadie bloqueado mandando, recv se bloquea hasta que alguien mande

76 Canal Declaro un canal Channel *c; creo un canal Channel* chancreate(int elsize, int nel) elsize es el tamaño de un elemento (puedo mandar cosas diferentes) nel es el tamaño del buffer, si es cero no hay buffering libero un canal void chanfree(channel *c)

77 Canal Para mandar y recibir, primitivas int int recv(channel *c, void *v) send(channel *c, void *v) Son como memmove(2), copian la memoria al canal (si no hay buffering, al destino) Por eso recibe un puntero al trozo de memoria que copia

78 Canal Para mandar y recibir, funciones especializadas, reciben un valor, no un puntero void* recvp(channel *c) ulong recvul(channel *c) int sendp(channel *c, void *v) int sendul(channel *c, ulong v) Se usan más que las otras pero es importante entender las otras para entender alt que veremos más adelante

79 libthread(2), ejemplos tcnt.c contador con threads tpc.c, productor consumidor pong.c ping pong canales intercambiando un valor pong2.c lo mismo especializado con sendul recvul

80 libthread(2), ejemplo tticker.c, ejemplo paneles Cada panel se corresponde con un descriptor de fichero Tengo que pensar en términos de procesos conectados por canales

81 libthread(2), operaciones operaciones con mas de un canal a la vez int cada operación alt(alt *alts); typedef struct Alt Alt; struct Alt { Channel *c; void *v; int op; };

82 libthread(2), operaciones cada constante una operación mejor usar enum #define CHANEND 0 //indica el final de alts #define CHANSND 1 //para mandar #define CHANRCV 2 //para recibir #define CHANNOP 3 //nop (no usar) #define CHANNOBLK 4 //no bloqueante (no usar)

83 libthread(2), ejemplo dentro de la función que hace el alt enum{ WR = 0, EXIT, END, }; int i; //ambos canales de enteros Alt a[] = { [WR] {wrc,&i,chanrcv}, [EXIT] {exitc,&i,chanrcv}, [END] {nil,nil,chanend}, };

84 libthread(2), ejemplo switch(alt(a)){ case WR: //lo que hace WR return; case EXIT: //lo que hace EXIT break; default: sysfatal("bad alt"); break; }

85 libthread(2), ejemplo etticker.c, ejemplo paneles quiero añadir mensajes de temperatura, tiempo uso alt(2) para decorar el thread el canal de broadcast no cambia su interfaz y me aisla

86 libthread(2), ejemplos mouse.c, eventos de raton con canales resize.c eventos de raton y eventos de resize slider.c es una slider, barra de desplazamiento

87 libthread(2), ejemplos texec.c, como hacer un exec(2) con un proceso usando libthread

88 libthread(2), cómo organizar un programa Un proc para cada llamada bloqueante sleep, read, write por ejemplo. Un thread representante de esos procs en un proc con datos compartidos Un thread por cada hilo separado de ejecución

89 libthread(2), cómo organizar un programa Para comunicación de N a 1 Se pueden usar valores de un canal O alternativamente usar alt Depende del problema

90 libthread(2), condiciones de carrera típicas Usar un canal no me libra Ejemplo, compartir los canales de respuesta y de petición ( quien se lleva el mensaje?). Mando un puntero a un canal para que me respondan por él Recordar liberarlo con chanfree

91 libthread(2), deadlock Es normal si no tengo cuidado Igual que antes, dependencias circulares mandando/recibiendo Ojo con alt Intento hacerme dependencias y comunicación sencillas