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

Comunicación y sincronización entre procesos

Realizado por Kepa Bengoetxea [email protected]

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

–http://wwwdi.ujaen.es/~lina/TemasSO/CONCURRENCIA/1ComunicacionySincronizacion.htm

–http://tiny.uasnet.mx/prof/cln/ccu/mario/sisop/sisop03.htm(exclusión mutua)

–http://tiny.uasnet.mx/prof/cln/ccu/mario/sisop/sisop05.htm(semaforos)

http://wwwdi.ujaen.es/~lina/TemasSO/CONCURRENCIA/1ComunicacionySincronizacion.htm

http://wwwdi.ujaen.es/~lina/TemasSO/CONCURRENCIA/1ComunicacionySincronizacion.htm

http://tiny.uasnet.mx/prof/cln/ccu/mario/sisop/sisop03.htm

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


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


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...


Proceso Clásico

EstadoArchivos

Pila

DatosOtros

RecursosPrograma

binario

Motor de

Ejecución

Proceso Multihilo

EstadoArchivos

Pila

DatosOtros

RecursosPrograma

binario

Motores de

Ejecución


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.


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.


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 <stddef.h>

#include <stdio.h>

#include <pthread.h>

#include <stdlib.h>

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


¿Qué ocurriría si se ejecutase en el tiempo de la siguiente manera?

P1p=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)


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


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-10000 WHERE IDCTA=1;

SESION 2: UPDATE CTA SET SALDO=SALDO-20000 WHERE IDCTA=2;

SESION 1: UPDATE CTA SET SALDO=SALDO+10000 WHERE IDCTA=2;

SESION 2: UPDATE CTA SET SALDO=SALDO+20000 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


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.


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ºSolEspera 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.


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)


P1While (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++;}


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.)



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)



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.)


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

T Proceso Operación reg1 reg2 contador

1P1 0 0 02P1 1 0 0

3P2 1 0 04P2 1 1 0

5P1 1 1 16P2 1 1 1

mv nolineas reg1inc reg1

mv nolineas reg2inc reg2

mv reg1 nolineasmv reg2 nolineas


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.


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;


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;


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.


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.


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


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


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 *)


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

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

Documents

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