Comunicación y sincronización entre procesos Realizado por Kepa Bengoetxea Kortazar

Referencias –Descripción Funcional de los Sistemas Operativos.-Iñaki Alegria –UNIX.Programación Avanzada.-Manuel Márquez –Programación en Linux con ejemplos. Kurt Wall – cacionySincronizacion.htmhttp://wwwdi.ujaen.es/~lina/TemasSO/CONCURRENCIA/1Comuni cacionySincronizacion.htm – mutua)‏ – s)‏

Motivación: Estudiar mecanismos de comunicación entre los procesos. Puede verse la concurrencia de procesos como la ejecución simultánea de varios procesos Los distintos procesos dentro de un ordenador no actúan de forma aislada. Por un lado, algunos procesos cooperan para lograr un objetivo común. Por otro lado, los procesos compiten por el uso de unos recursos limitados, como el procesador, la memoria o los ficheros. Estas dos actividades de cooperación y competición llevan asociada la necesidad de algún tipo de comunicación entre los procesos. Parte de este tema lo dedicaremos a estudiar mecanismos de comunicación entre los procesos.

Mecanismos de comunicación y sincronización entre procesos Se utiliza para que los diferentes procesos puedan compartir un mismo recurso. Un recurso puede ser: CPU, dispositivos de E/S, variables, rutinas etc... Existen 2 tipos de recursos:  Recursos Compartibles  Recursos No Compartibles

Comunicación y sincronización entre procesos Recursos Compartibles en el tiempo:  Los que se pueden compartir concurrentemente.  Se puede tener también recursos compartibles de grado k, es decir, sólo puede ser accedido por k procesos a la vez.  Ejm: los ficheros de lectura, áreas de memoria o datos no modificables

Comunicación y sincronización entre procesos Los recursos No Compartibles en el tiempo:  Serán aquellos que en cada momento sólo pueden estar siendo accedidos por un proceso.  Ejm: cpu, ficheros abiertos para sólo escritura, teclado, áreas de memoria o datos modificables

Técnicas o Mecanismos de Comunicación entre procesos Existen diferentes técnicas de comunicaciones:  Mediante el uso de mensajes o señales (Teoría y Práctica)‏  Mediante el uso variables compartidas ó Memoria Compartida (Teoría)‏  Archivos comunes (visto ISO)‏  Archivos especiales como:Tuberías o Pipes (Práctica)‏

Mensajes o Señales Usando mensajes o señales:  Los programas envían y reciben mensajes siempre y cuando el canal de comunicación lo permita.  Los procesos se pueden bloquear a la espera de un mensaje y despertarse a la llegada de un mensaje.  Ejm: Si un proceso envia un mensaje KILL a otro proceso, lo mata y termina.

Variables Compartidas.Hilos vs Procesos El proceso es el entorno computacional incluye:  Segmento de Texto: Programa binário ó código objeto  Segmento de Datos: Variables globales y estáticas  Archivos abiertos, y otros recursos como impresora, teclado....  Motor de ejecución ó hilo: Segmento de pila: Un stack frame se introduce o saca en función de si se llama o se vuelve de la llamada a una función. Consta de las variables locales y parámetro de función (privados) del hilo. Información de Contexto que el S.O necesita para gestionar dichos hilos: estado actual, estado de los registros de la cpu, contador de programa...

Variables Compartidas.Hilos vs Procesos Proceso Clásico Estado Archivos Pila Datos Otros Recursos Programa binario Motor de Ejecución Proceso Multihilo Estado Archivos Pila Datos Otros Recursos Programa binario Motores de Ejecución

Variables Compartidas.Hilos vs Procesos En los Sistemas Operativos modernos (Windows, Mac y Linux 2.2 en adelante) los procesos pueden contener múltiples motores de ejecución ó hilos. En un proceso moderno(cómputo multihilo) los diferentes hilos utilizan el mismo programa, datos globales del proceso, archivos y otros recursos, pero cada uno tiene sus propios datos locales y estado. Un proceso clásico: Cada proceso tiene un estudio privado donde sólo hay un hilo ejecutándose en él.

Variables Compartidas.Hilos vs Procesos Multihilo significa que si el programa fuera ejecutado en un sistema con multiprogramación, dos o más hilos podrían estar compartiendo el procesador por multiplexado de tiempo con otro, incluso aunque estuvieran utilizando el mismo programa y los mismos datos. Además, si tal cómputo multihilo se ejecutara en un computador con más de un procesador, sería posible que dos o más hilos se ejecutasen en paralelo.

Variables Compartidas.Hilos vs Procesos Se crean y destruyen más rápidamente que los procesos. No es necesario asignar recursos, los poseen todos los hilos del proceso. La conmutación entre hilos del mismo proceso, requiere de menor coste que la conmutación de procesos, sólo es necesario salvar los registros y conmutar la pila. Los hilos de un proceso comparten el mismo espacio de direccionamiento virtual. Existe menor sobrecarga de comunicaciones, todos los hilos de una tarea comparten memoria.

Implementación de hilos usando C y las librerías de POSIX pthread_create(thread_id, attr, func, args): Crea un nuevo hilo de ejecución. El hilo de ejecución empieza en func y se le pasan los parámetros args. pthread_exit (status): El hilo que la invoca finaliza su ejecución. pthread_join (thread_id): Suspende la ejecución del hilo que invoca esta llamada, hasta que el thread_id acabe. pthread_t pthread_self() Devuelve el identificador del thread que la invoca.

Variables Compartidas.Hilos #include void * process(void * arg){ static int sum=0;int num; num=atoi(arg); sum=sum+num; printf("%d ", sum); fflush(stdout); pthread_exit(0);} int main(){ pthread_t th_a, th_b; pthread_create(&th_a, NULL, process, "100"); pthread_create(&th_b, NULL, process, "200"); sleep(1); exit(0); } gcc -pthread -o hilosvar hilosvar.c

Variables Compartidas: Sección Crítica Concepto de sección crítica Una sección crítica es una zona de código en la que se accede a variables compartidas por varios procesos.

Variables Compartidas:Sección Crítica Ejemplo de sección crítica:  Ejm: Dado el siguiente programa donde "buff" e "in" son variables compartidas. Este programa introduce datos en un buffer. Imaginemos que se están ejecutando dos procesos P1 y P2 del mismo programa y existe un tercer proceso P3 que se encarga de consumir los datos del buffer. P1 P2... buff P3 p=in; buff[p]=item; in++; SC

Variables Compartidas:Sección Crítica  ¿Qué ocurriría si se ejecutase en el tiempo de la siguiente manera? P1 p=in (in->1;p=1)‏ buff[p]=item(item='a') (buff[1]='a')‏ in++(in->2)‏ tiempo P2 p=in (in->1;p=1)‏ buff[p]=item (item='b') (buff[1]='b')‏ in++(in->3)‏

Variables Compartidas:Sección Crítica  Ejm:Telemaratón donde varios teleoperadores, cada uno ejecuta programa.exe que ejecutan las siguientes instrucciones: Select dinero_acum,num_llamada from SOLIDARIDAD; dinero=dinero_acum+dfdinero numllamada=num_llamada+1 update SOLIDARIDAD set dinero_acum =dinero,num_llamada=numllamada commit

Variables Compartidas:Sección Crítica  En función de la ejecución se obtendrían resultados diferentes.  El uso de variables compartidas añade los siguientes problemas: Exclusión mutua Progresión finita Espera Acotada Interbloqueo

Variables Compartidas:Exclusión mutua Los algoritmos de exclusión mutua se usan en programación concurrente para evitar que fragmentos de código conocidos como secciones críticas accedan concurrentemente a recursos que no pueden ser compartidos, es decir, que si un proceso está accediendo a la sección crítica que ningún otro proceso pueda ejecutarlo a la vez(de manera concurrente)‏ Ejm:p=in; buff[p]=item; in++; es una SECCION CRÍTICA que en caso de que un proceso las este modificando no se debe dejar que otro proceso las manipule.

Variables Compartidas: Progresión Finita Progresión Finita: Si ningún proceso está ejecutando dentro de la sección crítica, la decisión de qué proceso entra en la sección se hará sobre los procesos que desean entrar. Los procesos que no quieren entrar, no pueden tomar parte de esta decisión. Además esta decisión, se debe tomar en tiempo finito.

Comunicación.Variables Compartidas:Espera Acotada Espera Acotada: Que ningún proceso tenga que esperar un intervalo de tiempo arbitrariamente grande para entrar en su Sección Crítica

Comunicación.Variables Compartidas:Interbloqueo Interbloqueo: Interbloqueo puede darse entre dos procesos P1 y P2 cuando los dos procesos compiten por recursos que comparten, pero nínguno de ellos puede proseguir ya que que los recursos que necesita P1 los tiene retenido P2 y los que necesita P2 los tiene retenido P1. Ejm:2 transferencias de cuenta bancarias entre las mismas cuentas 1 y 2. SESION 1: UPDATE CTA SET SALDO=SALDO WHERE IDCTA=1; SESION 2: UPDATE CTA SET SALDO=SALDO WHERE IDCTA=2; SESION 1: UPDATE CTA SET SALDO=SALDO WHERE IDCTA=2; SESION 2: UPDATE CTA SET SALDO=SALDO WHERE IDCTA=1; SE PRODUCE EL INTERBLOQUEO SESION 1:COMMIT SESION 2:COMMIT

Métodos de Comunicación: SECCIÓN CRÍTICA=todo recurso compartido no compartible concurrentemente por más de k procesos. Para acceder a una sección crítica necesitaré un protocolo de E y otro de S. Poner_petición (pide acceso a la SC)‏ SC Sacar_petición (salir de la SC)‏ Diferentes métodos acceder a SC previniendo problemas:  Espera activa: Software o Hardware  Semáforos

Métodos de Comunicación: Para todas las soluciones tendremos en cuenta las siguientes suposiciones: –2 procesos ejecutándose concurrentemente. –Ambos procesos comparten sección crítica. –El cambio de contexto se puede dar en cualquier momento. –Uno de ellos podría finalizar correctamente.

Métodos de Comunicación.Espera Activa:Software.1ºSol Espera activa: Software:Primera Solución Se usa una variable global VAB. Si VAB=i, el proceso Pi es el que puede progresar. while (i<5){ #poner_peticion_1: while (VAB=2) {NOP;} Sección Crítica #sacar_petición_1: VAB=2; i++;} while (j<3){ #poner_peticion_2: while (VAB=1) {NOP;} Sección Crítica #sacar_petición_2: VAB=1; j++;} Problema:No hay progresión finita si uno de los procesos termina correctamente.

Métodos de Comunicación.Espera Activa:Software.2ºSol Espera activa: Software:Segunda Solución Hay un indicador por cada proceso (P1,P2). C1=0 significa que P1 va a pasar a la SC, C2=0 que P2 va a pasar a la SC. C1 y C2 se inicializan a 1. while (i<5){ #poner_peticion_1: while (C2=0) {NOP;} C1=0; Sección Crítica #sacar_petición_1: C1=1; i++;} while (j<3){ #poner_peticion_2: while (C1=0) {NOP;} C2=0; Sección Crítica #sacar_petición_2: C2=1; j++;} Problema:Exclusión mutua-Peligro de que el otro proceso coja el control antes de marcar C1=0 o C2=0.

Espera Activa:Software.3ºSol Espera activa: Software:Tercera Solución Usamos los mismo indicadores que el anterior, pero ahora primero marcamos y luego preguntamos. C1=0 significa que P1 quiere entrar a la SC, C2=0 que P2 quiere entrar a la SC. C1 y C2 se inicializan a 1. while (i<5){ #poner_peticion_1: C1=0; while (C2=0) {NOP;} Sección Crítica #sacar_petición_1: C1=1; i++;} while (j<3){ #poner_peticion_2: C2=0; while (C1=0) {NOP;} Sección Crítica #sacar_petición_2: C2=1; j++;} Problema:Interbloqueo que los 2 procesos marquen a 0, nunca se cambiará su valor a 1, y se bloquearán en el while.

Métodos de Comunicación.Espera Activa:Software.4ºSol Espera activa: Software:Cuarta Solución Usamos los mismo indicadores que el anterior, pero ahora sustituimos la espera NOP por la ejecución de alguna instrucción que rompa el interbloqueo. C1=0 significa que P1 quiere entrar a la SC, C2=0 que P2 quiere entrar a la SC. C1 y C2 se inicializan a 1. while (i<5){ #poner_peticion_1: C1=0; while (C2=0) {C1=1;C1=0;} Sección Crítica #sacar_petición_1: C1=1; i++;} while (j<3){ #poner_peticion_2: C2=0; while (C1=0) {C2=1;C2=0;} Sección Crítica #sacar_petición_2: C2=1; j++;} Problema:Espera Acotada, puede ocurrir un aplazamiento indefinido si se ejecutan en tándem, una instrucción uno y acontinuación otra el otro. No vale:Marcapasos o controles de vuelos.

Métodos de Comunicación.Espera Activa:Software.Sol:Dekker Software: Algoritmo de Dekker  En caso de c1 y c2 esten a 0 se utiliza otra variable vab que indica cual de las 2 debe continuar.  P1 antes de pedir pone su indicador c1 a 0, en caso de que el P2 también tenga su indicador a 0, mira la variable vab. Si vab es igual a 1 entraría directamente en la SC. Si vab es igual a 2, pone c1=1 para que P2 entre directamente en la SC y no haya interbloqueo; mientras vab sea 2 no hace nada P1. De la que vab se pone a 1, se pone c1=0, y entra en la SC directamente.  Al salir SC se pone vab=2 y c1=1(libera el recurso)‏

Métodos de Comunicación.Espera Activa:Software.Sol:Dekker P1 While (i<5){ #poner_peticion_1: c1=0; while (c2=0)‏ {if vab=2 {c1=1;while vab=2 NOP;c1=0;}} Sección Crítica #sacar_petición_1: c1=1;vab=2; i++;} P2 While (j<3){ #poner_peticion_2: c2=0; while (c1=0)‏ {if vab=1 {c2=1;while vab=1 NOP;c2=0;}} Sección Crítica #sacar_petición_2: c2=1;vab=1; j++;}

Métodos de Comunicación.Espera Activa:Software.Sol:Dekker Software: Vamos a ver si Algoritmo de Dekker cumple los siguientes casos para que su solución sea correcta:  Exclusión mutua: Comprobar que si los dos quieren entrar a la vez, sólo lo haga uno, y si uno entra a dentro no deja entrar al otro: SI, ya que...(en caso de que quieran entrar los dos, VAB decide cual de los dos entra, ya que VAB sólo puede tener el valor 1 o 2 al mismo tiempo. Por ejm: En caso de que P1 y P2 marquen sus respectivas C1 y C2 a 0 indicando que quieren entrar, en caso de que VAB sea 2, será P1 quien entre dentro del “then” del if, para poner C1=1, y quedarse en NOP mientras VAB sea 2. Es cuando P2 coge el control y como en su while externo pregunta mientras C1=0, nos saltaremos dicho while, entrando directamente en la SC; y viceversa si VAB fuera 1.)‏

Métodos de Comunicación.Espera Activa:Software.Sol:Dekker Software: Vamos a ver si Algoritmo de Dekker cumple los siguientes casos para que su solución sea correcta:  Progresión finita: Si ningún proceso está ejecutando dentro de la sección crítica, la decisión de qué proceso entra en la sección se hará sobre los procesos que desean entrar. Los procesos que no quieren entrar, no pueden tomar parte de esta decisión. Además esta decisión, se debe tomar en tiempo finito.:¿Si finaliza correctamente P1 o P2 puede continuar el otro, y este otro puede estar ejecutándose el solo continuamente? SI ya que...(Cuando uno de los procesos finaliza el otro puede seguir, ya que, el que finaliza cede el control al otro.Por ejm:P2 al finalizar pone C2=1 y vab=1 para entrar P1 en el while externo o vab=1 en el interno, en caso de estar sólo P1 podría ejecutarse sucesivamente ya que se pregunta mientras C2=0, por lo que no entra en el while y entra directamente en la SC)‏

Métodos de Comunicación.Espera Activa:Software.Sol:Dekker Software: Vamos a ver si Algoritmo de Dekker cumple los siguientes casos para que su solución sea correcta:  Interbloqueo: Interbloqueo puede darse entre dos procesos P1 y P2 cuando los dos procesos compiten por recursos que comparten, pero nínguno de ellos puede proseguir ya que que los recursos que necesita P1 los tiene retenido P2 y los que necesita P2 los tiene retenido P1. No se produce el interbloqueo ya que...( si los dos marcan que quieren entrar será la variable VAB la que determine cual de los dos seguirá. Por ejm,en caso de que P1 y P2 marquen sus respectivas C1 y C2 a 0 indicando que quieren entrar, en caso de que VAB sea 2, será P1 quien entre dentro del “then” del if, para poner C1=1, y quedarse en NOP mientras VAB sea 2. Liberando a P2 del while externo, entrando directamente en la SC, ; y viceversa si VAB fuera 1.)‏

Métodos de Comunicación.Espera Activa:Software.Sol:Dekker Software: Vamos a ver si Algoritmo de Dekker cumple los siguientes casos para que su solución sea correcta: Espera Acotada: Que ningún proceso tenga que esperar un intervalo de tiempo arbitrariamente grande para entrar en su Sección Crítica. Si ya que... (En la salida se facilita que el otro proceso pueda entrar en la sección crítica. Si un proceso intenta reentrar rápidamente en su sección crítica, poniendo su bandera a 0, el otro proceso estará obligado a entrar en el cuerpo del while externo. Pero esta vez el proceso favorecido es el, ya que vab tiene su valor. Así es que dicho proceso salta el cuerpo del if y ejecuta de forma repetida la prueba del while externo, hasta que el proceso que quiso reentrar "humildemente", desconecte su bandera, permitiendo entrar al otro en su sección crítica. Evitando de esta manera que ningún proceso tenga que esperar un intervalo de tiempo arbitrariamente grande para entrar en su sección crítica. Como mucho espera la terminación del otro proceso, ya que una vez finalizado cede el control al otro)‏

Métodos de Comunicación.Espera Activa:Software.Sol:Peterson Ejm: Tendremos dos procesos que alteran el valor de número de líneas, un primer proceso de 1 a 20 y un segundo proceso de 1 a 30. La sección crítica esta formada por la siguiente instrucción: nolineas := nolineas + 1; Ya que si ambos procesos leen a la vez el valor del nolineas se perderá uno de los incrementos. Ya que esta instrucción aunque parece que es atómica no lo es sino que consta de:  mov regX, nolineas;  inc regX;  mov nolineas, regX;

Condición de Carrera o exclusión mutua

Métodos de Comunicación.Espera Activa:Software.Sol:Peterson Solución: Algoritmo de Peterson program peterson;(*PASCAL Total de Líneas: 50*)‏ var nolineas, turno : integer; band1, band2: boolean; begin nolineas := 0;(*SC*) turno := 1;(*Prioridad*)band1 := false;(*true si quiere entrar uno*) band2 := false; cobegin uno; dos coend; writeln('Total de Líneas: ',nolineas) (*SC=nolineas*)‏ end.

Métodos de Comunicación.Espera Activa:Software.Sol:Peterson process uno; var lin: integer; begin for lin := 1 to 20 do begin band1:= true; (*entrar*)‏ turno:= 2; (* da prioridad a 2*)‏ while band2 and (turno = 2) do null; nolineas := nolineas + 1; (*SC*)‏ band1:= false (* salir *)‏ end end;

Métodos de Comunicación.Espera Activa:Software.Sol:Peterson process dos; var lin: integer; begin for lin := 1 to 30 do begin band2:= true; (* entrar *)‏ turno:= 1; (* prioridad a 1*)‏ while band1 and (turno = 1) do null; nolineas := nolineas + 1; (*SC*)‏ band2:= false (* salir *)‏ end end;

Métodos de Comunicación.Espera Activa:Software.Sol:Peterson Algoritmo de Peterson:  Se puede apreciar que para entrar en la sección crítica, el proceso uno primero asigna true a band1 y luego afirma que es el turno del proceso dos para entrar si así lo desea (turno=2).  Si ambos procesos tratan de entrar a la vez, se asignará turno como 1 y 2 aproximadamente al mismo tiempo. Sólo una de estas asignaciones durará; la otra ocurrirá, pero será reemplazada de inmediato. El valor eventual de turno decide a cual de los dos procesos se le permitirá entrar primero en su sección crítica.

Métodos de Comunicación.Espera Activa:Software.Sol:Peterson Algoritmo de Peterson:  Ahora demostraremos que esta solución es correcta. Necesitamos demostrar: Que se conserva la exclusión mutua. Que se respeta el requisito de progresión finita. Que se cumple el requisito de espera acotada. Que se cumple el requisito de interbloqueo.

Métodos de Comunicación.Espera Activa:Hardware  Espera Activa: Hardware Test-and-set es una instrucción HW que significa que viene en los circuitos del ordenador y es indivisible. En un sistema multiprocesador de memoria compartida, se usa la operación test-and-set indivisible sobre una bandera para esperar hasta que el otro procesador la despeja. La operación test-and-set realiza ambas operaciones(test y set) sin liberar el bus de memoria a otro procesador. Así, cuando el código deja la sección crítica, se despeja la bandera. Esto se conoce como "spin lock" o "espera activa".

Métodos de Comunicación.Espera Activa:Hardware Variable Compartida: int cerrojo; Inicializamos: int cerrojo=0; Cada proceso x poner_peticion_x: while (test_and_set(&cerrojo)) NOP; Sección Crítica sacar_petición_x: cerrojo=0; La mayoría de los procesadores incluyen la instrucción máquina test_and_set. Simulación en C: boolean test_and_set(int *i)‏ {if (*i==0) {*i=1; return false;} else {return true;} } -Se ejecuta en su totalidad -No esta sujeta a interrupciones

Métodos de Comunicación.Espera por Bloqueo:Semáforos Espera por bloqueo. Semáforos:  Espera activa: malgasta tiempo del procesador. Se usa cuando la espera por la sección crítica es corta. Ejm: Un consumidor- productor en un buffer.  Espera por bloqueo: Se implementa para exclusión mutua a largo plazo. Ejm:Acceso a disco. Es un mecanismo que pone en estado bloqueado al proceso que la espera, y desbloquea cuando se produce el evento por el que espera.

Métodos de Comunicación.Espera por Bloqueo:Semáforos Espera por bloqueo. Semáforos:  Un semáforo es una variable entera protegida cuyo valor puede ser accesado y alterado tan sólo por las operaciones atómicas: wait, signal e initial.  Los semáforos binarios(mutex) solo puede tomar valores menores o igual a 1.  Los semáforos contadores pueden tomar valores enteros mayores que uno.

Métodos de Comunicación: Ejm: initial(s,1)‏ wait (s)‏ S.C signal(s)‏ * wait,signal,initial son indivisibles

Métodos de Comunicación:Espera por Bloqueo:Semáforos Wait: La operación wait en el semáforo S, escrito wait(S), opera de la siguiente manera: S:=S-1; if S<0 then esperar(S); *La operación esperar(S) suspende al proceso que la ha invocado y lo introduce en una cola de espera asociada a S. atómicamente

Métodos de Comunicación: Signal: La operación signal en el semáforo S, escrito signal(S), opera de la siguiente manera: S:=S+1; if S<=0 then despertar(S); *La operación despertar(S) extrae un proceso de la cola de espera asociada a S y lo activa. atómicamente

Métodos de Comunicación: initial: La operación initial en el semáforo S, escrito initial(S,5), inicializa el semáforo a un valor en concreto, permitiendo definir el número de procesos que pueden acceder a la sección crítica de manera concurrente o a la vez. S=5

Métodos de Comunicación: program sem01; var nolineas: integer; mutex: semaphore; (* declaración del semáforo *)‏ begin nolineas := 0; initial(mutex,1); (* se inicializa el semáforo *)‏ cobegin uno; dos coend; writeln('Total de Líneas = ',nolineas)‏ end.

Métodos de Comunicación: process uno; var lin: integer; begin for lin := 1 to 20 do begin wait(mutex); (* Espera por el semáforo *)‏ nolineas := nolineas + 1; (* sección crítica *)‏ signal(mutex) (* libera el semáforo *)‏ end end; (* uno *)‏

Métodos de Comunicación: process dos; var lin: integer; begin for lin := 1 to 20 do begin wait(mutex); nolineas := nolineas + 1; signal(mutex)‏ end end; (* dos *)‏

Tuberías Ref. Práctica